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  * setting the proper context error and throwing a check_size_exception if it
1413  * fails.
1414  *
1415  * The second lambda tests the validity of the value check, setting the proper
1416  * context error and throwing a check_value_exception if it failed.
1417  */
1418 template<typename T, size_t N>
1419 auto GetCheckers(const SourceProp prop, const al::span<T,N> values)
1420 {
1421     return std::make_pair(
1422         [=](size_t expect) -> void
1423         {
1424             if(values.size() == expect) return;
1425             throw al::context_error{AL_INVALID_ENUM,
1426                 "Property 0x%04x expects %zu value(s), got %zu", prop, expect, values.size()};
1427         },
1428         [](bool passed) -> void
1429         {
1430             if(passed) return;
1431             throw al::context_error{AL_INVALID_VALUE, "Value out of range"};
1432         }
1433     );
1434 }
1435
1436 template<typename T>
1437 NOINLINE void SetProperty(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
1438     const al::span<const T> values)
1439 {
1440     auto [CheckSize, CheckValue] = GetCheckers(prop, values);
1441     ALCdevice *device{Context->mALDevice.get()};
1442
1443     switch(prop)
1444     {
1445     case AL_SOURCE_STATE:
1446     case AL_SOURCE_TYPE:
1447     case AL_BUFFERS_QUEUED:
1448     case AL_BUFFERS_PROCESSED:
1449         if constexpr(std::is_integral_v<T>)
1450         {
1451             /* Query only */
1452             throw al::context_error{AL_INVALID_OPERATION,
1453                 "Setting read-only source property 0x%04x", prop};
1454         }
1455         break;
1456
1457     case AL_BYTE_LENGTH_SOFT:
1458     case AL_SAMPLE_LENGTH_SOFT:
1459     case AL_SEC_LENGTH_SOFT:
1460     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
1461     case AL_SEC_OFFSET_LATENCY_SOFT:
1462     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
1463     case AL_SEC_OFFSET_CLOCK_SOFT:
1464         /* Query only */
1465         throw al::context_error{AL_INVALID_OPERATION, "Setting read-only source property 0x%04x",
1466             prop};
1467
1468     case AL_PITCH:
1469         CheckSize(1);
1470         CheckValue(values[0] >= T{0});
1471
1472         Source->Pitch = static_cast<float>(values[0]);
1473         return UpdateSourceProps(Source, Context);
1474
1475     case AL_CONE_INNER_ANGLE:
1476         CheckSize(1);
1477         CheckValue(values[0] >= T{0} && values[0] <= T{360});
1478
1479         Source->InnerAngle = static_cast<float>(values[0]);
1480         return CommitAndUpdateSourceProps(Source, Context);
1481
1482     case AL_CONE_OUTER_ANGLE:
1483         CheckSize(1);
1484         CheckValue(values[0] >= T{0} && values[0] <= T{360});
1485
1486         Source->OuterAngle = static_cast<float>(values[0]);
1487         return CommitAndUpdateSourceProps(Source, Context);
1488
1489     case AL_GAIN:
1490         CheckSize(1);
1491         CheckValue(values[0] >= T{0});
1492
1493         Source->Gain = static_cast<float>(values[0]);
1494         return UpdateSourceProps(Source, Context);
1495
1496     case AL_MAX_DISTANCE:
1497         CheckSize(1);
1498         CheckValue(values[0] >= T{0});
1499
1500         Source->MaxDistance = static_cast<float>(values[0]);
1501         return CommitAndUpdateSourceProps(Source, Context);
1502
1503     case AL_ROLLOFF_FACTOR:
1504         CheckSize(1);
1505         CheckValue(values[0] >= T{0});
1506
1507         Source->RolloffFactor = static_cast<float>(values[0]);
1508         return CommitAndUpdateSourceProps(Source, Context);
1509
1510     case AL_REFERENCE_DISTANCE:
1511         CheckSize(1);
1512         CheckValue(values[0] >= T{0});
1513
1514         Source->RefDistance = static_cast<float>(values[0]);
1515         return CommitAndUpdateSourceProps(Source, Context);
1516
1517     case AL_MIN_GAIN:
1518         CheckSize(1);
1519         CheckValue(values[0] >= T{0});
1520
1521         Source->MinGain = static_cast<float>(values[0]);
1522         return UpdateSourceProps(Source, Context);
1523
1524     case AL_MAX_GAIN:
1525         CheckSize(1);
1526         CheckValue(values[0] >= T{0});
1527
1528         Source->MaxGain = static_cast<float>(values[0]);
1529         return UpdateSourceProps(Source, Context);
1530
1531     case AL_CONE_OUTER_GAIN:
1532         CheckSize(1);
1533         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1534
1535         Source->OuterGain = static_cast<float>(values[0]);
1536         return UpdateSourceProps(Source, Context);
1537
1538     case AL_CONE_OUTER_GAINHF:
1539         CheckSize(1);
1540         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1541
1542         Source->OuterGainHF = static_cast<float>(values[0]);
1543         return UpdateSourceProps(Source, Context);
1544
1545     case AL_AIR_ABSORPTION_FACTOR:
1546         CheckSize(1);
1547         CheckValue(values[0] >= T{0} && values[0] <= T{10});
1548
1549         Source->AirAbsorptionFactor = static_cast<float>(values[0]);
1550         return UpdateSourceProps(Source, Context);
1551
1552     case AL_ROOM_ROLLOFF_FACTOR:
1553         CheckSize(1);
1554         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1555
1556         Source->RoomRolloffFactor = static_cast<float>(values[0]);
1557         return UpdateSourceProps(Source, Context);
1558
1559     case AL_DOPPLER_FACTOR:
1560         CheckSize(1);
1561         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1562
1563         Source->DopplerFactor = static_cast<float>(values[0]);
1564         return UpdateSourceProps(Source, Context);
1565
1566
1567     case AL_SOURCE_RELATIVE:
1568         if constexpr(std::is_integral_v<T>)
1569         {
1570             CheckSize(1);
1571             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1572
1573             Source->HeadRelative = values[0] != AL_FALSE;
1574             return CommitAndUpdateSourceProps(Source, Context);
1575         }
1576         break;
1577
1578     case AL_LOOPING:
1579         if constexpr(std::is_integral_v<T>)
1580         {
1581             CheckSize(1);
1582             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1583
1584             Source->Looping = values[0] != AL_FALSE;
1585             if(Voice *voice{GetSourceVoice(Source, Context)})
1586             {
1587                 if(Source->Looping)
1588                     voice->mLoopBuffer.store(&Source->mQueue.front(), std::memory_order_release);
1589                 else
1590                     voice->mLoopBuffer.store(nullptr, std::memory_order_release);
1591
1592                 /* If the source is playing, wait for the current mix to finish
1593                  * to ensure it isn't currently looping back or reaching the
1594                  * end.
1595                  */
1596                 std::ignore = device->waitForMix();
1597             }
1598             return;
1599         }
1600         break;
1601
1602     case AL_BUFFER:
1603         if constexpr(std::is_integral_v<T>)
1604         {
1605             CheckSize(1);
1606             if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1607                 state == AL_PLAYING || state == AL_PAUSED)
1608                 throw al::context_error{AL_INVALID_OPERATION,
1609                     "Setting buffer on playing or paused source %u", Source->id};
1610
1611             std::deque<ALbufferQueueItem> oldlist;
1612             if(values[0])
1613             {
1614                 using UT = std::make_unsigned_t<T>;
1615                 std::lock_guard<std::mutex> buflock{device->BufferLock};
1616                 ALbuffer *buffer{LookupBuffer(device, static_cast<UT>(values[0]))};
1617                 if(!buffer)
1618                     throw al::context_error{AL_INVALID_VALUE, "Invalid buffer ID %s",
1619                         std::to_string(values[0]).c_str()};
1620                 if(buffer->MappedAccess && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
1621                     throw al::context_error{AL_INVALID_OPERATION,
1622                         "Setting non-persistently mapped buffer %u", buffer->id};
1623                 if(buffer->mCallback && buffer->ref.load(std::memory_order_relaxed) != 0)
1624                     throw al::context_error{AL_INVALID_OPERATION,
1625                         "Setting already-set callback buffer %u", buffer->id};
1626
1627                 /* Add the selected buffer to a one-item queue */
1628                 std::deque<ALbufferQueueItem> newlist;
1629                 newlist.emplace_back();
1630                 newlist.back().mCallback = buffer->mCallback;
1631                 newlist.back().mUserData = buffer->mUserData;
1632                 newlist.back().mBlockAlign = buffer->mBlockAlign;
1633                 newlist.back().mSampleLen = buffer->mSampleLen;
1634                 newlist.back().mLoopStart = buffer->mLoopStart;
1635                 newlist.back().mLoopEnd = buffer->mLoopEnd;
1636                 newlist.back().mSamples = buffer->mData;
1637                 newlist.back().mBuffer = buffer;
1638                 IncrementRef(buffer->ref);
1639
1640                 /* Source is now Static */
1641                 Source->SourceType = AL_STATIC;
1642                 Source->mQueue.swap(oldlist);
1643                 Source->mQueue.swap(newlist);
1644             }
1645             else
1646             {
1647                 /* Source is now Undetermined */
1648                 Source->SourceType = AL_UNDETERMINED;
1649                 Source->mQueue.swap(oldlist);
1650             }
1651
1652             /* Delete all elements in the previous queue */
1653             for(auto &item : oldlist)
1654             {
1655                 if(ALbuffer *buffer{item.mBuffer})
1656                     DecrementRef(buffer->ref);
1657             }
1658             return;
1659         }
1660         break;
1661
1662
1663     case AL_SEC_OFFSET:
1664     case AL_SAMPLE_OFFSET:
1665     case AL_BYTE_OFFSET:
1666         CheckSize(1);
1667         if constexpr(std::is_floating_point_v<T>)
1668             CheckValue(std::isfinite(values[0]));
1669
1670         if(Voice *voice{GetSourceVoice(Source, Context)})
1671         {
1672             auto vpos = GetSampleOffset(Source->mQueue, prop, static_cast<double>(values[0]));
1673             if(!vpos) throw al::context_error{AL_INVALID_VALUE, "Invalid offset"};
1674
1675             if(SetVoiceOffset(voice, *vpos, Source, Context, Context->mALDevice.get()))
1676                 return;
1677         }
1678         Source->OffsetType = prop;
1679         Source->Offset = static_cast<double>(values[0]);
1680         return;
1681
1682     case AL_SAMPLE_RW_OFFSETS_SOFT:
1683         if(sBufferSubDataCompat)
1684         {
1685             if constexpr(std::is_integral_v<T>)
1686             {
1687                 /* Query only */
1688                 throw al::context_error{AL_INVALID_OPERATION,
1689                     "Setting read-only source property 0x%04x", prop};
1690             }
1691         }
1692         break;
1693
1694     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
1695         if(sBufferSubDataCompat)
1696         {
1697             if constexpr(std::is_integral_v<T>)
1698             {
1699                 /* Query only */
1700                 throw al::context_error{AL_INVALID_OPERATION,
1701                     "Setting read-only source property 0x%04x", prop};
1702             }
1703             break;
1704         }
1705         CheckSize(1);
1706         if constexpr(std::is_floating_point_v<T>)
1707             CheckValue(values[0] >= T{0} && std::isfinite(static_cast<float>(values[0])));
1708         else
1709             CheckValue(values[0] >= T{0});
1710
1711         Source->Radius = static_cast<float>(values[0]);
1712         return UpdateSourceProps(Source, Context);
1713
1714     case AL_SUPER_STEREO_WIDTH_SOFT:
1715         CheckSize(1);
1716         CheckValue(values[0] >= T{0} && values[0] <= T{1});
1717
1718         Source->EnhWidth = static_cast<float>(values[0]);
1719         return UpdateSourceProps(Source, Context);
1720
1721     case AL_PANNING_ENABLED_SOFT:
1722         CheckSize(1);
1723         if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1724             state == AL_PLAYING || state == AL_PAUSED)
1725             throw al::context_error{AL_INVALID_OPERATION,
1726                 "Modifying panning enabled on playing or paused source %u", Source->id};
1727
1728         CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1729
1730         Source->mPanningEnabled = values[0] != AL_FALSE;
1731         return UpdateSourceProps(Source, Context);
1732
1733     case AL_PAN_SOFT:
1734         CheckSize(1);
1735         CheckValue(values[0] >= T{-1} && values[0] <= T{1});
1736
1737         Source->mPan = static_cast<float>(values[0]);
1738         return UpdateSourceProps(Source, Context);
1739
1740     case AL_STEREO_ANGLES:
1741         CheckSize(2);
1742         if constexpr(std::is_floating_point_v<T>)
1743             CheckValue(std::isfinite(static_cast<float>(values[0]))
1744                 && std::isfinite(static_cast<float>(values[1])));
1745
1746         Source->StereoPan[0] = static_cast<float>(values[0]);
1747         Source->StereoPan[1] = static_cast<float>(values[1]);
1748         return UpdateSourceProps(Source, Context);
1749
1750
1751     case AL_POSITION:
1752         CheckSize(3);
1753         if constexpr(std::is_floating_point_v<T>)
1754             CheckValue(std::isfinite(static_cast<float>(values[0]))
1755                 && std::isfinite(static_cast<float>(values[1]))
1756                 && std::isfinite(static_cast<float>(values[2])));
1757
1758         Source->Position[0] = static_cast<float>(values[0]);
1759         Source->Position[1] = static_cast<float>(values[1]);
1760         Source->Position[2] = static_cast<float>(values[2]);
1761         return CommitAndUpdateSourceProps(Source, Context);
1762
1763     case AL_VELOCITY:
1764         CheckSize(3);
1765         if constexpr(std::is_floating_point_v<T>)
1766             CheckValue(std::isfinite(static_cast<float>(values[0]))
1767                 && std::isfinite(static_cast<float>(values[1]))
1768                 && std::isfinite(static_cast<float>(values[2])));
1769
1770         Source->Velocity[0] = static_cast<float>(values[0]);
1771         Source->Velocity[1] = static_cast<float>(values[1]);
1772         Source->Velocity[2] = static_cast<float>(values[2]);
1773         return CommitAndUpdateSourceProps(Source, Context);
1774
1775     case AL_DIRECTION:
1776         CheckSize(3);
1777         if constexpr(std::is_floating_point_v<T>)
1778             CheckValue(std::isfinite(static_cast<float>(values[0]))
1779                 && std::isfinite(static_cast<float>(values[1]))
1780                 && std::isfinite(static_cast<float>(values[2])));
1781
1782         Source->Direction[0] = static_cast<float>(values[0]);
1783         Source->Direction[1] = static_cast<float>(values[1]);
1784         Source->Direction[2] = static_cast<float>(values[2]);
1785         return CommitAndUpdateSourceProps(Source, Context);
1786
1787     case AL_ORIENTATION:
1788         CheckSize(6);
1789         if constexpr(std::is_floating_point_v<T>)
1790             CheckValue(std::isfinite(static_cast<float>(values[0]))
1791                 && std::isfinite(static_cast<float>(values[1]))
1792                 && std::isfinite(static_cast<float>(values[2]))
1793                 && std::isfinite(static_cast<float>(values[3]))
1794                 && std::isfinite(static_cast<float>(values[4]))
1795                 && std::isfinite(static_cast<float>(values[5])));
1796
1797         Source->OrientAt[0] = static_cast<float>(values[0]);
1798         Source->OrientAt[1] = static_cast<float>(values[1]);
1799         Source->OrientAt[2] = static_cast<float>(values[2]);
1800         Source->OrientUp[0] = static_cast<float>(values[3]);
1801         Source->OrientUp[1] = static_cast<float>(values[4]);
1802         Source->OrientUp[2] = static_cast<float>(values[5]);
1803         return UpdateSourceProps(Source, Context);
1804
1805
1806     case AL_DIRECT_FILTER:
1807         if constexpr(std::is_integral_v<T>)
1808         {
1809             CheckSize(1);
1810             const auto filterid = static_cast<std::make_unsigned_t<T>>(values[0]);
1811             if(values[0])
1812             {
1813                 std::lock_guard<std::mutex> filterlock{device->FilterLock};
1814                 ALfilter *filter{LookupFilter(device, filterid)};
1815                 if(!filter)
1816                     throw al::context_error{AL_INVALID_VALUE, "Invalid filter ID %s",
1817                         std::to_string(filterid).c_str()};
1818                 Source->Direct.Gain = filter->Gain;
1819                 Source->Direct.GainHF = filter->GainHF;
1820                 Source->Direct.HFReference = filter->HFReference;
1821                 Source->Direct.GainLF = filter->GainLF;
1822                 Source->Direct.LFReference = filter->LFReference;
1823             }
1824             else
1825             {
1826                 Source->Direct.Gain = 1.0f;
1827                 Source->Direct.GainHF = 1.0f;
1828                 Source->Direct.HFReference = LowPassFreqRef;
1829                 Source->Direct.GainLF = 1.0f;
1830                 Source->Direct.LFReference = HighPassFreqRef;
1831             }
1832             return UpdateSourceProps(Source, Context);
1833         }
1834         break;
1835
1836     case AL_DIRECT_FILTER_GAINHF_AUTO:
1837         if constexpr(std::is_integral_v<T>)
1838         {
1839             CheckSize(1);
1840             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1841
1842             Source->DryGainHFAuto = values[0] != AL_FALSE;
1843             return UpdateSourceProps(Source, Context);
1844         }
1845         break;
1846
1847     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1848         if constexpr(std::is_integral_v<T>)
1849         {
1850             CheckSize(1);
1851             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1852
1853             Source->WetGainAuto = values[0] != AL_FALSE;
1854             return UpdateSourceProps(Source, Context);
1855         }
1856         break;
1857
1858     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1859         if constexpr(std::is_integral_v<T>)
1860         {
1861             CheckSize(1);
1862             CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
1863
1864             Source->WetGainHFAuto = values[0] != AL_FALSE;
1865             return UpdateSourceProps(Source, Context);
1866         }
1867         break;
1868
1869     case AL_DIRECT_CHANNELS_SOFT:
1870         if constexpr(std::is_integral_v<T>)
1871         {
1872             CheckSize(1);
1873             if(auto mode = DirectModeFromEnum(values[0]))
1874             {
1875                 Source->DirectChannels = *mode;
1876                 return UpdateSourceProps(Source, Context);
1877             }
1878             throw al::context_error{AL_INVALID_VALUE, "Invalid direct channels mode: %s\n",
1879                 HexPrinter{values[0]}.c_str()};
1880         }
1881         break;
1882
1883     case AL_DISTANCE_MODEL:
1884         if constexpr(std::is_integral_v<T>)
1885         {
1886             CheckSize(1);
1887             if(auto model = DistanceModelFromALenum(values[0]))
1888             {
1889                 Source->mDistanceModel = *model;
1890                 if(Context->mSourceDistanceModel)
1891                     UpdateSourceProps(Source, Context);
1892                 return;
1893             }
1894             throw al::context_error{AL_INVALID_VALUE, "Invalid distance model: %s\n",
1895                 HexPrinter{values[0]}.c_str()};
1896         }
1897         break;
1898
1899     case AL_SOURCE_RESAMPLER_SOFT:
1900         if constexpr(std::is_integral_v<T>)
1901         {
1902             CheckSize(1);
1903             CheckValue(values[0] >= 0 && values[0] <= static_cast<int>(Resampler::Max));
1904
1905             Source->mResampler = static_cast<Resampler>(values[0]);
1906             return UpdateSourceProps(Source, Context);
1907         }
1908         break;
1909
1910     case AL_SOURCE_SPATIALIZE_SOFT:
1911         if constexpr(std::is_integral_v<T>)
1912         {
1913             CheckSize(1);
1914             if(auto mode = SpatializeModeFromEnum(values[0]))
1915             {
1916                 Source->mSpatialize = *mode;
1917                 return UpdateSourceProps(Source, Context);
1918             }
1919             throw al::context_error{AL_INVALID_VALUE, "Invalid source spatialize mode: %s\n",
1920                 HexPrinter{values[0]}.c_str()};
1921         }
1922         break;
1923
1924     case AL_STEREO_MODE_SOFT:
1925         if constexpr(std::is_integral_v<T>)
1926         {
1927             CheckSize(1);
1928             if(const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
1929                 state == AL_PLAYING || state == AL_PAUSED)
1930                 throw al::context_error{AL_INVALID_OPERATION,
1931                     "Modifying stereo mode on playing or paused source %u", Source->id};
1932
1933             if(auto mode = StereoModeFromEnum(values[0]))
1934             {
1935                 Source->mStereoMode = *mode;
1936                 return;
1937             }
1938             throw al::context_error{AL_INVALID_VALUE, "Invalid stereo mode: %s\n",
1939                 HexPrinter{values[0]}.c_str()};
1940         }
1941         break;
1942
1943     case AL_AUXILIARY_SEND_FILTER:
1944         if constexpr(std::is_integral_v<T>)
1945         {
1946             CheckSize(3);
1947             const auto slotid = static_cast<std::make_unsigned_t<T>>(values[0]);
1948             const auto sendidx = static_cast<std::make_unsigned_t<T>>(values[1]);
1949             const auto filterid = static_cast<std::make_unsigned_t<T>>(values[2]);
1950
1951             std::unique_lock slotlock{Context->mEffectSlotLock};
1952             ALeffectslot *slot{};
1953             if(values[0])
1954             {
1955                 slot = LookupEffectSlot(Context, slotid);
1956                 if(!slot)
1957                     throw al::context_error{AL_INVALID_VALUE, "Invalid effect ID %s",
1958                         std::to_string(slotid).c_str()};
1959             }
1960
1961             if(sendidx >= device->NumAuxSends)
1962                 throw al::context_error{AL_INVALID_VALUE, "Invalid send %s",
1963                     std::to_string(sendidx).c_str()};
1964             auto &send = Source->Send[static_cast<size_t>(sendidx)];
1965
1966             if(values[2])
1967             {
1968                 std::lock_guard<std::mutex> filterlock{device->FilterLock};
1969                 ALfilter *filter{LookupFilter(device, filterid)};
1970                 if(!filter)
1971                     throw al::context_error{AL_INVALID_VALUE, "Invalid filter ID %s",
1972                         std::to_string(filterid).c_str()};
1973
1974                 send.Gain = filter->Gain;
1975                 send.GainHF = filter->GainHF;
1976                 send.HFReference = filter->HFReference;
1977                 send.GainLF = filter->GainLF;
1978                 send.LFReference = filter->LFReference;
1979             }
1980             else
1981             {
1982                 /* Disable filter */
1983                 send.Gain = 1.0f;
1984                 send.GainHF = 1.0f;
1985                 send.HFReference = LowPassFreqRef;
1986                 send.GainLF = 1.0f;
1987                 send.LFReference = HighPassFreqRef;
1988             }
1989
1990             /* We must force an update if the current auxiliary slot is valid
1991              * and about to be changed on an active source, in case the old
1992              * slot is about to be deleted.
1993              */
1994             if(send.Slot && slot != send.Slot && IsPlayingOrPaused(Source))
1995             {
1996                 /* Add refcount on the new slot, and release the previous slot */
1997                 if(slot) IncrementRef(slot->ref);
1998                 if(auto *oldslot = send.Slot)
1999                     DecrementRef(oldslot->ref);
2000                 send.Slot = slot;
2001
2002                 Voice *voice{GetSourceVoice(Source, Context)};
2003                 if(voice) UpdateSourceProps(Source, voice, Context);
2004                 else Source->mPropsDirty = true;
2005             }
2006             else
2007             {
2008                 if(slot) IncrementRef(slot->ref);
2009                 if(auto *oldslot = send.Slot)
2010                     DecrementRef(oldslot->ref);
2011                 send.Slot = slot;
2012                 UpdateSourceProps(Source, Context);
2013             }
2014             return;
2015         }
2016         break;
2017     }
2018
2019     ERR("Unexpected %s property: 0x%04x\n", PropType<T>::Name(), prop);
2020     throw al::context_error{AL_INVALID_ENUM, "Invalid source %s property 0x%04x",
2021         PropType<T>::Name(), prop};
2022 }
2023
2024
2025 template<typename T, size_t N>
2026 auto GetSizeChecker(const SourceProp prop, const al::span<T,N> values)
2027 {
2028     return [=](size_t expect) -> void
2029     {
2030         if(values.size() == expect) LIKELY return;
2031         throw al::context_error{AL_INVALID_ENUM, "Property 0x%04x expects %zu value(s), got %zu",
2032             prop, expect, values.size()};
2033     };
2034 }
2035
2036 template<typename T>
2037 NOINLINE void GetProperty(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
2038     const al::span<T> values)
2039 {
2040     using std::chrono::duration_cast;
2041     auto CheckSize = GetSizeChecker(prop, values);
2042     ALCdevice *device{Context->mALDevice.get()};
2043
2044     switch(prop)
2045     {
2046     case AL_GAIN:
2047         CheckSize(1);
2048         values[0] = static_cast<T>(Source->Gain);
2049         return;
2050
2051     case AL_PITCH:
2052         CheckSize(1);
2053         values[0] = static_cast<T>(Source->Pitch);
2054         return;
2055
2056     case AL_MAX_DISTANCE:
2057         CheckSize(1);
2058         values[0] = static_cast<T>(Source->MaxDistance);
2059         return;
2060
2061     case AL_ROLLOFF_FACTOR:
2062         CheckSize(1);
2063         values[0] = static_cast<T>(Source->RolloffFactor);
2064         return;
2065
2066     case AL_REFERENCE_DISTANCE:
2067         CheckSize(1);
2068         values[0] = static_cast<T>(Source->RefDistance);
2069         return;
2070
2071     case AL_CONE_INNER_ANGLE:
2072         CheckSize(1);
2073         values[0] = static_cast<T>(Source->InnerAngle);
2074         return;
2075
2076     case AL_CONE_OUTER_ANGLE:
2077         CheckSize(1);
2078         values[0] = static_cast<T>(Source->OuterAngle);
2079         return;
2080
2081     case AL_MIN_GAIN:
2082         CheckSize(1);
2083         values[0] = static_cast<T>(Source->MinGain);
2084         return;
2085
2086     case AL_MAX_GAIN:
2087         CheckSize(1);
2088         values[0] = static_cast<T>(Source->MaxGain);
2089         return;
2090
2091     case AL_CONE_OUTER_GAIN:
2092         CheckSize(1);
2093         values[0] = static_cast<T>(Source->OuterGain);
2094         return;
2095
2096     case AL_SEC_OFFSET:
2097     case AL_SAMPLE_OFFSET:
2098     case AL_BYTE_OFFSET:
2099         CheckSize(1);
2100         values[0] = GetSourceOffset<T>(Source, prop, Context);
2101         return;
2102
2103     case AL_CONE_OUTER_GAINHF:
2104         CheckSize(1);
2105         values[0] = static_cast<T>(Source->OuterGainHF);
2106         return;
2107
2108     case AL_AIR_ABSORPTION_FACTOR:
2109         CheckSize(1);
2110         values[0] = static_cast<T>(Source->AirAbsorptionFactor);
2111         return;
2112
2113     case AL_ROOM_ROLLOFF_FACTOR:
2114         CheckSize(1);
2115         values[0] = static_cast<T>(Source->RoomRolloffFactor);
2116         return;
2117
2118     case AL_DOPPLER_FACTOR:
2119         CheckSize(1);
2120         values[0] = static_cast<T>(Source->DopplerFactor);
2121         return;
2122
2123     case AL_SAMPLE_RW_OFFSETS_SOFT:
2124         if constexpr(std::is_integral_v<T>)
2125         {
2126             if(sBufferSubDataCompat)
2127             {
2128                 CheckSize(2);
2129                 values[0] = GetSourceOffset<T>(Source, AL_SAMPLE_OFFSET, Context);
2130                 /* FIXME: values[1] should be ahead of values[0] by the device
2131                  * update time. It needs to clamp or wrap the length of the
2132                  * buffer queue.
2133                  */
2134                 values[1] = values[0];
2135                 return;
2136             }
2137         }
2138         break;
2139     case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
2140         if constexpr(std::is_floating_point_v<T>)
2141         {
2142             if(sBufferSubDataCompat)
2143                 break;
2144
2145             CheckSize(1);
2146             values[0] = static_cast<T>(Source->Radius);
2147             return;
2148         }
2149         else
2150         {
2151             if(sBufferSubDataCompat)
2152             {
2153                 CheckSize(2);
2154                 values[0] = GetSourceOffset<T>(Source, AL_BYTE_OFFSET, Context);
2155                 /* FIXME: values[1] should be ahead of values[0] by the device
2156                  * update time. It needs to clamp or wrap the length of the
2157                  * buffer queue.
2158                  */
2159                 values[1] = values[0];
2160                 return;
2161             }
2162             break;
2163         }
2164
2165     case AL_SUPER_STEREO_WIDTH_SOFT:
2166         CheckSize(1);
2167         values[0] = static_cast<T>(Source->EnhWidth);
2168         return;
2169
2170     case AL_BYTE_LENGTH_SOFT:
2171     case AL_SAMPLE_LENGTH_SOFT:
2172     case AL_SEC_LENGTH_SOFT:
2173         CheckSize(1);
2174         values[0] = GetSourceLength<T>(Source, prop);
2175         return;
2176
2177     case AL_PANNING_ENABLED_SOFT:
2178         CheckSize(1);
2179         values[0] = Source->mPanningEnabled;
2180         return;
2181
2182     case AL_PAN_SOFT:
2183         CheckSize(1);
2184         values[0] = static_cast<T>(Source->mPan);
2185         return;
2186
2187     case AL_STEREO_ANGLES:
2188         if constexpr(std::is_floating_point_v<T>)
2189         {
2190             CheckSize(2);
2191             values[0] = static_cast<T>(Source->StereoPan[0]);
2192             values[1] = static_cast<T>(Source->StereoPan[1]);
2193             return;
2194         }
2195         break;
2196
2197     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
2198         if constexpr(std::is_same_v<T,int64_t>)
2199         {
2200             CheckSize(2);
2201             /* Get the source offset with the clock time first. Then get the
2202              * clock time with the device latency. Order is important.
2203              */
2204             ClockLatency clocktime{};
2205             nanoseconds srcclock{};
2206             values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
2207             {
2208                 std::lock_guard<std::mutex> statelock{device->StateLock};
2209                 clocktime = GetClockLatency(device, device->Backend.get());
2210             }
2211             if(srcclock == clocktime.ClockTime)
2212                 values[1] = nanoseconds{clocktime.Latency}.count();
2213             else
2214             {
2215                 /* If the clock time incremented, reduce the latency by that
2216                  * much since it's that much closer to the source offset it got
2217                  * earlier.
2218                  */
2219                 const auto diff = std::min(clocktime.Latency, clocktime.ClockTime-srcclock);
2220                 values[1] = nanoseconds{clocktime.Latency - diff}.count();
2221             }
2222             return;
2223         }
2224         break;
2225
2226     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
2227         if constexpr(std::is_same_v<T,int64_t>)
2228         {
2229             CheckSize(2);
2230             nanoseconds srcclock{};
2231             values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
2232             values[1] = srcclock.count();
2233             return;
2234         }
2235         break;
2236
2237     case AL_SEC_OFFSET_LATENCY_SOFT:
2238         if constexpr(std::is_same_v<T,double>)
2239         {
2240             CheckSize(2);
2241             /* Get the source offset with the clock time first. Then get the
2242              * clock time with the device latency. Order is important.
2243              */
2244             ClockLatency clocktime{};
2245             nanoseconds srcclock{};
2246             values[0] = GetSourceSecOffset(Source, Context, &srcclock);
2247             {
2248                 std::lock_guard<std::mutex> statelock{device->StateLock};
2249                 clocktime = GetClockLatency(device, device->Backend.get());
2250             }
2251             if(srcclock == clocktime.ClockTime)
2252                 values[1] = duration_cast<seconds_d>(clocktime.Latency).count();
2253             else
2254             {
2255                 /* If the clock time incremented, reduce the latency by that
2256                  * much since it's that much closer to the source offset it got
2257                  * earlier.
2258                  */
2259                 const auto diff = std::min(clocktime.Latency, clocktime.ClockTime-srcclock);
2260                 values[1] = duration_cast<seconds_d>(clocktime.Latency - diff).count();
2261             }
2262             return;
2263         }
2264         break;
2265
2266     case AL_SEC_OFFSET_CLOCK_SOFT:
2267         if constexpr(std::is_same_v<T,double>)
2268         {
2269             CheckSize(2);
2270             nanoseconds srcclock{};
2271             values[0] = GetSourceSecOffset(Source, Context, &srcclock);
2272             values[1] = duration_cast<seconds_d>(srcclock).count();
2273             return;
2274         }
2275         break;
2276
2277     case AL_POSITION:
2278         CheckSize(3);
2279         values[0] = static_cast<T>(Source->Position[0]);
2280         values[1] = static_cast<T>(Source->Position[1]);
2281         values[2] = static_cast<T>(Source->Position[2]);
2282         return;
2283
2284     case AL_VELOCITY:
2285         CheckSize(3);
2286         values[0] = static_cast<T>(Source->Velocity[0]);
2287         values[1] = static_cast<T>(Source->Velocity[1]);
2288         values[2] = static_cast<T>(Source->Velocity[2]);
2289         return;
2290
2291     case AL_DIRECTION:
2292         CheckSize(3);
2293         values[0] = static_cast<T>(Source->Direction[0]);
2294         values[1] = static_cast<T>(Source->Direction[1]);
2295         values[2] = static_cast<T>(Source->Direction[2]);
2296         return;
2297
2298     case AL_ORIENTATION:
2299         CheckSize(6);
2300         values[0] = static_cast<T>(Source->OrientAt[0]);
2301         values[1] = static_cast<T>(Source->OrientAt[1]);
2302         values[2] = static_cast<T>(Source->OrientAt[2]);
2303         values[3] = static_cast<T>(Source->OrientUp[0]);
2304         values[4] = static_cast<T>(Source->OrientUp[1]);
2305         values[5] = static_cast<T>(Source->OrientUp[2]);
2306         return;
2307
2308
2309     case AL_SOURCE_RELATIVE:
2310         if constexpr(std::is_integral_v<T>)
2311         {
2312             CheckSize(1);
2313             values[0] = Source->HeadRelative;
2314             return;
2315         }
2316         break;
2317
2318     case AL_LOOPING:
2319         if constexpr(std::is_integral_v<T>)
2320         {
2321             CheckSize(1);
2322             values[0] = Source->Looping;
2323             return;
2324         }
2325         break;
2326
2327     case AL_BUFFER:
2328         if constexpr(std::is_integral_v<T>)
2329         {
2330             CheckSize(1);
2331             ALbufferQueueItem *BufferList{};
2332             /* HACK: This query should technically only return the buffer set
2333              * on a static source. However, some apps had used it to detect
2334              * when a streaming source changed buffers, so report the current
2335              * buffer's ID when playing.
2336              */
2337             if(Source->SourceType == AL_STATIC || Source->state == AL_INITIAL)
2338             {
2339                 if(!Source->mQueue.empty())
2340                     BufferList = &Source->mQueue.front();
2341             }
2342             else if(Voice *voice{GetSourceVoice(Source, Context)})
2343             {
2344                 VoiceBufferItem *Current{voice->mCurrentBuffer.load(std::memory_order_relaxed)};
2345                 BufferList = static_cast<ALbufferQueueItem*>(Current);
2346             }
2347             ALbuffer *buffer{BufferList ? BufferList->mBuffer : nullptr};
2348             values[0] = buffer ? static_cast<T>(buffer->id) : T{0};
2349             return;
2350         }
2351         break;
2352
2353     case AL_SOURCE_STATE:
2354         if constexpr(std::is_integral_v<T>)
2355         {
2356             CheckSize(1);
2357             values[0] = GetSourceState(Source, GetSourceVoice(Source, Context));
2358             return;
2359         }
2360         break;
2361
2362     case AL_BUFFERS_QUEUED:
2363         if constexpr(std::is_integral_v<T>)
2364         {
2365             CheckSize(1);
2366             values[0] = static_cast<T>(Source->mQueue.size());
2367             return;
2368         }
2369         break;
2370
2371     case AL_BUFFERS_PROCESSED:
2372         if constexpr(std::is_integral_v<T>)
2373         {
2374             CheckSize(1);
2375             if(Source->Looping || Source->SourceType != AL_STREAMING)
2376             {
2377                 /* Buffers on a looping source are in a perpetual state of
2378                  * PENDING, so don't report any as PROCESSED
2379                  */
2380                 values[0] = 0;
2381             }
2382             else
2383             {
2384                 int played{0};
2385                 if(Source->state != AL_INITIAL)
2386                 {
2387                     const VoiceBufferItem *Current{nullptr};
2388                     if(Voice *voice{GetSourceVoice(Source, Context)})
2389                         Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
2390                     for(auto &item : Source->mQueue)
2391                     {
2392                         if(&item == Current)
2393                             break;
2394                         ++played;
2395                     }
2396                 }
2397                 values[0] = played;
2398             }
2399             return;
2400         }
2401         break;
2402
2403     case AL_SOURCE_TYPE:
2404         if constexpr(std::is_integral_v<T>)
2405         {
2406             CheckSize(1);
2407             values[0] = Source->SourceType;
2408             return;
2409         }
2410         break;
2411
2412     case AL_DIRECT_FILTER_GAINHF_AUTO:
2413         if constexpr(std::is_integral_v<T>)
2414         {
2415             CheckSize(1);
2416             values[0] = Source->DryGainHFAuto;
2417             return;
2418         }
2419         break;
2420
2421     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
2422         if constexpr(std::is_integral_v<T>)
2423         {
2424             CheckSize(1);
2425             values[0] = Source->WetGainAuto;
2426             return;
2427         }
2428         break;
2429
2430     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
2431         if constexpr(std::is_integral_v<T>)
2432         {
2433             CheckSize(1);
2434             values[0] = Source->WetGainHFAuto;
2435             return;
2436         }
2437         break;
2438
2439     case AL_DIRECT_CHANNELS_SOFT:
2440         if constexpr(std::is_integral_v<T>)
2441         {
2442             CheckSize(1);
2443             values[0] = EnumFromDirectMode(Source->DirectChannels);
2444             return;
2445         }
2446         break;
2447
2448     case AL_DISTANCE_MODEL:
2449         if constexpr(std::is_integral_v<T>)
2450         {
2451             CheckSize(1);
2452             values[0] = ALenumFromDistanceModel(Source->mDistanceModel);
2453             return;
2454         }
2455         break;
2456
2457     case AL_SOURCE_RESAMPLER_SOFT:
2458         if constexpr(std::is_integral_v<T>)
2459         {
2460             CheckSize(1);
2461             values[0] = static_cast<T>(Source->mResampler);
2462             return;
2463         }
2464         break;
2465
2466     case AL_SOURCE_SPATIALIZE_SOFT:
2467         if constexpr(std::is_integral_v<T>)
2468         {
2469             CheckSize(1);
2470             values[0] = EnumFromSpatializeMode(Source->mSpatialize);
2471             return;
2472         }
2473         break;
2474
2475     case AL_STEREO_MODE_SOFT:
2476         if constexpr(std::is_integral_v<T>)
2477         {
2478             CheckSize(1);
2479             values[0] = EnumFromStereoMode(Source->mStereoMode);
2480             return;
2481         }
2482         break;
2483
2484     case AL_DIRECT_FILTER:
2485     case AL_AUXILIARY_SEND_FILTER:
2486         break;
2487     }
2488
2489     ERR("Unexpected %s query property: 0x%04x\n", PropType<T>::Name(), prop);
2490     throw al::context_error{AL_INVALID_ENUM, "Invalid source %s query property 0x%04x",
2491         PropType<T>::Name(), prop};
2492 }
2493
2494
2495 void StartSources(ALCcontext *const context, const al::span<ALsource*> srchandles,
2496     const nanoseconds start_time=nanoseconds::min())
2497 {
2498     ALCdevice *device{context->mALDevice.get()};
2499     /* If the device is disconnected, and voices stop on disconnect, go right
2500      * to stopped.
2501      */
2502     if(!device->Connected.load(std::memory_order_acquire)) UNLIKELY
2503     {
2504         if(context->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
2505         {
2506             for(ALsource *source : srchandles)
2507             {
2508                 /* TODO: Send state change event? */
2509                 source->Offset = 0.0;
2510                 source->OffsetType = AL_NONE;
2511                 source->state = AL_STOPPED;
2512             }
2513             return;
2514         }
2515     }
2516
2517     /* Count the number of reusable voices. */
2518     auto voicelist = context->getVoicesSpan();
2519     size_t free_voices{0};
2520     for(const Voice *voice : voicelist)
2521     {
2522         free_voices += (voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
2523             && voice->mSourceID.load(std::memory_order_relaxed) == 0u
2524             && voice->mPendingChange.load(std::memory_order_relaxed) == false);
2525         if(free_voices == srchandles.size())
2526             break;
2527     }
2528     if(srchandles.size() != free_voices) UNLIKELY
2529     {
2530         const size_t inc_amount{srchandles.size() - free_voices};
2531         auto &allvoices = *context->mVoices.load(std::memory_order_relaxed);
2532         if(inc_amount > allvoices.size() - voicelist.size())
2533         {
2534             /* Increase the number of voices to handle the request. */
2535             context->allocVoices(inc_amount - (allvoices.size() - voicelist.size()));
2536         }
2537         context->mActiveVoiceCount.fetch_add(inc_amount, std::memory_order_release);
2538         voicelist = context->getVoicesSpan();
2539     }
2540
2541     auto voiceiter = voicelist.begin();
2542     ALuint vidx{0};
2543     VoiceChange *tail{}, *cur{};
2544     for(ALsource *source : srchandles)
2545     {
2546         /* Check that there is a queue containing at least one valid, non zero
2547          * length buffer.
2548          */
2549         auto find_buffer = [](ALbufferQueueItem &entry) noexcept
2550         { return entry.mSampleLen != 0 || entry.mCallback != nullptr; };
2551         auto BufferList = std::find_if(source->mQueue.begin(), source->mQueue.end(), find_buffer);
2552
2553         /* If there's nothing to play, go right to stopped. */
2554         if(BufferList == source->mQueue.end()) UNLIKELY
2555         {
2556             /* NOTE: A source without any playable buffers should not have a
2557              * Voice since it shouldn't be in a playing or paused state. So
2558              * there's no need to look up its voice and clear the source.
2559              */
2560             source->Offset = 0.0;
2561             source->OffsetType = AL_NONE;
2562             source->state = AL_STOPPED;
2563             continue;
2564         }
2565
2566         if(!cur)
2567             cur = tail = GetVoiceChanger(context);
2568         else
2569         {
2570             cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
2571             cur = cur->mNext.load(std::memory_order_relaxed);
2572         }
2573
2574         Voice *voice{GetSourceVoice(source, context)};
2575         switch(GetSourceState(source, voice))
2576         {
2577         case AL_PAUSED:
2578             /* A source that's paused simply resumes. If there's no voice, it
2579              * was lost from a disconnect, so just start over with a new one.
2580              */
2581             cur->mOldVoice = nullptr;
2582             if(!voice) break;
2583             cur->mVoice = voice;
2584             cur->mSourceID = source->id;
2585             cur->mState = VChangeState::Play;
2586             source->state = AL_PLAYING;
2587 #ifdef ALSOFT_EAX
2588             if(context->hasEax())
2589                 source->eaxCommit();
2590 #endif // ALSOFT_EAX
2591             continue;
2592
2593         case AL_PLAYING:
2594             /* A source that's already playing is restarted from the beginning.
2595              * Stop the current voice and start a new one so it properly cross-
2596              * fades back to the beginning.
2597              */
2598             if(voice)
2599                 voice->mPendingChange.store(true, std::memory_order_relaxed);
2600             cur->mOldVoice = voice;
2601             voice = nullptr;
2602             break;
2603
2604         default:
2605             assert(voice == nullptr);
2606             cur->mOldVoice = nullptr;
2607 #ifdef ALSOFT_EAX
2608             if(context->hasEax())
2609                 source->eaxCommit();
2610 #endif // ALSOFT_EAX
2611             break;
2612         }
2613
2614         /* Find the next unused voice to play this source with. */
2615         for(;voiceiter != voicelist.end();++voiceiter,++vidx)
2616         {
2617             Voice *v{*voiceiter};
2618             if(v->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
2619                 && v->mSourceID.load(std::memory_order_relaxed) == 0u
2620                 && v->mPendingChange.load(std::memory_order_relaxed) == false)
2621             {
2622                 voice = v;
2623                 break;
2624             }
2625         }
2626         ASSUME(voice != nullptr);
2627
2628         voice->mPosition.store(0, std::memory_order_relaxed);
2629         voice->mPositionFrac.store(0, std::memory_order_relaxed);
2630         voice->mCurrentBuffer.store(&source->mQueue.front(), std::memory_order_relaxed);
2631         voice->mStartTime = start_time;
2632         voice->mFlags.reset();
2633         /* A source that's not playing or paused has any offset applied when it
2634          * starts playing.
2635          */
2636         if(const ALenum offsettype{source->OffsetType})
2637         {
2638             const double offset{source->Offset};
2639             source->OffsetType = AL_NONE;
2640             source->Offset = 0.0;
2641             if(auto vpos = GetSampleOffset(source->mQueue, offsettype, offset))
2642             {
2643                 voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
2644                 voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
2645                 voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_relaxed);
2646                 if(vpos->pos > 0 || (vpos->pos == 0 && vpos->frac > 0)
2647                     || vpos->bufferitem != &source->mQueue.front())
2648                     voice->mFlags.set(VoiceIsFading);
2649             }
2650         }
2651         InitVoice(voice, source, al::to_address(BufferList), context, device);
2652
2653         source->VoiceIdx = vidx;
2654         source->state = AL_PLAYING;
2655
2656         cur->mVoice = voice;
2657         cur->mSourceID = source->id;
2658         cur->mState = VChangeState::Play;
2659     }
2660     if(tail) LIKELY
2661         SendVoiceChanges(context, tail);
2662 }
2663
2664 } // namespace
2665
2666 AL_API DECL_FUNC2(void, alGenSources, ALsizei,n, ALuint*,sources)
2667 FORCE_ALIGN void AL_APIENTRY alGenSourcesDirect(ALCcontext *context, ALsizei n, ALuint *sources) noexcept
2668 try {
2669     if(n < 0)
2670         throw al::context_error{AL_INVALID_VALUE, "Generating %d sources", n};
2671     if(n <= 0) UNLIKELY return;
2672
2673     std::unique_lock<std::mutex> srclock{context->mSourceLock};
2674     ALCdevice *device{context->mALDevice.get()};
2675
2676     const al::span sids{sources, static_cast<ALuint>(n)};
2677     if(sids.size() > device->SourcesMax-context->mNumSources)
2678         throw al::context_error{AL_OUT_OF_MEMORY, "Exceeding %u source limit (%u + %d)",
2679             device->SourcesMax, context->mNumSources, n};
2680     if(!EnsureSources(context, sids.size()))
2681         throw al::context_error{AL_OUT_OF_MEMORY, "Failed to allocate %d source%s", n,
2682             (n == 1) ? "" : "s"};
2683
2684     std::generate(sids.begin(), sids.end(), [context]{ return AllocSource(context)->id; });
2685 }
2686 catch(al::context_error& e) {
2687     context->setError(e.errorCode(), "%s", e.what());
2688 }
2689
2690 AL_API DECL_FUNC2(void, alDeleteSources, ALsizei,n, const ALuint*,sources)
2691 FORCE_ALIGN void AL_APIENTRY alDeleteSourcesDirect(ALCcontext *context, ALsizei n,
2692     const ALuint *sources) noexcept
2693 try {
2694     if(n < 0)
2695         throw al::context_error{AL_INVALID_VALUE, "Deleting %d sources", n};
2696     if(n <= 0) UNLIKELY return;
2697
2698     std::lock_guard<std::mutex> srclock{context->mSourceLock};
2699
2700     /* Check that all Sources are valid */
2701     auto validate_source = [context](const ALuint sid) -> bool
2702     { return LookupSource(context, sid) != nullptr; };
2703
2704     const al::span sids{sources, static_cast<ALuint>(n)};
2705     auto invsrc = std::find_if_not(sids.begin(), sids.end(), validate_source);
2706     if(invsrc != sids.end())
2707         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", *invsrc};
2708
2709     /* All good. Delete source IDs. */
2710     auto delete_source = [&context](const ALuint sid) -> void
2711     {
2712         if(ALsource *src{LookupSource(context, sid)})
2713             FreeSource(context, src);
2714     };
2715     std::for_each(sids.begin(), sids.end(), delete_source);
2716 }
2717 catch(al::context_error& e) {
2718     context->setError(e.errorCode(), "%s", e.what());
2719 }
2720
2721 AL_API DECL_FUNC1(ALboolean, alIsSource, ALuint,source)
2722 FORCE_ALIGN ALboolean AL_APIENTRY alIsSourceDirect(ALCcontext *context, ALuint source) noexcept
2723 {
2724     std::lock_guard<std::mutex> srclock{context->mSourceLock};
2725     if(LookupSource(context, source) != nullptr)
2726         return AL_TRUE;
2727     return AL_FALSE;
2728 }
2729
2730
2731 AL_API DECL_FUNC3(void, alSourcef, ALuint,source, ALenum,param, ALfloat,value)
2732 FORCE_ALIGN void AL_APIENTRY alSourcefDirect(ALCcontext *context, ALuint source, ALenum param,
2733     ALfloat value) noexcept
2734 try {
2735     std::lock_guard<std::mutex> proplock{context->mPropLock};
2736     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2737     ALsource *Source{LookupSource(context, source)};
2738     if(!Source)
2739         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2740
2741     SetProperty<float>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2742 }
2743 catch(al::context_error& e) {
2744     context->setError(e.errorCode(), "%s", e.what());
2745 }
2746
2747 AL_API DECL_FUNC5(void, alSource3f, ALuint,source, ALenum,param, ALfloat,value1, ALfloat,value2, ALfloat,value3)
2748 FORCE_ALIGN void AL_APIENTRY alSource3fDirect(ALCcontext *context, ALuint source, ALenum param,
2749     ALfloat value1, ALfloat value2, ALfloat value3) noexcept
2750 try {
2751     std::lock_guard<std::mutex> proplock{context->mPropLock};
2752     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2753     ALsource *Source{LookupSource(context, source)};
2754     if(!Source)
2755         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2756
2757     const std::array fvals{value1, value2, value3};
2758     SetProperty<float>(Source, context, static_cast<SourceProp>(param), fvals);
2759 }
2760 catch(al::context_error& e) {
2761     context->setError(e.errorCode(), "%s", e.what());
2762 }
2763
2764 AL_API DECL_FUNC3(void, alSourcefv, ALuint,source, ALenum,param, const ALfloat*,values)
2765 FORCE_ALIGN void AL_APIENTRY alSourcefvDirect(ALCcontext *context, ALuint source, ALenum param,
2766     const ALfloat *values) noexcept
2767 try {
2768     std::lock_guard<std::mutex> proplock{context->mPropLock};
2769     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2770     ALsource *Source{LookupSource(context, source)};
2771     if(!Source)
2772         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2773     if(!values)
2774         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2775
2776     const ALuint count{FloatValsByProp(param)};
2777     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2778 }
2779 catch(al::context_error& e) {
2780     context->setError(e.errorCode(), "%s", e.what());
2781 }
2782
2783
2784 AL_API DECL_FUNCEXT3(void, alSourced,SOFT, ALuint,source, ALenum,param, ALdouble,value)
2785 FORCE_ALIGN void AL_APIENTRY alSourcedDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2786     ALdouble value) 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
2794     SetProperty<double>(Source, context, static_cast<SourceProp>(param), {&value, 1});
2795 }
2796 catch(al::context_error& e) {
2797     context->setError(e.errorCode(), "%s", e.what());
2798 }
2799
2800 AL_API DECL_FUNCEXT5(void, alSource3d,SOFT, ALuint,source, ALenum,param, ALdouble,value1, ALdouble,value2, ALdouble,value3)
2801 FORCE_ALIGN void AL_APIENTRY alSource3dDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2802     ALdouble value1, ALdouble value2, ALdouble value3) noexcept
2803 try {
2804     std::lock_guard<std::mutex> proplock{context->mPropLock};
2805     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2806     ALsource *Source{LookupSource(context, source)};
2807     if(!Source)
2808         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2809
2810     const std::array dvals{value1, value2, value3};
2811     SetProperty<double>(Source, context, static_cast<SourceProp>(param), dvals);
2812 }
2813 catch(al::context_error& e) {
2814     context->setError(e.errorCode(), "%s", e.what());
2815 }
2816
2817 AL_API DECL_FUNCEXT3(void, alSourcedv,SOFT, ALuint,source, ALenum,param, const ALdouble*,values)
2818 FORCE_ALIGN void AL_APIENTRY alSourcedvDirectSOFT(ALCcontext *context, ALuint source, ALenum param,
2819     const ALdouble *values) noexcept
2820 try {
2821     std::lock_guard<std::mutex> proplock{context->mPropLock};
2822     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2823     ALsource *Source{LookupSource(context, source)};
2824     if(!Source)
2825         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2826     if(!values)
2827         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2828
2829     const ALuint count{DoubleValsByProp(param)};
2830     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2831 }
2832 catch(al::context_error& e) {
2833     context->setError(e.errorCode(), "%s", e.what());
2834 }
2835
2836
2837 AL_API DECL_FUNC3(void, alSourcei, ALuint,source, ALenum,param, ALint,value)
2838 FORCE_ALIGN void AL_APIENTRY alSourceiDirect(ALCcontext *context, ALuint source, ALenum param,
2839     ALint value) 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
2847     SetProperty<int>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2848 }
2849 catch(al::context_error& e) {
2850     context->setError(e.errorCode(), "%s", e.what());
2851 }
2852
2853 AL_API DECL_FUNC5(void, alSource3i, ALuint,buffer, ALenum,param, ALint,value1, ALint,value2, ALint,value3)
2854 FORCE_ALIGN void AL_APIENTRY alSource3iDirect(ALCcontext *context, ALuint source, ALenum param,
2855     ALint value1, ALint value2, ALint value3) noexcept
2856 try {
2857     std::lock_guard<std::mutex> proplock{context->mPropLock};
2858     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2859     ALsource *Source{LookupSource(context, source)};
2860     if(!Source)
2861         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2862
2863     const std::array ivals{value1, value2, value3};
2864     SetProperty<int>(Source, context, static_cast<SourceProp>(param), ivals);
2865 }
2866 catch(al::context_error& e) {
2867     context->setError(e.errorCode(), "%s", e.what());
2868 }
2869
2870 AL_API DECL_FUNC3(void, alSourceiv, ALuint,source, ALenum,param, const ALint*,values)
2871 FORCE_ALIGN void AL_APIENTRY alSourceivDirect(ALCcontext *context, ALuint source, ALenum param,
2872     const ALint *values) noexcept
2873 try {
2874     std::lock_guard<std::mutex> proplock{context->mPropLock};
2875     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2876     ALsource *Source{LookupSource(context, source)};
2877     if(!Source)
2878         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2879     if(!values)
2880         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2881
2882     const ALuint count{IntValsByProp(param)};
2883     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2884 }
2885 catch(al::context_error& e) {
2886     context->setError(e.errorCode(), "%s", e.what());
2887 }
2888
2889
2890 AL_API DECL_FUNCEXT3(void, alSourcei64,SOFT, ALuint,source, ALenum,param, ALint64SOFT,value)
2891 FORCE_ALIGN void AL_APIENTRY alSourcei64DirectSOFT(ALCcontext *context, ALuint source,
2892     ALenum param, ALint64SOFT value) 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
2900     SetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), {&value, 1u});
2901 }
2902 catch(al::context_error& e) {
2903     context->setError(e.errorCode(), "%s", e.what());
2904 }
2905
2906 AL_API DECL_FUNCEXT5(void, alSource3i64,SOFT, ALuint,source, ALenum,param, ALint64SOFT,value1, ALint64SOFT,value2, ALint64SOFT,value3)
2907 FORCE_ALIGN void AL_APIENTRY alSource3i64DirectSOFT(ALCcontext *context, ALuint source,
2908     ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3) noexcept
2909 try {
2910     std::lock_guard<std::mutex> proplock{context->mPropLock};
2911     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2912     ALsource *Source{LookupSource(context, source)};
2913     if(!Source)
2914         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2915
2916     const std::array i64vals{value1, value2, value3};
2917     SetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), i64vals);
2918 }
2919 catch(al::context_error& e) {
2920     context->setError(e.errorCode(), "%s", e.what());
2921 }
2922
2923 AL_API DECL_FUNCEXT3(void, alSourcei64v,SOFT, ALuint,source, ALenum,param, const ALint64SOFT*,values)
2924 FORCE_ALIGN void AL_APIENTRY alSourcei64vDirectSOFT(ALCcontext *context, ALuint source,
2925     ALenum param, const ALint64SOFT *values) noexcept
2926 try {
2927     std::lock_guard<std::mutex> proplock{context->mPropLock};
2928     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2929     ALsource *Source{LookupSource(context, source)};
2930     if(!Source)
2931         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2932     if(!values)
2933         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2934
2935     const ALuint count{Int64ValsByProp(param)};
2936     SetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2937 }
2938 catch(al::context_error& e) {
2939     context->setError(e.errorCode(), "%s", e.what());
2940 }
2941
2942
2943 AL_API DECL_FUNC3(void, alGetSourcef, ALuint,source, ALenum,param, ALfloat*,value)
2944 FORCE_ALIGN void AL_APIENTRY alGetSourcefDirect(ALCcontext *context, ALuint source, ALenum param,
2945     ALfloat *value) noexcept
2946 try {
2947     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2948     ALsource *Source{LookupSource(context, source)};
2949     if(!Source)
2950         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2951     if(!value)
2952         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2953
2954     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
2955 }
2956 catch(al::context_error& e) {
2957     context->setError(e.errorCode(), "%s", e.what());
2958 }
2959
2960 AL_API DECL_FUNC5(void, alGetSource3f, ALuint,source, ALenum,param, ALfloat*,value1, ALfloat*,value2, ALfloat*,value3)
2961 FORCE_ALIGN void AL_APIENTRY alGetSource3fDirect(ALCcontext *context, ALuint source, ALenum param,
2962     ALfloat *value1, ALfloat *value2, ALfloat *value3) noexcept
2963 try {
2964     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2965     ALsource *Source{LookupSource(context, source)};
2966     if(!Source)
2967         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2968     if(!(value1 && value2 && value3))
2969         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2970
2971     std::array<float,3> fvals{};
2972     GetProperty<float>(Source, context, static_cast<SourceProp>(param), fvals);
2973     *value1 = fvals[0];
2974     *value2 = fvals[1];
2975     *value3 = fvals[2];
2976 }
2977 catch(al::context_error& e) {
2978     context->setError(e.errorCode(), "%s", e.what());
2979 }
2980
2981 AL_API DECL_FUNC3(void, alGetSourcefv, ALuint,source, ALenum,param, ALfloat*,values)
2982 FORCE_ALIGN void AL_APIENTRY alGetSourcefvDirect(ALCcontext *context, ALuint source, ALenum param,
2983     ALfloat *values) noexcept
2984 try {
2985     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
2986     ALsource *Source{LookupSource(context, source)};
2987     if(!Source)
2988         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
2989     if(!values)
2990         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
2991
2992     const ALuint count{FloatValsByProp(param)};
2993     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
2994 }
2995 catch(al::context_error& e) {
2996     context->setError(e.errorCode(), "%s", e.what());
2997 }
2998
2999
3000 AL_API DECL_FUNCEXT3(void, alGetSourced,SOFT, ALuint,source, ALenum,param, ALdouble*,value)
3001 FORCE_ALIGN void AL_APIENTRY alGetSourcedDirectSOFT(ALCcontext *context, ALuint source,
3002     ALenum param, ALdouble *value) noexcept
3003 try {
3004     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3005     ALsource *Source{LookupSource(context, source)};
3006     if(!Source)
3007         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3008     if(!value)
3009         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3010
3011     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3012 }
3013 catch(al::context_error& e) {
3014     context->setError(e.errorCode(), "%s", e.what());
3015 }
3016
3017 AL_API DECL_FUNCEXT5(void, alGetSource3d,SOFT, ALuint,source, ALenum,param, ALdouble*,value1, ALdouble*,value2, ALdouble*,value3)
3018 FORCE_ALIGN void AL_APIENTRY alGetSource3dDirectSOFT(ALCcontext *context, ALuint source,
3019     ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3) noexcept
3020 try {
3021     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3022     ALsource *Source{LookupSource(context, source)};
3023     if(!Source)
3024         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3025     if(!(value1 && value2 && value3))
3026         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3027
3028     std::array<double,3> dvals{};
3029     GetProperty<double>(Source, context, static_cast<SourceProp>(param), dvals);
3030     *value1 = dvals[0];
3031     *value2 = dvals[1];
3032     *value3 = dvals[2];
3033 }
3034 catch(al::context_error& e) {
3035     context->setError(e.errorCode(), "%s", e.what());
3036 }
3037
3038 AL_API DECL_FUNCEXT3(void, alGetSourcedv,SOFT, ALuint,source, ALenum,param, ALdouble*,values)
3039 FORCE_ALIGN void AL_APIENTRY alGetSourcedvDirectSOFT(ALCcontext *context, ALuint source,
3040     ALenum param, ALdouble *values) noexcept
3041 try {
3042     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3043     ALsource *Source{LookupSource(context, source)};
3044     if(!Source)
3045         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3046     if(!values)
3047         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3048
3049     const ALuint count{DoubleValsByProp(param)};
3050     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3051 }
3052 catch(al::context_error& e) {
3053     context->setError(e.errorCode(), "%s", e.what());
3054 }
3055
3056
3057 AL_API DECL_FUNC3(void, alGetSourcei, ALuint,source, ALenum,param, ALint*,value)
3058 FORCE_ALIGN void AL_APIENTRY alGetSourceiDirect(ALCcontext *context, ALuint source, ALenum param,
3059     ALint *value) noexcept
3060 try {
3061     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3062     ALsource *Source{LookupSource(context, source)};
3063     if(!Source)
3064         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3065     if(!value)
3066         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3067
3068     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3069 }
3070 catch(al::context_error& e) {
3071     context->setError(e.errorCode(), "%s", e.what());
3072 }
3073
3074 AL_API DECL_FUNC5(void, alGetSource3i, ALuint,source, ALenum,param, ALint*,value1, ALint*,value2, ALint*,value3)
3075 FORCE_ALIGN void AL_APIENTRY alGetSource3iDirect(ALCcontext *context, ALuint source, ALenum param,
3076     ALint *value1, ALint *value2, ALint *value3) noexcept
3077 try {
3078     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3079     ALsource *Source{LookupSource(context, source)};
3080     if(!Source)
3081         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3082     if(!(value1 && value2 && value3))
3083         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3084
3085     std::array<int,3> ivals{};
3086     GetProperty<int>(Source, context, static_cast<SourceProp>(param), ivals);
3087     *value1 = ivals[0];
3088     *value2 = ivals[1];
3089     *value3 = ivals[2];
3090 }
3091 catch(al::context_error& e) {
3092     context->setError(e.errorCode(), "%s", e.what());
3093 }
3094
3095 AL_API DECL_FUNC3(void, alGetSourceiv, ALuint,source, ALenum,param, ALint*,values)
3096 FORCE_ALIGN void AL_APIENTRY alGetSourceivDirect(ALCcontext *context, ALuint source, ALenum param,
3097     ALint *values) noexcept
3098 try {
3099     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3100     ALsource *Source{LookupSource(context, source)};
3101     if(!Source)
3102         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3103     if(!values)
3104         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3105
3106     const ALuint count{IntValsByProp(param)};
3107     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3108 }
3109 catch(al::context_error& e) {
3110     context->setError(e.errorCode(), "%s", e.what());
3111 }
3112
3113
3114 AL_API DECL_FUNCEXT3(void, alGetSourcei64,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,value)
3115 FORCE_ALIGN void AL_APIENTRY alGetSourcei64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT *value) noexcept
3116 try {
3117     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3118     ALsource *Source{LookupSource(context, source)};
3119     if(!Source)
3120         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3121     if(!value)
3122         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3123
3124     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{value, 1u});
3125 }
3126 catch(al::context_error& e) {
3127     context->setError(e.errorCode(), "%s", e.what());
3128 }
3129
3130 AL_API DECL_FUNCEXT5(void, alGetSource3i64,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,value1, ALint64SOFT*,value2, ALint64SOFT*,value3)
3131 FORCE_ALIGN void AL_APIENTRY alGetSource3i64DirectSOFT(ALCcontext *context, ALuint source,
3132     ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3) noexcept
3133 try {
3134     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3135     ALsource *Source{LookupSource(context, source)};
3136     if(!Source)
3137         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3138     if(!(value1 && value2 && value3))
3139         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3140
3141     std::array<int64_t,3> i64vals{};
3142     GetProperty<int64_t>(Source, context, static_cast<SourceProp>(param), i64vals);
3143     *value1 = i64vals[0];
3144     *value2 = i64vals[1];
3145     *value3 = i64vals[2];
3146 }
3147 catch(al::context_error& e) {
3148     context->setError(e.errorCode(), "%s", e.what());
3149 }
3150
3151 AL_API DECL_FUNCEXT3(void, alGetSourcei64v,SOFT, ALuint,source, ALenum,param, ALint64SOFT*,values)
3152 FORCE_ALIGN void AL_APIENTRY alGetSourcei64vDirectSOFT(ALCcontext *context, ALuint source,
3153     ALenum param, ALint64SOFT *values) noexcept
3154 try {
3155     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3156     ALsource *Source{LookupSource(context, source)};
3157     if(!Source)
3158         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3159     if(!values)
3160         throw al::context_error{AL_INVALID_VALUE, "NULL pointer"};
3161
3162     const ALuint count{Int64ValsByProp(param)};
3163     GetProperty(Source, context, static_cast<SourceProp>(param), al::span{values, count});
3164 }
3165 catch(al::context_error& e) {
3166     context->setError(e.errorCode(), "%s", e.what());
3167 }
3168
3169
3170 AL_API DECL_FUNC1(void, alSourcePlay, ALuint,source)
3171 FORCE_ALIGN void AL_APIENTRY alSourcePlayDirect(ALCcontext *context, ALuint source) noexcept
3172 try {
3173     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3174     ALsource *Source{LookupSource(context, source)};
3175     if(!Source)
3176         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3177
3178     StartSources(context, {&Source, 1});
3179 }
3180 catch(al::context_error& e) {
3181     context->setError(e.errorCode(), "%s", e.what());
3182 }
3183
3184 FORCE_ALIGN DECL_FUNCEXT2(void, alSourcePlayAtTime,SOFT, ALuint,source, ALint64SOFT,start_time)
3185 FORCE_ALIGN void AL_APIENTRY alSourcePlayAtTimeDirectSOFT(ALCcontext *context, ALuint source,
3186     ALint64SOFT start_time) noexcept
3187 try {
3188     if(start_time < 0)
3189         throw al::context_error{AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time};
3190
3191     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3192     ALsource *Source{LookupSource(context, source)};
3193     if(!Source)
3194         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", source};
3195
3196     StartSources(context, {&Source, 1}, nanoseconds{start_time});
3197 }
3198 catch(al::context_error& e) {
3199     context->setError(e.errorCode(), "%s", e.what());
3200 }
3201
3202 AL_API DECL_FUNC2(void, alSourcePlayv, ALsizei,n, const ALuint*,sources)
3203 FORCE_ALIGN void AL_APIENTRY alSourcePlayvDirect(ALCcontext *context, ALsizei n,
3204     const ALuint *sources) noexcept
3205 try {
3206     if(n < 0)
3207         throw al::context_error{AL_INVALID_VALUE, "Playing %d sources", n};
3208     if(n <= 0) UNLIKELY return;
3209
3210     al::span sids{sources, static_cast<ALuint>(n)};
3211     source_store_variant source_store;
3212     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3213     {
3214         if(count > std::tuple_size_v<source_store_array>)
3215             return al::span{source_store.emplace<source_store_vector>(count)};
3216         return al::span{source_store.emplace<source_store_array>()}.first(count);
3217     }(sids.size());
3218
3219     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3220     auto lookup_src = [context](const ALuint sid) -> ALsource*
3221     {
3222         if(ALsource *src{LookupSource(context, sid)})
3223             return src;
3224         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3225     };
3226     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3227
3228     StartSources(context, srchandles);
3229 }
3230 catch(al::context_error& e) {
3231     context->setError(e.errorCode(), "%s", e.what());
3232 }
3233
3234 FORCE_ALIGN DECL_FUNCEXT3(void, alSourcePlayAtTimev,SOFT, ALsizei,n, const ALuint*,sources, ALint64SOFT,start_time)
3235 FORCE_ALIGN void AL_APIENTRY alSourcePlayAtTimevDirectSOFT(ALCcontext *context, ALsizei n,
3236     const ALuint *sources, ALint64SOFT start_time) noexcept
3237 try {
3238     if(n < 0)
3239         throw al::context_error{AL_INVALID_VALUE, "Playing %d sources", n};
3240     if(n <= 0) UNLIKELY return;
3241
3242     if(start_time < 0)
3243         throw al::context_error{AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time};
3244
3245     al::span sids{sources, static_cast<ALuint>(n)};
3246     source_store_variant source_store;
3247     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3248     {
3249         if(count > std::tuple_size_v<source_store_array>)
3250             return al::span{source_store.emplace<source_store_vector>(count)};
3251         return al::span{source_store.emplace<source_store_array>()}.first(count);
3252     }(sids.size());
3253
3254     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3255     auto lookup_src = [context](const ALuint sid) -> ALsource*
3256     {
3257         if(ALsource *src{LookupSource(context, sid)})
3258             return src;
3259         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3260     };
3261     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3262
3263     StartSources(context, srchandles, nanoseconds{start_time});
3264 }
3265 catch(al::context_error& e) {
3266     context->setError(e.errorCode(), "%s", e.what());
3267 }
3268
3269
3270 AL_API DECL_FUNC1(void, alSourcePause, ALuint,source)
3271 FORCE_ALIGN void AL_APIENTRY alSourcePauseDirect(ALCcontext *context, ALuint source) noexcept
3272 { alSourcePausevDirect(context, 1, &source); }
3273
3274 AL_API DECL_FUNC2(void, alSourcePausev, ALsizei,n, const ALuint*,sources)
3275 FORCE_ALIGN void AL_APIENTRY alSourcePausevDirect(ALCcontext *context, ALsizei n,
3276     const ALuint *sources) noexcept
3277 try {
3278     if(n < 0)
3279         throw al::context_error{AL_INVALID_VALUE, "Pausing %d sources", n};
3280     if(n <= 0) UNLIKELY return;
3281
3282     al::span sids{sources, static_cast<ALuint>(n)};
3283     source_store_variant source_store;
3284     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3285     {
3286         if(count > std::tuple_size_v<source_store_array>)
3287             return al::span{source_store.emplace<source_store_vector>(count)};
3288         return al::span{source_store.emplace<source_store_array>()}.first(count);
3289     }(sids.size());
3290
3291     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3292     auto lookup_src = [context](const ALuint sid) -> ALsource*
3293     {
3294         if(ALsource *src{LookupSource(context, sid)})
3295             return src;
3296         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3297     };
3298     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3299
3300     /* Pausing has to be done in two steps. First, for each source that's
3301      * detected to be playing, chamge the voice (asynchronously) to
3302      * stopping/paused.
3303      */
3304     VoiceChange *tail{}, *cur{};
3305     for(ALsource *source : srchandles)
3306     {
3307         Voice *voice{GetSourceVoice(source, context)};
3308         if(GetSourceState(source, voice) == AL_PLAYING)
3309         {
3310             if(!cur)
3311                 cur = tail = GetVoiceChanger(context);
3312             else
3313             {
3314                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3315                 cur = cur->mNext.load(std::memory_order_relaxed);
3316             }
3317             cur->mVoice = voice;
3318             cur->mSourceID = source->id;
3319             cur->mState = VChangeState::Pause;
3320         }
3321     }
3322     if(tail) LIKELY
3323     {
3324         SendVoiceChanges(context, tail);
3325         /* Second, now that the voice changes have been sent, because it's
3326          * possible that the voice stopped after it was detected playing and
3327          * before the voice got paused, recheck that the source is still
3328          * considered playing and set it to paused if so.
3329          */
3330         for(ALsource *source : srchandles)
3331         {
3332             Voice *voice{GetSourceVoice(source, context)};
3333             if(GetSourceState(source, voice) == AL_PLAYING)
3334                 source->state = AL_PAUSED;
3335         }
3336     }
3337 }
3338 catch(al::context_error& e) {
3339     context->setError(e.errorCode(), "%s", e.what());
3340 }
3341
3342
3343 AL_API DECL_FUNC1(void, alSourceStop, ALuint,source)
3344 FORCE_ALIGN void AL_APIENTRY alSourceStopDirect(ALCcontext *context, ALuint source) noexcept
3345 { alSourceStopvDirect(context, 1, &source); }
3346
3347 AL_API DECL_FUNC2(void, alSourceStopv, ALsizei,n, const ALuint*,sources)
3348 FORCE_ALIGN void AL_APIENTRY alSourceStopvDirect(ALCcontext *context, ALsizei n,
3349     const ALuint *sources) noexcept
3350 try {
3351     if(n < 0)
3352         throw al::context_error{AL_INVALID_VALUE, "Stopping %d sources", n};
3353     if(n <= 0) UNLIKELY return;
3354
3355     al::span sids{sources, static_cast<ALuint>(n)};
3356     source_store_variant source_store;
3357     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3358     {
3359         if(count > std::tuple_size_v<source_store_array>)
3360             return al::span{source_store.emplace<source_store_vector>(count)};
3361         return al::span{source_store.emplace<source_store_array>()}.first(count);
3362     }(sids.size());
3363
3364     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3365     auto lookup_src = [context](const ALuint sid) -> ALsource*
3366     {
3367         if(ALsource *src{LookupSource(context, sid)})
3368             return src;
3369         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3370     };
3371     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3372
3373     VoiceChange *tail{}, *cur{};
3374     for(ALsource *source : srchandles)
3375     {
3376         if(Voice *voice{GetSourceVoice(source, context)})
3377         {
3378             if(!cur)
3379                 cur = tail = GetVoiceChanger(context);
3380             else
3381             {
3382                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3383                 cur = cur->mNext.load(std::memory_order_relaxed);
3384             }
3385             voice->mPendingChange.store(true, std::memory_order_relaxed);
3386             cur->mVoice = voice;
3387             cur->mSourceID = source->id;
3388             cur->mState = VChangeState::Stop;
3389             source->state = AL_STOPPED;
3390         }
3391         source->Offset = 0.0;
3392         source->OffsetType = AL_NONE;
3393         source->VoiceIdx = InvalidVoiceIndex;
3394     }
3395     if(tail) LIKELY
3396         SendVoiceChanges(context, tail);
3397 }
3398 catch(al::context_error& e) {
3399     context->setError(e.errorCode(), "%s", e.what());
3400 }
3401
3402
3403 AL_API DECL_FUNC1(void, alSourceRewind, ALuint,source)
3404 FORCE_ALIGN void AL_APIENTRY alSourceRewindDirect(ALCcontext *context, ALuint source) noexcept
3405 { alSourceRewindvDirect(context, 1, &source); }
3406
3407 AL_API DECL_FUNC2(void, alSourceRewindv, ALsizei,n, const ALuint*,sources)
3408 FORCE_ALIGN void AL_APIENTRY alSourceRewindvDirect(ALCcontext *context, ALsizei n,
3409     const ALuint *sources) noexcept
3410 try {
3411     if(n < 0)
3412         throw al::context_error{AL_INVALID_VALUE, "Rewinding %d sources", n};
3413     if(n <= 0) UNLIKELY return;
3414
3415     al::span sids{sources, static_cast<ALuint>(n)};
3416     source_store_variant source_store;
3417     const auto srchandles = [&source_store](size_t count) -> al::span<ALsource*>
3418     {
3419         if(count > std::tuple_size_v<source_store_array>)
3420             return al::span{source_store.emplace<source_store_vector>(count)};
3421         return al::span{source_store.emplace<source_store_array>()}.first(count);
3422     }(sids.size());
3423
3424     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3425     auto lookup_src = [context](const ALuint sid) -> ALsource*
3426     {
3427         if(ALsource *src{LookupSource(context, sid)})
3428             return src;
3429         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", sid};
3430     };
3431     std::transform(sids.cbegin(), sids.cend(), srchandles.begin(), lookup_src);
3432
3433     VoiceChange *tail{}, *cur{};
3434     for(ALsource *source : srchandles)
3435     {
3436         Voice *voice{GetSourceVoice(source, context)};
3437         if(source->state != AL_INITIAL)
3438         {
3439             if(!cur)
3440                 cur = tail = GetVoiceChanger(context);
3441             else
3442             {
3443                 cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
3444                 cur = cur->mNext.load(std::memory_order_relaxed);
3445             }
3446             if(voice)
3447                 voice->mPendingChange.store(true, std::memory_order_relaxed);
3448             cur->mVoice = voice;
3449             cur->mSourceID = source->id;
3450             cur->mState = VChangeState::Reset;
3451             source->state = AL_INITIAL;
3452         }
3453         source->Offset = 0.0;
3454         source->OffsetType = AL_NONE;
3455         source->VoiceIdx = InvalidVoiceIndex;
3456     }
3457     if(tail) LIKELY
3458         SendVoiceChanges(context, tail);
3459 }
3460 catch(al::context_error& e) {
3461     context->setError(e.errorCode(), "%s", e.what());
3462 }
3463
3464
3465 AL_API DECL_FUNC3(void, alSourceQueueBuffers, ALuint,source, ALsizei,nb, const ALuint*,buffers)
3466 FORCE_ALIGN void AL_APIENTRY alSourceQueueBuffersDirect(ALCcontext *context, ALuint src,
3467     ALsizei nb, const ALuint *buffers) noexcept
3468 try {
3469     if(nb < 0)
3470         throw al::context_error{AL_INVALID_VALUE, "Queueing %d buffers", nb};
3471     if(nb <= 0) UNLIKELY return;
3472
3473     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3474     ALsource *source{LookupSource(context,src)};
3475     if(!source)
3476         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", src};
3477
3478     /* Can't queue on a Static Source */
3479     if(source->SourceType == AL_STATIC)
3480         throw al::context_error{AL_INVALID_OPERATION, "Queueing onto static source %u", src};
3481
3482     /* Check for a valid Buffer, for its frequency and format */
3483     ALCdevice *device{context->mALDevice.get()};
3484     ALbuffer *BufferFmt{nullptr};
3485     for(auto &item : source->mQueue)
3486     {
3487         BufferFmt = item.mBuffer;
3488         if(BufferFmt) break;
3489     }
3490
3491     std::unique_lock<std::mutex> buflock{device->BufferLock};
3492     const auto bids = al::span{buffers, static_cast<ALuint>(nb)};
3493     const size_t NewListStart{source->mQueue.size()};
3494     try {
3495         ALbufferQueueItem *BufferList{nullptr};
3496         std::for_each(bids.cbegin(), bids.cend(),
3497         [source,device,&BufferFmt,&BufferList](const ALuint bid)
3498         {
3499             ALbuffer *buffer{bid ? LookupBuffer(device, bid) : nullptr};
3500             if(bid && !buffer)
3501                 throw al::context_error{AL_INVALID_NAME, "Queueing invalid buffer ID %u", bid};
3502
3503             if(buffer)
3504             {
3505                 if(buffer->mSampleRate < 1)
3506                     throw al::context_error{AL_INVALID_OPERATION,
3507                         "Queueing buffer %u with no format", buffer->id};
3508
3509                 if(buffer->mCallback)
3510                     throw al::context_error{AL_INVALID_OPERATION, "Queueing callback buffer %u",
3511                         buffer->id};
3512
3513                 if(buffer->MappedAccess != 0 && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
3514                     throw al::context_error{AL_INVALID_OPERATION,
3515                         "Queueing non-persistently mapped buffer %u", buffer->id};
3516             }
3517
3518             source->mQueue.emplace_back();
3519             if(!BufferList)
3520                 BufferList = &source->mQueue.back();
3521             else
3522             {
3523                 auto &item = source->mQueue.back();
3524                 BufferList->mNext.store(&item, std::memory_order_relaxed);
3525                 BufferList = &item;
3526             }
3527             if(!buffer) return;
3528             BufferList->mBlockAlign = buffer->mBlockAlign;
3529             BufferList->mSampleLen = buffer->mSampleLen;
3530             BufferList->mLoopEnd = buffer->mSampleLen;
3531             BufferList->mSamples = buffer->mData;
3532             BufferList->mBuffer = buffer;
3533             IncrementRef(buffer->ref);
3534
3535             bool fmt_mismatch{false};
3536             if(BufferFmt == nullptr)
3537                 BufferFmt = buffer;
3538             else
3539             {
3540                 fmt_mismatch |= BufferFmt->mSampleRate != buffer->mSampleRate;
3541                 fmt_mismatch |= BufferFmt->mChannels != buffer->mChannels;
3542                 fmt_mismatch |= BufferFmt->mType != buffer->mType;
3543                 if(BufferFmt->isBFormat())
3544                 {
3545                     fmt_mismatch |= BufferFmt->mAmbiLayout != buffer->mAmbiLayout;
3546                     fmt_mismatch |= BufferFmt->mAmbiScaling != buffer->mAmbiScaling;
3547                 }
3548                 fmt_mismatch |= BufferFmt->mAmbiOrder != buffer->mAmbiOrder;
3549             }
3550             if(fmt_mismatch)
3551                 throw al::context_error{AL_INVALID_OPERATION,
3552                     "Queueing buffer with mismatched format\n"
3553                     "  Expected: %uhz, %s, %s ; Got: %uhz, %s, %s\n", BufferFmt->mSampleRate,
3554                     NameFromFormat(BufferFmt->mType), NameFromFormat(BufferFmt->mChannels),
3555                     buffer->mSampleRate, NameFromFormat(buffer->mType),
3556                     NameFromFormat(buffer->mChannels)};
3557         });
3558     }
3559     catch(...) {
3560         /* A buffer failed (invalid ID or format), or there was some other
3561          * unexpected error, so unlock and release each buffer we had.
3562          */
3563         auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
3564         for(;iter != source->mQueue.end();++iter)
3565         {
3566             if(ALbuffer *buf{iter->mBuffer})
3567                 DecrementRef(buf->ref);
3568         }
3569         source->mQueue.resize(NewListStart);
3570         throw;
3571     }
3572     /* All buffers good. */
3573     buflock.unlock();
3574
3575     /* Source is now streaming */
3576     source->SourceType = AL_STREAMING;
3577
3578     if(NewListStart != 0)
3579     {
3580         auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
3581         (iter-1)->mNext.store(al::to_address(iter), std::memory_order_release);
3582     }
3583 }
3584 catch(al::context_error& e) {
3585     context->setError(e.errorCode(), "%s", e.what());
3586 }
3587
3588 AL_API DECL_FUNC3(void, alSourceUnqueueBuffers, ALuint,source, ALsizei,nb, ALuint*,buffers)
3589 FORCE_ALIGN void AL_APIENTRY alSourceUnqueueBuffersDirect(ALCcontext *context, ALuint src,
3590     ALsizei nb, ALuint *buffers) noexcept
3591 try {
3592     if(nb < 0)
3593         throw al::context_error{AL_INVALID_VALUE, "Unqueueing %d buffers", nb};
3594     if(nb <= 0) UNLIKELY return;
3595
3596     std::lock_guard<std::mutex> sourcelock{context->mSourceLock};
3597     ALsource *source{LookupSource(context,src)};
3598     if(!source)
3599         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", src};
3600
3601     if(source->SourceType != AL_STREAMING)
3602         throw al::context_error{AL_INVALID_VALUE, "Unqueueing from a non-streaming source %u",src};
3603     if(source->Looping)
3604         throw al::context_error{AL_INVALID_VALUE, "Unqueueing from looping source %u", src};
3605
3606     /* Make sure enough buffers have been processed to unqueue. */
3607     const al::span bids{buffers, static_cast<ALuint>(nb)};
3608     size_t processed{0};
3609     if(source->state != AL_INITIAL) LIKELY
3610     {
3611         VoiceBufferItem *Current{nullptr};
3612         if(Voice *voice{GetSourceVoice(source, context)})
3613             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
3614         for(auto &item : source->mQueue)
3615         {
3616             if(&item == Current)
3617                 break;
3618             ++processed;
3619         }
3620     }
3621     if(processed < bids.size())
3622         throw al::context_error{AL_INVALID_VALUE, "Unqueueing %d buffer%s (only %zu processed)",
3623             nb, (nb==1)?"":"s", processed};
3624
3625     std::generate(bids.begin(), bids.end(), [source]() noexcept -> ALuint
3626     {
3627         auto &head = source->mQueue.front();
3628         ALuint bid{0};
3629         if(ALbuffer *buffer{head.mBuffer})
3630         {
3631             bid = buffer->id;
3632             DecrementRef(buffer->ref);
3633         }
3634         source->mQueue.pop_front();
3635         return bid;
3636     });
3637 }
3638 catch(al::context_error& e) {
3639     context->setError(e.errorCode(), "%s", e.what());
3640 }
3641
3642
3643 AL_API void AL_APIENTRY alSourceQueueBufferLayersSOFT(ALuint, ALsizei, const ALuint*) noexcept
3644 {
3645     ContextRef context{GetContextRef()};
3646     if(!context) UNLIKELY return;
3647
3648     context->setError(AL_INVALID_OPERATION, "alSourceQueueBufferLayersSOFT not supported");
3649 }
3650
3651
3652 ALsource::ALsource() noexcept
3653 {
3654     Direct.Gain = 1.0f;
3655     Direct.GainHF = 1.0f;
3656     Direct.HFReference = LowPassFreqRef;
3657     Direct.GainLF = 1.0f;
3658     Direct.LFReference = HighPassFreqRef;
3659     for(auto &send : Send)
3660     {
3661         send.Slot = nullptr;
3662         send.Gain = 1.0f;
3663         send.GainHF = 1.0f;
3664         send.HFReference = LowPassFreqRef;
3665         send.GainLF = 1.0f;
3666         send.LFReference = HighPassFreqRef;
3667     }
3668 }
3669
3670 ALsource::~ALsource()
3671 {
3672     for(auto &item : mQueue)
3673     {
3674         if(ALbuffer *buffer{item.mBuffer})
3675             DecrementRef(buffer->ref);
3676     }
3677
3678     auto clear_send = [](ALsource::SendData &send) -> void
3679     { if(send.Slot) DecrementRef(send.Slot->ref); };
3680     std::for_each(Send.begin(), Send.end(), clear_send);
3681 }
3682
3683 void UpdateAllSourceProps(ALCcontext *context)
3684 {
3685     std::lock_guard<std::mutex> srclock{context->mSourceLock};
3686     auto voicelist = context->getVoicesSpan();
3687     ALuint vidx{0u};
3688     for(Voice *voice : voicelist)
3689     {
3690         ALuint sid{voice->mSourceID.load(std::memory_order_acquire)};
3691         ALsource *source{sid ? LookupSource(context, sid) : nullptr};
3692         if(source && source->VoiceIdx == vidx)
3693         {
3694             if(std::exchange(source->mPropsDirty, false))
3695                 UpdateSourceProps(source, voice, context);
3696         }
3697         ++vidx;
3698     }
3699 }
3700
3701 void ALsource::SetName(ALCcontext *context, ALuint id, std::string_view name)
3702 {
3703     std::lock_guard<std::mutex> srclock{context->mSourceLock};
3704
3705     auto source = LookupSource(context, id);
3706     if(!source)
3707         throw al::context_error{AL_INVALID_NAME, "Invalid source ID %u", id};
3708
3709     context->mSourceNames.insert_or_assign(id, name);
3710 }
3711
3712
3713 SourceSubList::~SourceSubList()
3714 {
3715     if(!Sources)
3716         return;
3717
3718     uint64_t usemask{~FreeMask};
3719     while(usemask)
3720     {
3721         const int idx{al::countr_zero(usemask)};
3722         usemask &= ~(1_u64 << idx);
3723         std::destroy_at(al::to_address(Sources->begin() + idx));
3724     }
3725     FreeMask = ~usemask;
3726     SubListAllocator{}.deallocate(Sources, 1);
3727     Sources = nullptr;
3728 }
3729
3730
3731 #ifdef ALSOFT_EAX
3732 void ALsource::eaxInitialize(ALCcontext *context) noexcept
3733 {
3734     assert(context != nullptr);
3735     mEaxAlContext = context;
3736
3737     mEaxPrimaryFxSlotId = context->eaxGetPrimaryFxSlotIndex();
3738     eax_set_defaults();
3739
3740     eax1_translate(mEax1.i, mEax);
3741     mEaxVersion = 1;
3742     mEaxChanged = true;
3743 }
3744
3745 void ALsource::eaxDispatch(const EaxCall& call)
3746 {
3747     call.is_get() ? eax_get(call) : eax_set(call);
3748 }
3749
3750 ALsource* ALsource::EaxLookupSource(ALCcontext& al_context, ALuint source_id) noexcept
3751 {
3752     return LookupSource(&al_context, source_id);
3753 }
3754
3755 [[noreturn]] void ALsource::eax_fail(const char* message)
3756 {
3757     throw Exception{message};
3758 }
3759
3760 [[noreturn]] void ALsource::eax_fail_unknown_property_id()
3761 {
3762     eax_fail("Unknown property id.");
3763 }
3764
3765 [[noreturn]] void ALsource::eax_fail_unknown_version()
3766 {
3767     eax_fail("Unknown version.");
3768 }
3769
3770 [[noreturn]] void ALsource::eax_fail_unknown_active_fx_slot_id()
3771 {
3772     eax_fail("Unknown active FX slot ID.");
3773 }
3774
3775 [[noreturn]] void ALsource::eax_fail_unknown_receiving_fx_slot_id()
3776 {
3777     eax_fail("Unknown receiving FX slot ID.");
3778 }
3779
3780 void ALsource::eax_set_sends_defaults(EaxSends& sends, const EaxFxSlotIds& ids) noexcept
3781 {
3782     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
3783     {
3784         auto& send = sends[i];
3785         send.guidReceivingFXSlotID = *(ids[i]);
3786         send.lSend = EAXSOURCE_DEFAULTSEND;
3787         send.lSendHF = EAXSOURCE_DEFAULTSENDHF;
3788         send.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3789         send.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3790         send.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3791         send.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3792         send.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3793         send.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3794     }
3795 }
3796
3797 void ALsource::eax1_set_defaults(Eax1Props& props) noexcept
3798 {
3799     props.fMix = EAX_REVERBMIX_USEDISTANCE;
3800 }
3801
3802 void ALsource::eax1_set_defaults() noexcept
3803 {
3804     eax1_set_defaults(mEax1.i);
3805     mEax1.d = mEax1.i;
3806 }
3807
3808 void ALsource::eax2_set_defaults(Eax2Props& props) noexcept
3809 {
3810     props.lDirect = EAXSOURCE_DEFAULTDIRECT;
3811     props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
3812     props.lRoom = EAXSOURCE_DEFAULTROOM;
3813     props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
3814     props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
3815     props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
3816     props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
3817     props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3818     props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3819     props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3820     props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
3821     props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
3822     props.dwFlags = EAXSOURCE_DEFAULTFLAGS;
3823 }
3824
3825 void ALsource::eax2_set_defaults() noexcept
3826 {
3827     eax2_set_defaults(mEax2.i);
3828     mEax2.d = mEax2.i;
3829 }
3830
3831 void ALsource::eax3_set_defaults(Eax3Props& props) noexcept
3832 {
3833     props.lDirect = EAXSOURCE_DEFAULTDIRECT;
3834     props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
3835     props.lRoom = EAXSOURCE_DEFAULTROOM;
3836     props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
3837     props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
3838     props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
3839     props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
3840     props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
3841     props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
3842     props.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3843     props.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3844     props.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3845     props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
3846     props.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
3847     props.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
3848     props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
3849     props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
3850     props.ulFlags = EAXSOURCE_DEFAULTFLAGS;
3851 }
3852
3853 void ALsource::eax3_set_defaults() noexcept
3854 {
3855     eax3_set_defaults(mEax3.i);
3856     mEax3.d = mEax3.i;
3857 }
3858
3859 void ALsource::eax4_set_sends_defaults(EaxSends& sends) noexcept
3860 {
3861     eax_set_sends_defaults(sends, eax4_fx_slot_ids);
3862 }
3863
3864 void ALsource::eax4_set_active_fx_slots_defaults(EAX40ACTIVEFXSLOTS& slots) noexcept
3865 {
3866     slots = EAX40SOURCE_DEFAULTACTIVEFXSLOTID;
3867 }
3868
3869 void ALsource::eax4_set_defaults() noexcept
3870 {
3871     eax3_set_defaults(mEax4.i.source);
3872     eax4_set_sends_defaults(mEax4.i.sends);
3873     eax4_set_active_fx_slots_defaults(mEax4.i.active_fx_slots);
3874     mEax4.d = mEax4.i;
3875 }
3876
3877 void ALsource::eax5_set_source_defaults(EAX50SOURCEPROPERTIES& props) noexcept
3878 {
3879     eax3_set_defaults(static_cast<Eax3Props&>(props));
3880     props.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3881 }
3882
3883 void ALsource::eax5_set_sends_defaults(EaxSends& sends) noexcept
3884 {
3885     eax_set_sends_defaults(sends, eax5_fx_slot_ids);
3886 }
3887
3888 void ALsource::eax5_set_active_fx_slots_defaults(EAX50ACTIVEFXSLOTS& slots) noexcept
3889 {
3890     slots = EAX50SOURCE_3DDEFAULTACTIVEFXSLOTID;
3891 }
3892
3893 void ALsource::eax5_set_speaker_levels_defaults(EaxSpeakerLevels& speaker_levels) noexcept
3894 {
3895     for(size_t i{0};i < eax_max_speakers;++i)
3896     {
3897         auto& speaker_level = speaker_levels[i];
3898         speaker_level.lSpeakerID = static_cast<long>(EAXSPEAKER_FRONT_LEFT + i);
3899         speaker_level.lLevel = EAXSOURCE_DEFAULTSPEAKERLEVEL;
3900     }
3901 }
3902
3903 void ALsource::eax5_set_defaults(Eax5Props& props) noexcept
3904 {
3905     eax5_set_source_defaults(props.source);
3906     eax5_set_sends_defaults(props.sends);
3907     eax5_set_active_fx_slots_defaults(props.active_fx_slots);
3908     eax5_set_speaker_levels_defaults(props.speaker_levels);
3909 }
3910
3911 void ALsource::eax5_set_defaults() noexcept
3912 {
3913     eax5_set_defaults(mEax5.i);
3914     mEax5.d = mEax5.i;
3915 }
3916
3917 void ALsource::eax_set_defaults() noexcept
3918 {
3919     eax1_set_defaults();
3920     eax2_set_defaults();
3921     eax3_set_defaults();
3922     eax4_set_defaults();
3923     eax5_set_defaults();
3924 }
3925
3926 void ALsource::eax1_translate(const Eax1Props& src, Eax5Props& dst) noexcept
3927 {
3928     eax5_set_defaults(dst);
3929
3930     if (src.fMix == EAX_REVERBMIX_USEDISTANCE)
3931     {
3932         dst.source.ulFlags |= EAXSOURCEFLAGS_ROOMAUTO;
3933         dst.sends[0].lSend = 0;
3934     }
3935     else
3936     {
3937         dst.source.ulFlags &= ~EAXSOURCEFLAGS_ROOMAUTO;
3938         dst.sends[0].lSend = std::clamp(static_cast<long>(gain_to_level_mb(src.fMix)),
3939             EAXSOURCE_MINSEND, EAXSOURCE_MAXSEND);
3940     }
3941 }
3942
3943 void ALsource::eax2_translate(const Eax2Props& src, Eax5Props& dst) noexcept
3944 {
3945     // Source.
3946     //
3947     dst.source.lDirect = src.lDirect;
3948     dst.source.lDirectHF = src.lDirectHF;
3949     dst.source.lRoom = src.lRoom;
3950     dst.source.lRoomHF = src.lRoomHF;
3951     dst.source.lObstruction = src.lObstruction;
3952     dst.source.flObstructionLFRatio = src.flObstructionLFRatio;
3953     dst.source.lOcclusion = src.lOcclusion;
3954     dst.source.flOcclusionLFRatio = src.flOcclusionLFRatio;
3955     dst.source.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
3956     dst.source.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
3957     dst.source.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
3958     dst.source.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
3959     dst.source.lOutsideVolumeHF = src.lOutsideVolumeHF;
3960     dst.source.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
3961     dst.source.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
3962     dst.source.flRoomRolloffFactor = src.flRoomRolloffFactor;
3963     dst.source.flAirAbsorptionFactor = src.flAirAbsorptionFactor;
3964     dst.source.ulFlags = src.dwFlags;
3965     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3966
3967     // Set everything else to defaults.
3968     //
3969     eax5_set_sends_defaults(dst.sends);
3970     eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
3971     eax5_set_speaker_levels_defaults(dst.speaker_levels);
3972 }
3973
3974 void ALsource::eax3_translate(const Eax3Props& src, Eax5Props& dst) noexcept
3975 {
3976     // Source.
3977     //
3978     static_cast<Eax3Props&>(dst.source) = src;
3979     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3980
3981     // Set everything else to defaults.
3982     //
3983     eax5_set_sends_defaults(dst.sends);
3984     eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
3985     eax5_set_speaker_levels_defaults(dst.speaker_levels);
3986 }
3987
3988 void ALsource::eax4_translate(const Eax4Props& src, Eax5Props& dst) noexcept
3989 {
3990     // Source.
3991     //
3992     static_cast<Eax3Props&>(dst.source) = src.source;
3993     dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
3994
3995     // Sends.
3996     //
3997     dst.sends = src.sends;
3998
3999     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4000         dst.sends[i].guidReceivingFXSlotID = *(eax5_fx_slot_ids[i]);
4001
4002     // Active FX slots.
4003     //
4004     for(size_t i{0};i < EAX50_MAX_ACTIVE_FXSLOTS;++i)
4005     {
4006         auto& dst_id = dst.active_fx_slots.guidActiveFXSlots[i];
4007
4008         if(i < EAX40_MAX_ACTIVE_FXSLOTS)
4009         {
4010             const auto& src_id = src.active_fx_slots.guidActiveFXSlots[i];
4011
4012             if(src_id == EAX_NULL_GUID)
4013                 dst_id = EAX_NULL_GUID;
4014             else if(src_id == EAX_PrimaryFXSlotID)
4015                 dst_id = EAX_PrimaryFXSlotID;
4016             else if(src_id == EAXPROPERTYID_EAX40_FXSlot0)
4017                 dst_id = EAXPROPERTYID_EAX50_FXSlot0;
4018             else if(src_id == EAXPROPERTYID_EAX40_FXSlot1)
4019                 dst_id = EAXPROPERTYID_EAX50_FXSlot1;
4020             else if(src_id == EAXPROPERTYID_EAX40_FXSlot2)
4021                 dst_id = EAXPROPERTYID_EAX50_FXSlot2;
4022             else if(src_id == EAXPROPERTYID_EAX40_FXSlot3)
4023                 dst_id = EAXPROPERTYID_EAX50_FXSlot3;
4024             else
4025                 assert(false && "Unknown active FX slot ID.");
4026         }
4027         else
4028             dst_id = EAX_NULL_GUID;
4029     }
4030
4031     // Speaker levels.
4032     //
4033     eax5_set_speaker_levels_defaults(dst.speaker_levels);
4034 }
4035
4036 float ALsource::eax_calculate_dst_occlusion_mb(
4037     long src_occlusion_mb,
4038     float path_ratio,
4039     float lf_ratio) noexcept
4040 {
4041     const auto ratio_1 = path_ratio + lf_ratio - 1.0F;
4042     const auto ratio_2 = path_ratio * lf_ratio;
4043     const auto ratio = (ratio_2 > ratio_1) ? ratio_2 : ratio_1;
4044     const auto dst_occlustion_mb = static_cast<float>(src_occlusion_mb) * ratio;
4045     return dst_occlustion_mb;
4046 }
4047
4048 EaxAlLowPassParam ALsource::eax_create_direct_filter_param() const noexcept
4049 {
4050     auto gain_mb =
4051         static_cast<float>(mEax.source.lDirect) +
4052         (static_cast<float>(mEax.source.lObstruction) * mEax.source.flObstructionLFRatio) +
4053         eax_calculate_dst_occlusion_mb(
4054             mEax.source.lOcclusion,
4055             mEax.source.flOcclusionDirectRatio,
4056             mEax.source.flOcclusionLFRatio);
4057
4058     const auto has_source_occlusion = (mEax.source.lOcclusion != 0);
4059
4060     auto gain_hf_mb =
4061         static_cast<float>(mEax.source.lDirectHF) +
4062         static_cast<float>(mEax.source.lObstruction);
4063
4064     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4065     {
4066         if(!mEaxActiveFxSlots[i])
4067             continue;
4068
4069         if(has_source_occlusion)
4070         {
4071             const auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
4072             const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
4073             const auto is_environmental_fx = ((fx_slot_eax.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0);
4074             const auto is_primary = (mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index());
4075             const auto is_listener_environment = (is_environmental_fx && is_primary);
4076
4077             if(is_listener_environment)
4078             {
4079                 gain_mb += eax_calculate_dst_occlusion_mb(
4080                     mEax.source.lOcclusion,
4081                     mEax.source.flOcclusionDirectRatio,
4082                     mEax.source.flOcclusionLFRatio);
4083
4084                 gain_hf_mb += static_cast<float>(mEax.source.lOcclusion) * mEax.source.flOcclusionDirectRatio;
4085             }
4086         }
4087
4088         const auto& send = mEax.sends[i];
4089
4090         if(send.lOcclusion != 0)
4091         {
4092             gain_mb += eax_calculate_dst_occlusion_mb(
4093                 send.lOcclusion,
4094                 send.flOcclusionDirectRatio,
4095                 send.flOcclusionLFRatio);
4096
4097             gain_hf_mb += static_cast<float>(send.lOcclusion) * send.flOcclusionDirectRatio;
4098         }
4099     }
4100
4101     return EaxAlLowPassParam{
4102         level_mb_to_gain(gain_mb),
4103         std::min(level_mb_to_gain(gain_hf_mb), 1.0f)};
4104 }
4105
4106 EaxAlLowPassParam ALsource::eax_create_room_filter_param(
4107     const ALeffectslot& fx_slot,
4108     const EAXSOURCEALLSENDPROPERTIES& send) const noexcept
4109 {
4110     const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
4111     const auto is_environmental_fx = ((fx_slot_eax.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0);
4112     const auto is_primary = (mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index());
4113     const auto is_listener_environment = (is_environmental_fx && is_primary);
4114
4115     const auto gain_mb =
4116         (static_cast<float>(fx_slot_eax.lOcclusion) * fx_slot_eax.flOcclusionLFRatio) +
4117         static_cast<float>((is_environmental_fx ? mEax.source.lRoom : 0) + send.lSend) +
4118         (is_listener_environment ?
4119             eax_calculate_dst_occlusion_mb(
4120                 mEax.source.lOcclusion,
4121                 mEax.source.flOcclusionRoomRatio,
4122                 mEax.source.flOcclusionLFRatio) :
4123             0.0f) +
4124         eax_calculate_dst_occlusion_mb(
4125             send.lOcclusion,
4126             send.flOcclusionRoomRatio,
4127             send.flOcclusionLFRatio) +
4128         (is_listener_environment ?
4129             (static_cast<float>(mEax.source.lExclusion) * mEax.source.flExclusionLFRatio) :
4130             0.0f) +
4131         (static_cast<float>(send.lExclusion) * send.flExclusionLFRatio);
4132
4133     const auto gain_hf_mb =
4134         static_cast<float>(fx_slot_eax.lOcclusion) +
4135         static_cast<float>((is_environmental_fx ? mEax.source.lRoomHF : 0) + send.lSendHF) +
4136         (is_listener_environment ?
4137             ((static_cast<float>(mEax.source.lOcclusion) * mEax.source.flOcclusionRoomRatio)) :
4138             0.0f) +
4139         (static_cast<float>(send.lOcclusion) * send.flOcclusionRoomRatio) +
4140         (is_listener_environment ?
4141             static_cast<float>(mEax.source.lExclusion + send.lExclusion) :
4142             0.0f);
4143
4144     return EaxAlLowPassParam{
4145         level_mb_to_gain(gain_mb),
4146         std::min(level_mb_to_gain(gain_hf_mb), 1.0f)};
4147 }
4148
4149 void ALsource::eax_update_direct_filter()
4150 {
4151     const auto& direct_param = eax_create_direct_filter_param();
4152     Direct.Gain = direct_param.gain;
4153     Direct.GainHF = direct_param.gain_hf;
4154     Direct.HFReference = LowPassFreqRef;
4155     Direct.GainLF = 1.0f;
4156     Direct.LFReference = HighPassFreqRef;
4157     mPropsDirty = true;
4158 }
4159
4160 void ALsource::eax_update_room_filters()
4161 {
4162     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4163     {
4164         if(!mEaxActiveFxSlots[i])
4165             continue;
4166
4167         auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
4168         const auto& send = mEax.sends[i];
4169         const auto& room_param = eax_create_room_filter_param(fx_slot, send);
4170         eax_set_al_source_send(&fx_slot, i, room_param);
4171     }
4172 }
4173
4174 void ALsource::eax_set_efx_outer_gain_hf()
4175 {
4176     OuterGainHF = std::clamp(
4177         level_mb_to_gain(static_cast<float>(mEax.source.lOutsideVolumeHF)),
4178         AL_MIN_CONE_OUTER_GAINHF,
4179         AL_MAX_CONE_OUTER_GAINHF);
4180 }
4181
4182 void ALsource::eax_set_efx_doppler_factor()
4183 {
4184     DopplerFactor = mEax.source.flDopplerFactor;
4185 }
4186
4187 void ALsource::eax_set_efx_rolloff_factor()
4188 {
4189     RolloffFactor2 = mEax.source.flRolloffFactor;
4190 }
4191
4192 void ALsource::eax_set_efx_room_rolloff_factor()
4193 {
4194     RoomRolloffFactor = mEax.source.flRoomRolloffFactor;
4195 }
4196
4197 void ALsource::eax_set_efx_air_absorption_factor()
4198 {
4199     AirAbsorptionFactor = mEax.source.flAirAbsorptionFactor;
4200 }
4201
4202 void ALsource::eax_set_efx_dry_gain_hf_auto()
4203 {
4204     DryGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_DIRECTHFAUTO) != 0);
4205 }
4206
4207 void ALsource::eax_set_efx_wet_gain_auto()
4208 {
4209     WetGainAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMAUTO) != 0);
4210 }
4211
4212 void ALsource::eax_set_efx_wet_gain_hf_auto()
4213 {
4214     WetGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMHFAUTO) != 0);
4215 }
4216
4217 void ALsource::eax1_set(const EaxCall& call, Eax1Props& props)
4218 {
4219     switch (call.get_property_id()) {
4220         case DSPROPERTY_EAXBUFFER_ALL:
4221             eax_defer<Eax1SourceAllValidator>(call, props);
4222             break;
4223
4224         case DSPROPERTY_EAXBUFFER_REVERBMIX:
4225             eax_defer<Eax1SourceReverbMixValidator>(call, props.fMix);
4226             break;
4227
4228         default:
4229             eax_fail_unknown_property_id();
4230     }
4231 }
4232
4233 void ALsource::eax2_set(const EaxCall& call, Eax2Props& props)
4234 {
4235     switch (call.get_property_id()) {
4236         case DSPROPERTY_EAX20BUFFER_NONE:
4237             break;
4238
4239         case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
4240             eax_defer<Eax2SourceAllValidator>(call, props);
4241             break;
4242
4243         case DSPROPERTY_EAX20BUFFER_DIRECT:
4244             eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
4245             break;
4246
4247         case DSPROPERTY_EAX20BUFFER_DIRECTHF:
4248             eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
4249             break;
4250
4251         case DSPROPERTY_EAX20BUFFER_ROOM:
4252             eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
4253             break;
4254
4255         case DSPROPERTY_EAX20BUFFER_ROOMHF:
4256             eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
4257             break;
4258
4259         case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
4260             eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
4261             break;
4262
4263         case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
4264             eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
4265             break;
4266
4267         case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
4268             eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
4269             break;
4270
4271         case DSPROPERTY_EAX20BUFFER_OCCLUSION:
4272             eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
4273             break;
4274
4275         case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
4276             eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
4277             break;
4278
4279         case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
4280             eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
4281             break;
4282
4283         case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
4284             eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
4285             break;
4286
4287         case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
4288             eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
4289             break;
4290
4291         case DSPROPERTY_EAX20BUFFER_FLAGS:
4292             eax_defer<Eax2SourceFlagsValidator>(call, props.dwFlags);
4293             break;
4294
4295         default:
4296             eax_fail_unknown_property_id();
4297     }
4298 }
4299
4300 void ALsource::eax3_set(const EaxCall& call, Eax3Props& props)
4301 {
4302     switch (call.get_property_id()) {
4303         case EAXSOURCE_NONE:
4304             break;
4305
4306         case EAXSOURCE_ALLPARAMETERS:
4307             eax_defer<Eax3SourceAllValidator>(call, props);
4308             break;
4309
4310         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4311             eax_defer_sub<Eax4ObstructionValidator, EAXOBSTRUCTIONPROPERTIES>(call, props.lObstruction);
4312             break;
4313
4314         case EAXSOURCE_OCCLUSIONPARAMETERS:
4315             eax_defer_sub<Eax4OcclusionValidator, EAXOCCLUSIONPROPERTIES>(call, props.lOcclusion);
4316             break;
4317
4318         case EAXSOURCE_EXCLUSIONPARAMETERS:
4319             eax_defer_sub<Eax4ExclusionValidator, EAXEXCLUSIONPROPERTIES>(call, props.lExclusion);
4320             break;
4321
4322         case EAXSOURCE_DIRECT:
4323             eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
4324             break;
4325
4326         case EAXSOURCE_DIRECTHF:
4327             eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
4328             break;
4329
4330         case EAXSOURCE_ROOM:
4331             eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
4332             break;
4333
4334         case EAXSOURCE_ROOMHF:
4335             eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
4336             break;
4337
4338         case EAXSOURCE_OBSTRUCTION:
4339             eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
4340             break;
4341
4342         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4343             eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
4344             break;
4345
4346         case EAXSOURCE_OCCLUSION:
4347             eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
4348             break;
4349
4350         case EAXSOURCE_OCCLUSIONLFRATIO:
4351             eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
4352             break;
4353
4354         case EAXSOURCE_OCCLUSIONROOMRATIO:
4355             eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
4356             break;
4357
4358         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4359             eax_defer<Eax3SourceOcclusionDirectRatioValidator>(call, props.flOcclusionDirectRatio);
4360             break;
4361
4362         case EAXSOURCE_EXCLUSION:
4363             eax_defer<Eax3SourceExclusionValidator>(call, props.lExclusion);
4364             break;
4365
4366         case EAXSOURCE_EXCLUSIONLFRATIO:
4367             eax_defer<Eax3SourceExclusionLfRatioValidator>(call, props.flExclusionLFRatio);
4368             break;
4369
4370         case EAXSOURCE_OUTSIDEVOLUMEHF:
4371             eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
4372             break;
4373
4374         case EAXSOURCE_DOPPLERFACTOR:
4375             eax_defer<Eax3SourceDopplerFactorValidator>(call, props.flDopplerFactor);
4376             break;
4377
4378         case EAXSOURCE_ROLLOFFFACTOR:
4379             eax_defer<Eax3SourceRolloffFactorValidator>(call, props.flRolloffFactor);
4380             break;
4381
4382         case EAXSOURCE_ROOMROLLOFFFACTOR:
4383             eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
4384             break;
4385
4386         case EAXSOURCE_AIRABSORPTIONFACTOR:
4387             eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
4388             break;
4389
4390         case EAXSOURCE_FLAGS:
4391             eax_defer<Eax2SourceFlagsValidator>(call, props.ulFlags);
4392             break;
4393
4394         default:
4395             eax_fail_unknown_property_id();
4396     }
4397 }
4398
4399 void ALsource::eax4_set(const EaxCall& call, Eax4Props& props)
4400 {
4401     switch (call.get_property_id()) {
4402         case EAXSOURCE_NONE:
4403         case EAXSOURCE_ALLPARAMETERS:
4404         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4405         case EAXSOURCE_OCCLUSIONPARAMETERS:
4406         case EAXSOURCE_EXCLUSIONPARAMETERS:
4407         case EAXSOURCE_DIRECT:
4408         case EAXSOURCE_DIRECTHF:
4409         case EAXSOURCE_ROOM:
4410         case EAXSOURCE_ROOMHF:
4411         case EAXSOURCE_OBSTRUCTION:
4412         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4413         case EAXSOURCE_OCCLUSION:
4414         case EAXSOURCE_OCCLUSIONLFRATIO:
4415         case EAXSOURCE_OCCLUSIONROOMRATIO:
4416         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4417         case EAXSOURCE_EXCLUSION:
4418         case EAXSOURCE_EXCLUSIONLFRATIO:
4419         case EAXSOURCE_OUTSIDEVOLUMEHF:
4420         case EAXSOURCE_DOPPLERFACTOR:
4421         case EAXSOURCE_ROLLOFFFACTOR:
4422         case EAXSOURCE_ROOMROLLOFFFACTOR:
4423         case EAXSOURCE_AIRABSORPTIONFACTOR:
4424         case EAXSOURCE_FLAGS:
4425             eax3_set(call, props.source);
4426             break;
4427
4428         case EAXSOURCE_SENDPARAMETERS:
4429             eax4_defer_sends<Eax4SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
4430             break;
4431
4432         case EAXSOURCE_ALLSENDPARAMETERS:
4433             eax4_defer_sends<Eax4AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4434             break;
4435
4436         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4437             eax4_defer_sends<Eax4OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4438             break;
4439
4440         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4441             eax4_defer_sends<Eax4ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4442             break;
4443
4444         case EAXSOURCE_ACTIVEFXSLOTID:
4445             eax4_defer_active_fx_slot_id(call, al::span{props.active_fx_slots.guidActiveFXSlots});
4446             break;
4447
4448         default:
4449             eax_fail_unknown_property_id();
4450     }
4451 }
4452
4453 void ALsource::eax5_defer_all_2d(const EaxCall& call, EAX50SOURCEPROPERTIES& props)
4454 {
4455     const auto& src_props = call.get_value<Exception, const EAXSOURCE2DPROPERTIES>();
4456     Eax5SourceAll2dValidator{}(src_props);
4457     props.lDirect = src_props.lDirect;
4458     props.lDirectHF = src_props.lDirectHF;
4459     props.lRoom = src_props.lRoom;
4460     props.lRoomHF = src_props.lRoomHF;
4461     props.ulFlags = src_props.ulFlags;
4462 }
4463
4464 void ALsource::eax5_defer_speaker_levels(const EaxCall& call, EaxSpeakerLevels& props)
4465 {
4466     const auto values = call.get_values<const EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
4467     std::for_each(values.cbegin(), values.cend(), Eax5SpeakerAllValidator{});
4468
4469     for (const auto& value : values) {
4470         const auto index = static_cast<size_t>(value.lSpeakerID - EAXSPEAKER_FRONT_LEFT);
4471         props[index].lLevel = value.lLevel;
4472     }
4473 }
4474
4475 void ALsource::eax5_set(const EaxCall& call, Eax5Props& props)
4476 {
4477     switch (call.get_property_id()) {
4478         case EAXSOURCE_NONE:
4479             break;
4480
4481         case EAXSOURCE_ALLPARAMETERS:
4482             eax_defer<Eax5SourceAllValidator>(call, props.source);
4483             break;
4484
4485         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4486         case EAXSOURCE_OCCLUSIONPARAMETERS:
4487         case EAXSOURCE_EXCLUSIONPARAMETERS:
4488         case EAXSOURCE_DIRECT:
4489         case EAXSOURCE_DIRECTHF:
4490         case EAXSOURCE_ROOM:
4491         case EAXSOURCE_ROOMHF:
4492         case EAXSOURCE_OBSTRUCTION:
4493         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4494         case EAXSOURCE_OCCLUSION:
4495         case EAXSOURCE_OCCLUSIONLFRATIO:
4496         case EAXSOURCE_OCCLUSIONROOMRATIO:
4497         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4498         case EAXSOURCE_EXCLUSION:
4499         case EAXSOURCE_EXCLUSIONLFRATIO:
4500         case EAXSOURCE_OUTSIDEVOLUMEHF:
4501         case EAXSOURCE_DOPPLERFACTOR:
4502         case EAXSOURCE_ROLLOFFFACTOR:
4503         case EAXSOURCE_ROOMROLLOFFFACTOR:
4504         case EAXSOURCE_AIRABSORPTIONFACTOR:
4505         case EAXSOURCE_FLAGS:
4506             eax3_set(call, props.source);
4507             break;
4508
4509         case EAXSOURCE_SENDPARAMETERS:
4510             eax5_defer_sends<Eax5SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
4511             break;
4512
4513         case EAXSOURCE_ALLSENDPARAMETERS:
4514             eax5_defer_sends<Eax5AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4515             break;
4516
4517         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4518             eax5_defer_sends<Eax5OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4519             break;
4520
4521         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4522             eax5_defer_sends<Eax5ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4523             break;
4524
4525         case EAXSOURCE_ACTIVEFXSLOTID:
4526             eax5_defer_active_fx_slot_id(call, al::span{props.active_fx_slots.guidActiveFXSlots});
4527             break;
4528
4529         case EAXSOURCE_MACROFXFACTOR:
4530             eax_defer<Eax5SourceMacroFXFactorValidator>(call, props.source.flMacroFXFactor);
4531             break;
4532
4533         case EAXSOURCE_SPEAKERLEVELS:
4534             eax5_defer_speaker_levels(call, props.speaker_levels);
4535             break;
4536
4537         case EAXSOURCE_ALL2DPARAMETERS:
4538             eax5_defer_all_2d(call, props.source);
4539             break;
4540
4541         default:
4542             eax_fail_unknown_property_id();
4543     }
4544 }
4545
4546 void ALsource::eax_set(const EaxCall& call)
4547 {
4548     const auto eax_version = call.get_version();
4549     switch(eax_version)
4550     {
4551     case 1: eax1_set(call, mEax1.d); break;
4552     case 2: eax2_set(call, mEax2.d); break;
4553     case 3: eax3_set(call, mEax3.d); break;
4554     case 4: eax4_set(call, mEax4.d); break;
4555     case 5: eax5_set(call, mEax5.d); break;
4556     default: eax_fail_unknown_property_id();
4557     }
4558     mEaxChanged = true;
4559     mEaxVersion = eax_version;
4560 }
4561
4562 void ALsource::eax_get_active_fx_slot_id(const EaxCall& call, const al::span<const GUID> src_ids)
4563 {
4564     assert(src_ids.size()==EAX40_MAX_ACTIVE_FXSLOTS || src_ids.size()==EAX50_MAX_ACTIVE_FXSLOTS);
4565     const auto dst_ids = call.get_values<GUID>(src_ids.size());
4566     std::uninitialized_copy_n(src_ids.begin(), dst_ids.size(), dst_ids.begin());
4567 }
4568
4569 void ALsource::eax1_get(const EaxCall& call, const Eax1Props& props)
4570 {
4571     switch (call.get_property_id()) {
4572         case DSPROPERTY_EAXBUFFER_ALL:
4573         case DSPROPERTY_EAXBUFFER_REVERBMIX:
4574             call.set_value<Exception>(props.fMix);
4575             break;
4576
4577         default:
4578             eax_fail_unknown_property_id();
4579     }
4580 }
4581
4582 void ALsource::eax2_get(const EaxCall& call, const Eax2Props& props)
4583 {
4584     switch (call.get_property_id()) {
4585         case DSPROPERTY_EAX20BUFFER_NONE:
4586             break;
4587
4588         case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
4589             call.set_value<Exception>(props);
4590             break;
4591
4592         case DSPROPERTY_EAX20BUFFER_DIRECT:
4593             call.set_value<Exception>(props.lDirect);
4594             break;
4595
4596         case DSPROPERTY_EAX20BUFFER_DIRECTHF:
4597             call.set_value<Exception>(props.lDirectHF);
4598             break;
4599
4600         case DSPROPERTY_EAX20BUFFER_ROOM:
4601             call.set_value<Exception>(props.lRoom);
4602             break;
4603
4604         case DSPROPERTY_EAX20BUFFER_ROOMHF:
4605             call.set_value<Exception>(props.lRoomHF);
4606             break;
4607
4608         case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
4609             call.set_value<Exception>(props.flRoomRolloffFactor);
4610             break;
4611
4612         case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
4613             call.set_value<Exception>(props.lObstruction);
4614             break;
4615
4616         case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
4617             call.set_value<Exception>(props.flObstructionLFRatio);
4618             break;
4619
4620         case DSPROPERTY_EAX20BUFFER_OCCLUSION:
4621             call.set_value<Exception>(props.lOcclusion);
4622             break;
4623
4624         case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
4625             call.set_value<Exception>(props.flOcclusionLFRatio);
4626             break;
4627
4628         case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
4629             call.set_value<Exception>(props.flOcclusionRoomRatio);
4630             break;
4631
4632         case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
4633             call.set_value<Exception>(props.lOutsideVolumeHF);
4634             break;
4635
4636         case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
4637             call.set_value<Exception>(props.flAirAbsorptionFactor);
4638             break;
4639
4640         case DSPROPERTY_EAX20BUFFER_FLAGS:
4641             call.set_value<Exception>(props.dwFlags);
4642             break;
4643
4644         default:
4645             eax_fail_unknown_property_id();
4646     }
4647 }
4648
4649 void ALsource::eax3_get_obstruction(const EaxCall& call, const Eax3Props& props)
4650 {
4651     const auto& subprops = reinterpret_cast<const EAXOBSTRUCTIONPROPERTIES&>(props.lObstruction);
4652     call.set_value<Exception>(subprops);
4653 }
4654
4655 void ALsource::eax3_get_occlusion(const EaxCall& call, const Eax3Props& props)
4656 {
4657     const auto& subprops = reinterpret_cast<const EAXOCCLUSIONPROPERTIES&>(props.lOcclusion);
4658     call.set_value<Exception>(subprops);
4659 }
4660
4661 void ALsource::eax3_get_exclusion(const EaxCall& call, const Eax3Props& props)
4662 {
4663     const auto& subprops = reinterpret_cast<const EAXEXCLUSIONPROPERTIES&>(props.lExclusion);
4664     call.set_value<Exception>(subprops);
4665 }
4666
4667 void ALsource::eax3_get(const EaxCall& call, const Eax3Props& props)
4668 {
4669     switch (call.get_property_id()) {
4670         case EAXSOURCE_NONE:
4671             break;
4672
4673         case EAXSOURCE_ALLPARAMETERS:
4674             call.set_value<Exception>(props);
4675             break;
4676
4677         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4678             eax3_get_obstruction(call, props);
4679             break;
4680
4681         case EAXSOURCE_OCCLUSIONPARAMETERS:
4682             eax3_get_occlusion(call, props);
4683             break;
4684
4685         case EAXSOURCE_EXCLUSIONPARAMETERS:
4686             eax3_get_exclusion(call, props);
4687             break;
4688
4689         case EAXSOURCE_DIRECT:
4690             call.set_value<Exception>(props.lDirect);
4691             break;
4692
4693         case EAXSOURCE_DIRECTHF:
4694             call.set_value<Exception>(props.lDirectHF);
4695             break;
4696
4697         case EAXSOURCE_ROOM:
4698             call.set_value<Exception>(props.lRoom);
4699             break;
4700
4701         case EAXSOURCE_ROOMHF:
4702             call.set_value<Exception>(props.lRoomHF);
4703             break;
4704
4705         case EAXSOURCE_OBSTRUCTION:
4706             call.set_value<Exception>(props.lObstruction);
4707             break;
4708
4709         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4710             call.set_value<Exception>(props.flObstructionLFRatio);
4711             break;
4712
4713         case EAXSOURCE_OCCLUSION:
4714             call.set_value<Exception>(props.lOcclusion);
4715             break;
4716
4717         case EAXSOURCE_OCCLUSIONLFRATIO:
4718             call.set_value<Exception>(props.flOcclusionLFRatio);
4719             break;
4720
4721         case EAXSOURCE_OCCLUSIONROOMRATIO:
4722             call.set_value<Exception>(props.flOcclusionRoomRatio);
4723             break;
4724
4725         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4726             call.set_value<Exception>(props.flOcclusionDirectRatio);
4727             break;
4728
4729         case EAXSOURCE_EXCLUSION:
4730             call.set_value<Exception>(props.lExclusion);
4731             break;
4732
4733         case EAXSOURCE_EXCLUSIONLFRATIO:
4734             call.set_value<Exception>(props.flExclusionLFRatio);
4735             break;
4736
4737         case EAXSOURCE_OUTSIDEVOLUMEHF:
4738             call.set_value<Exception>(props.lOutsideVolumeHF);
4739             break;
4740
4741         case EAXSOURCE_DOPPLERFACTOR:
4742             call.set_value<Exception>(props.flDopplerFactor);
4743             break;
4744
4745         case EAXSOURCE_ROLLOFFFACTOR:
4746             call.set_value<Exception>(props.flRolloffFactor);
4747             break;
4748
4749         case EAXSOURCE_ROOMROLLOFFFACTOR:
4750             call.set_value<Exception>(props.flRoomRolloffFactor);
4751             break;
4752
4753         case EAXSOURCE_AIRABSORPTIONFACTOR:
4754             call.set_value<Exception>(props.flAirAbsorptionFactor);
4755             break;
4756
4757         case EAXSOURCE_FLAGS:
4758             call.set_value<Exception>(props.ulFlags);
4759             break;
4760
4761         default:
4762             eax_fail_unknown_property_id();
4763     }
4764 }
4765
4766 void ALsource::eax4_get(const EaxCall& call, const Eax4Props& props)
4767 {
4768     switch (call.get_property_id()) {
4769         case EAXSOURCE_NONE:
4770             break;
4771
4772         case EAXSOURCE_ALLPARAMETERS:
4773         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4774         case EAXSOURCE_OCCLUSIONPARAMETERS:
4775         case EAXSOURCE_EXCLUSIONPARAMETERS:
4776         case EAXSOURCE_DIRECT:
4777         case EAXSOURCE_DIRECTHF:
4778         case EAXSOURCE_ROOM:
4779         case EAXSOURCE_ROOMHF:
4780         case EAXSOURCE_OBSTRUCTION:
4781         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4782         case EAXSOURCE_OCCLUSION:
4783         case EAXSOURCE_OCCLUSIONLFRATIO:
4784         case EAXSOURCE_OCCLUSIONROOMRATIO:
4785         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4786         case EAXSOURCE_EXCLUSION:
4787         case EAXSOURCE_EXCLUSIONLFRATIO:
4788         case EAXSOURCE_OUTSIDEVOLUMEHF:
4789         case EAXSOURCE_DOPPLERFACTOR:
4790         case EAXSOURCE_ROLLOFFFACTOR:
4791         case EAXSOURCE_ROOMROLLOFFFACTOR:
4792         case EAXSOURCE_AIRABSORPTIONFACTOR:
4793         case EAXSOURCE_FLAGS:
4794             eax3_get(call, props.source);
4795             break;
4796
4797         case EAXSOURCE_SENDPARAMETERS:
4798             eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
4799             break;
4800
4801         case EAXSOURCE_ALLSENDPARAMETERS:
4802             eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4803             break;
4804
4805         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4806             eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4807             break;
4808
4809         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4810             eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4811             break;
4812
4813         case EAXSOURCE_ACTIVEFXSLOTID:
4814             eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
4815             break;
4816
4817         default:
4818             eax_fail_unknown_property_id();
4819     }
4820 }
4821
4822 void ALsource::eax5_get_all_2d(const EaxCall& call, const EAX50SOURCEPROPERTIES& props)
4823 {
4824     auto& subprops = call.get_value<Exception, EAXSOURCE2DPROPERTIES>();
4825     subprops.lDirect = props.lDirect;
4826     subprops.lDirectHF = props.lDirectHF;
4827     subprops.lRoom = props.lRoom;
4828     subprops.lRoomHF = props.lRoomHF;
4829     subprops.ulFlags = props.ulFlags;
4830 }
4831
4832 void ALsource::eax5_get_speaker_levels(const EaxCall& call, const EaxSpeakerLevels& props)
4833 {
4834     const auto subprops = call.get_values<EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
4835     std::uninitialized_copy_n(props.cbegin(), subprops.size(), subprops.begin());
4836 }
4837
4838 void ALsource::eax5_get(const EaxCall& call, const Eax5Props& props)
4839 {
4840     switch (call.get_property_id()) {
4841         case EAXSOURCE_NONE:
4842             break;
4843
4844         case EAXSOURCE_ALLPARAMETERS:
4845         case EAXSOURCE_OBSTRUCTIONPARAMETERS:
4846         case EAXSOURCE_OCCLUSIONPARAMETERS:
4847         case EAXSOURCE_EXCLUSIONPARAMETERS:
4848         case EAXSOURCE_DIRECT:
4849         case EAXSOURCE_DIRECTHF:
4850         case EAXSOURCE_ROOM:
4851         case EAXSOURCE_ROOMHF:
4852         case EAXSOURCE_OBSTRUCTION:
4853         case EAXSOURCE_OBSTRUCTIONLFRATIO:
4854         case EAXSOURCE_OCCLUSION:
4855         case EAXSOURCE_OCCLUSIONLFRATIO:
4856         case EAXSOURCE_OCCLUSIONROOMRATIO:
4857         case EAXSOURCE_OCCLUSIONDIRECTRATIO:
4858         case EAXSOURCE_EXCLUSION:
4859         case EAXSOURCE_EXCLUSIONLFRATIO:
4860         case EAXSOURCE_OUTSIDEVOLUMEHF:
4861         case EAXSOURCE_DOPPLERFACTOR:
4862         case EAXSOURCE_ROLLOFFFACTOR:
4863         case EAXSOURCE_ROOMROLLOFFFACTOR:
4864         case EAXSOURCE_AIRABSORPTIONFACTOR:
4865         case EAXSOURCE_FLAGS:
4866             eax3_get(call, props.source);
4867             break;
4868
4869         case EAXSOURCE_SENDPARAMETERS:
4870             eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
4871             break;
4872
4873         case EAXSOURCE_ALLSENDPARAMETERS:
4874             eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
4875             break;
4876
4877         case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
4878             eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
4879             break;
4880
4881         case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
4882             eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
4883             break;
4884
4885         case EAXSOURCE_ACTIVEFXSLOTID:
4886             eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
4887             break;
4888
4889         case EAXSOURCE_MACROFXFACTOR:
4890             call.set_value<Exception>(props.source.flMacroFXFactor);
4891             break;
4892
4893         case EAXSOURCE_SPEAKERLEVELS:
4894             call.set_value<Exception>(props.speaker_levels);
4895             break;
4896
4897         case EAXSOURCE_ALL2DPARAMETERS:
4898             eax5_get_all_2d(call, props.source);
4899             break;
4900
4901         default:
4902             eax_fail_unknown_property_id();
4903     }
4904 }
4905
4906 void ALsource::eax_get(const EaxCall& call)
4907 {
4908     switch (call.get_version()) {
4909         case 1: eax1_get(call, mEax1.i); break;
4910         case 2: eax2_get(call, mEax2.i); break;
4911         case 3: eax3_get(call, mEax3.i); break;
4912         case 4: eax4_get(call, mEax4.i); break;
4913         case 5: eax5_get(call, mEax5.i); break;
4914         default: eax_fail_unknown_version();
4915     }
4916 }
4917
4918 void ALsource::eax_set_al_source_send(ALeffectslot *slot, size_t sendidx, const EaxAlLowPassParam &filter)
4919 {
4920     if(sendidx >= EAX_MAX_FXSLOTS)
4921         return;
4922
4923     auto &send = Send[sendidx];
4924     send.Gain = filter.gain;
4925     send.GainHF = filter.gain_hf;
4926     send.HFReference = LowPassFreqRef;
4927     send.GainLF = 1.0f;
4928     send.LFReference = HighPassFreqRef;
4929
4930     if(slot != nullptr)
4931         IncrementRef(slot->ref);
4932     if(auto *oldslot = send.Slot)
4933         DecrementRef(oldslot->ref);
4934
4935     send.Slot = slot;
4936     mPropsDirty = true;
4937 }
4938
4939 void ALsource::eax_commit_active_fx_slots()
4940 {
4941     // Clear all slots to an inactive state.
4942     mEaxActiveFxSlots.fill(false);
4943
4944     // Mark the set slots as active.
4945     for(const auto& slot_id : mEax.active_fx_slots.guidActiveFXSlots)
4946     {
4947         if(slot_id == EAX_NULL_GUID)
4948         {
4949         }
4950         else if(slot_id == EAX_PrimaryFXSlotID)
4951         {
4952             // Mark primary FX slot as active.
4953             if(mEaxPrimaryFxSlotId.has_value())
4954                 mEaxActiveFxSlots[*mEaxPrimaryFxSlotId] = true;
4955         }
4956         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot0)
4957             mEaxActiveFxSlots[0] = true;
4958         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot1)
4959             mEaxActiveFxSlots[1] = true;
4960         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot2)
4961             mEaxActiveFxSlots[2] = true;
4962         else if(slot_id == EAXPROPERTYID_EAX50_FXSlot3)
4963             mEaxActiveFxSlots[3] = true;
4964     }
4965
4966     // Deactivate EFX auxiliary effect slots for inactive slots. Active slots
4967     // will be updated with the room filters.
4968     for(size_t i{0};i < EAX_MAX_FXSLOTS;++i)
4969     {
4970         if(!mEaxActiveFxSlots[i])
4971             eax_set_al_source_send(nullptr, i, EaxAlLowPassParam{1.0f, 1.0f});
4972     }
4973 }
4974
4975 void ALsource::eax_commit_filters()
4976 {
4977     eax_update_direct_filter();
4978     eax_update_room_filters();
4979 }
4980
4981 void ALsource::eaxCommit()
4982 {
4983     const auto primary_fx_slot_id = mEaxAlContext->eaxGetPrimaryFxSlotIndex();
4984     const auto is_primary_fx_slot_id_changed = (mEaxPrimaryFxSlotId != primary_fx_slot_id);
4985
4986     if(!mEaxChanged && !is_primary_fx_slot_id_changed)
4987         return;
4988
4989     mEaxPrimaryFxSlotId = primary_fx_slot_id;
4990     mEaxChanged = false;
4991
4992     switch(mEaxVersion)
4993     {
4994     case 1:
4995         mEax1.i = mEax1.d;
4996         eax1_translate(mEax1.i, mEax);
4997         break;
4998     case 2:
4999         mEax2.i = mEax2.d;
5000         eax2_translate(mEax2.i, mEax);
5001         break;
5002     case 3:
5003         mEax3.i = mEax3.d;
5004         eax3_translate(mEax3.i, mEax);
5005         break;
5006     case 4:
5007         mEax4.i = mEax4.d;
5008         eax4_translate(mEax4.i, mEax);
5009         break;
5010     case 5:
5011         mEax5.i = mEax5.d;
5012         mEax = mEax5.d;
5013         break;
5014     }
5015
5016     eax_set_efx_outer_gain_hf();
5017     eax_set_efx_doppler_factor();
5018     eax_set_efx_rolloff_factor();
5019     eax_set_efx_room_rolloff_factor();
5020     eax_set_efx_air_absorption_factor();
5021     eax_set_efx_dry_gain_hf_auto();
5022     eax_set_efx_wet_gain_auto();
5023     eax_set_efx_wet_gain_hf_auto();
5024
5025     eax_commit_active_fx_slots();
5026     eax_commit_filters();
5027 }
5028
5029 #endif // ALSOFT_EAX