update openal-soft

sync point: master-ac5d40e40a0155351fe1be4aab30017b6a13a859

Engine/lib/openal-soft/al/auxeffectslot.h

@@ -0,0 +1,68 @@
+#ifndef AL_AUXEFFECTSLOT_H
+#define AL_AUXEFFECTSLOT_H
+
+#include <atomic>
+#include <cstddef>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/efx.h"
+
+#include "alcmain.h"
+#include "almalloc.h"
+#include "atomic.h"
+#include "effectslot.h"
+#include "effects/base.h"
+#include "intrusive_ptr.h"
+#include "vector.h"
+
+struct ALbuffer;
+struct ALeffect;
+struct WetBuffer;
+
+
+enum class SlotState : ALenum {
+    Initial = AL_INITIAL,
+    Playing = AL_PLAYING,
+    Stopped = AL_STOPPED,
+};
+
+struct ALeffectslot {
+    float Gain{1.0f};
+    bool  AuxSendAuto{true};
+    ALeffectslot *Target{nullptr};
+    ALbuffer *Buffer{nullptr};
+
+    struct {
+        EffectSlotType Type{EffectSlotType::None};
+        EffectProps Props{};
+
+        al::intrusive_ptr<EffectState> State;
+    } Effect;
+
+    std::atomic_flag PropsClean;
+
+    SlotState mState{SlotState::Initial};
+
+    RefCount ref{0u};
+
+    EffectSlot mSlot;
+
+    /* Self ID */
+    ALuint id{};
+
+    ALeffectslot();
+    ALeffectslot(const ALeffectslot&) = delete;
+    ALeffectslot& operator=(const ALeffectslot&) = delete;
+    ~ALeffectslot();
+
+    ALenum initEffect(ALeffect *effect, ALCcontext *context);
+    void updateProps(ALCcontext *context);
+
+    /* This can be new'd for the context's default effect slot. */
+    DEF_NEWDEL(ALeffectslot)
+};
+
+void UpdateAllEffectSlotProps(ALCcontext *context);
+
+#endif

Engine/lib/openal-soft/al/buffer.h

@@ -0,0 +1,70 @@
+#ifndef AL_BUFFER_H
+#define AL_BUFFER_H
+
+#include <atomic>
+
+#include "AL/al.h"
+
+#include "albyte.h"
+#include "almalloc.h"
+#include "atomic.h"
+#include "buffer_storage.h"
+#include "inprogext.h"
+#include "vector.h"
+
+
+/* User formats */
+enum UserFmtType : unsigned char {
+    UserFmtUByte = FmtUByte,
+    UserFmtShort = FmtShort,
+    UserFmtFloat = FmtFloat,
+    UserFmtMulaw = FmtMulaw,
+    UserFmtAlaw = FmtAlaw,
+    UserFmtDouble = FmtDouble,
+
+    UserFmtIMA4 = 128,
+    UserFmtMSADPCM,
+};
+enum UserFmtChannels : unsigned char {
+    UserFmtMono = FmtMono,
+    UserFmtStereo = FmtStereo,
+    UserFmtRear = FmtRear,
+    UserFmtQuad = FmtQuad,
+    UserFmtX51 = FmtX51,
+    UserFmtX61 = FmtX61,
+    UserFmtX71 = FmtX71,
+    UserFmtBFormat2D = FmtBFormat2D,
+    UserFmtBFormat3D = FmtBFormat3D,
+};
+
+
+struct ALbuffer : public BufferStorage {
+    ALbitfieldSOFT Access{0u};
+
+    al::vector<al::byte,16> mData;
+
+    UserFmtType OriginalType{UserFmtShort};
+    ALuint OriginalSize{0};
+    ALuint OriginalAlign{0};
+
+    ALuint UnpackAlign{0};
+    ALuint PackAlign{0};
+    ALuint UnpackAmbiOrder{1};
+
+    ALbitfieldSOFT MappedAccess{0u};
+    ALsizei MappedOffset{0};
+    ALsizei MappedSize{0};
+
+    ALuint mLoopStart{0u};
+    ALuint mLoopEnd{0u};
+
+    /* Number of times buffer was attached to a source (deletion can only occur when 0) */
+    RefCount ref{0u};
+
+    /* Self ID */
+    ALuint id{0};
+
+    DISABLE_ALLOC()
+};
+
+#endif

Engine/lib/openal-soft/al/effect.cpp

@@ -0,0 +1,746 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "effect.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <numeric>
+#include <utility>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+#include "AL/efx-presets.h"
+#include "AL/efx.h"
+
+#include "albit.h"
+#include "alcmain.h"
+#include "alcontext.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alstring.h"
+#include "core/except.h"
+#include "core/logging.h"
+#include "effects/base.h"
+#include "opthelpers.h"
+#include "vector.h"
+
+
+const EffectList gEffectList[16]{
+    { "eaxreverb",   EAXREVERB_EFFECT,   AL_EFFECT_EAXREVERB },
+    { "reverb",      REVERB_EFFECT,      AL_EFFECT_REVERB },
+    { "autowah",     AUTOWAH_EFFECT,     AL_EFFECT_AUTOWAH },
+    { "chorus",      CHORUS_EFFECT,      AL_EFFECT_CHORUS },
+    { "compressor",  COMPRESSOR_EFFECT,  AL_EFFECT_COMPRESSOR },
+    { "distortion",  DISTORTION_EFFECT,  AL_EFFECT_DISTORTION },
+    { "echo",        ECHO_EFFECT,        AL_EFFECT_ECHO },
+    { "equalizer",   EQUALIZER_EFFECT,   AL_EFFECT_EQUALIZER },
+    { "flanger",     FLANGER_EFFECT,     AL_EFFECT_FLANGER },
+    { "fshifter",    FSHIFTER_EFFECT,    AL_EFFECT_FREQUENCY_SHIFTER },
+    { "modulator",   MODULATOR_EFFECT,   AL_EFFECT_RING_MODULATOR },
+    { "pshifter",    PSHIFTER_EFFECT,    AL_EFFECT_PITCH_SHIFTER },
+    { "vmorpher",    VMORPHER_EFFECT,    AL_EFFECT_VOCAL_MORPHER },
+    { "dedicated",   DEDICATED_EFFECT,   AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT },
+    { "dedicated",   DEDICATED_EFFECT,   AL_EFFECT_DEDICATED_DIALOGUE },
+    { "convolution", CONVOLUTION_EFFECT, AL_EFFECT_CONVOLUTION_REVERB_SOFT },
+};
+
+bool DisabledEffects[MAX_EFFECTS];
+
+
+effect_exception::effect_exception(ALenum code, const char *msg, ...) : mErrorCode{code}
+{
+    std::va_list args;
+    va_start(args, msg);
+    setMessage(msg, args);
+    va_end(args);
+}
+
+namespace {
+
+struct EffectPropsItem {
+    ALenum Type;
+    const EffectProps &DefaultProps;
+    const EffectVtable &Vtable;
+};
+constexpr EffectPropsItem EffectPropsList[] = {
+    { AL_EFFECT_NULL, NullEffectProps, NullEffectVtable },
+    { AL_EFFECT_EAXREVERB, ReverbEffectProps, ReverbEffectVtable },
+    { AL_EFFECT_REVERB, StdReverbEffectProps, StdReverbEffectVtable },
+    { AL_EFFECT_AUTOWAH, AutowahEffectProps, AutowahEffectVtable },
+    { AL_EFFECT_CHORUS, ChorusEffectProps, ChorusEffectVtable },
+    { AL_EFFECT_COMPRESSOR, CompressorEffectProps, CompressorEffectVtable },
+    { AL_EFFECT_DISTORTION, DistortionEffectProps, DistortionEffectVtable },
+    { AL_EFFECT_ECHO, EchoEffectProps, EchoEffectVtable },
+    { AL_EFFECT_EQUALIZER, EqualizerEffectProps, EqualizerEffectVtable },
+    { AL_EFFECT_FLANGER, FlangerEffectProps, FlangerEffectVtable },
+    { AL_EFFECT_FREQUENCY_SHIFTER, FshifterEffectProps, FshifterEffectVtable },
+    { AL_EFFECT_RING_MODULATOR, ModulatorEffectProps, ModulatorEffectVtable },
+    { AL_EFFECT_PITCH_SHIFTER, PshifterEffectProps, PshifterEffectVtable },
+    { AL_EFFECT_VOCAL_MORPHER, VmorpherEffectProps, VmorpherEffectVtable },
+    { AL_EFFECT_DEDICATED_DIALOGUE, DedicatedEffectProps, DedicatedEffectVtable },
+    { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedEffectProps, DedicatedEffectVtable },
+    { AL_EFFECT_CONVOLUTION_REVERB_SOFT, ConvolutionEffectProps, ConvolutionEffectVtable },
+};
+
+
+void ALeffect_setParami(ALeffect *effect, ALenum param, int value)
+{ effect->vtab->setParami(&effect->Props, param, value); }
+void ALeffect_setParamiv(ALeffect *effect, ALenum param, const int *values)
+{ effect->vtab->setParamiv(&effect->Props, param, values); }
+void ALeffect_setParamf(ALeffect *effect, ALenum param, float value)
+{ effect->vtab->setParamf(&effect->Props, param, value); }
+void ALeffect_setParamfv(ALeffect *effect, ALenum param, const float *values)
+{ effect->vtab->setParamfv(&effect->Props, param, values); }
+
+void ALeffect_getParami(const ALeffect *effect, ALenum param, int *value)
+{ effect->vtab->getParami(&effect->Props, param, value); }
+void ALeffect_getParamiv(const ALeffect *effect, ALenum param, int *values)
+{ effect->vtab->getParamiv(&effect->Props, param, values); }
+void ALeffect_getParamf(const ALeffect *effect, ALenum param, float *value)
+{ effect->vtab->getParamf(&effect->Props, param, value); }
+void ALeffect_getParamfv(const ALeffect *effect, ALenum param, float *values)
+{ effect->vtab->getParamfv(&effect->Props, param, values); }
+
+
+const EffectPropsItem *getEffectPropsItemByType(ALenum type)
+{
+    auto iter = std::find_if(std::begin(EffectPropsList), std::end(EffectPropsList),
+        [type](const EffectPropsItem &item) noexcept -> bool
+        { return item.Type == type; });
+    return (iter != std::end(EffectPropsList)) ? std::addressof(*iter) : nullptr;
+}
+
+void InitEffectParams(ALeffect *effect, ALenum type)
+{
+    const EffectPropsItem *item{getEffectPropsItemByType(type)};
+    if(item)
+    {
+        effect->Props = item->DefaultProps;
+        effect->vtab = &item->Vtable;
+    }
+    else
+    {
+        effect->Props = EffectProps{};
+        effect->vtab = &NullEffectVtable;
+    }
+    effect->type = type;
+}
+
+bool EnsureEffects(ALCdevice *device, size_t needed)
+{
+    size_t count{std::accumulate(device->EffectList.cbegin(), device->EffectList.cend(), size_t{0},
+        [](size_t cur, const EffectSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
+
+    while(needed > count)
+    {
+        if UNLIKELY(device->EffectList.size() >= 1<<25)
+            return false;
+
+        device->EffectList.emplace_back();
+        auto sublist = device->EffectList.end() - 1;
+        sublist->FreeMask = ~0_u64;
+        sublist->Effects = static_cast<ALeffect*>(al_calloc(alignof(ALeffect), sizeof(ALeffect)*64));
+        if UNLIKELY(!sublist->Effects)
+        {
+            device->EffectList.pop_back();
+            return false;
+        }
+        count += 64;
+    }
+    return true;
+}
+
+ALeffect *AllocEffect(ALCdevice *device)
+{
+    auto sublist = std::find_if(device->EffectList.begin(), device->EffectList.end(),
+        [](const EffectSubList &entry) noexcept -> bool
+        { return entry.FreeMask != 0; }
+    );
+    auto lidx = static_cast<ALuint>(std::distance(device->EffectList.begin(), sublist));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+
+    ALeffect *effect{::new (sublist->Effects + slidx) ALeffect{}};
+    InitEffectParams(effect, AL_EFFECT_NULL);
+
+    /* Add 1 to avoid effect ID 0. */
+    effect->id = ((lidx<<6) | slidx) + 1;
+
+    sublist->FreeMask &= ~(1_u64 << slidx);
+
+    return effect;
+}
+
+void FreeEffect(ALCdevice *device, ALeffect *effect)
+{
+    const ALuint id{effect->id - 1};
+    const size_t lidx{id >> 6};
+    const ALuint slidx{id & 0x3f};
+
+    al::destroy_at(effect);
+
+    device->EffectList[lidx].FreeMask |= 1_u64 << slidx;
+}
+
+inline ALeffect *LookupEffect(ALCdevice *device, ALuint id)
+{
+    const size_t lidx{(id-1) >> 6};
+    const ALuint slidx{(id-1) & 0x3f};
+
+    if UNLIKELY(lidx >= device->EffectList.size())
+        return nullptr;
+    EffectSubList &sublist = device->EffectList[lidx];
+    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+        return nullptr;
+    return sublist.Effects + slidx;
+}
+
+} // namespace
+
+AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if UNLIKELY(n < 0)
+        context->setError(AL_INVALID_VALUE, "Generating %d effects", n);
+    if UNLIKELY(n <= 0) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+    if(!EnsureEffects(device, static_cast<ALuint>(n)))
+    {
+        context->setError(AL_OUT_OF_MEMORY, "Failed to allocate %d effect%s", n, (n==1)?"":"s");
+        return;
+    }
+
+    if LIKELY(n == 1)
+    {
+        /* Special handling for the easy and normal case. */
+        ALeffect *effect{AllocEffect(device)};
+        effects[0] = effect->id;
+    }
+    else
+    {
+        /* Store the allocated buffer IDs in a separate local list, to avoid
+         * modifying the user storage in case of failure.
+         */
+        al::vector<ALuint> ids;
+        ids.reserve(static_cast<ALuint>(n));
+        do {
+            ALeffect *effect{AllocEffect(device)};
+            ids.emplace_back(effect->id);
+        } while(--n);
+        std::copy(ids.cbegin(), ids.cend(), effects);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if UNLIKELY(n < 0)
+        context->setError(AL_INVALID_VALUE, "Deleting %d effects", n);
+    if UNLIKELY(n <= 0) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    /* First try to find any effects that are invalid. */
+    auto validate_effect = [device](const ALuint eid) -> bool
+    { return !eid || LookupEffect(device, eid) != nullptr; };
+
+    const ALuint *effects_end = effects + n;
+    auto inveffect = std::find_if_not(effects, effects_end, validate_effect);
+    if UNLIKELY(inveffect != effects_end)
+    {
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", *inveffect);
+        return;
+    }
+
+    /* All good. Delete non-0 effect IDs. */
+    auto delete_effect = [device](ALuint eid) -> void
+    {
+        ALeffect *effect{eid ? LookupEffect(device, eid) : nullptr};
+        if(effect) FreeEffect(device, effect);
+    };
+    std::for_each(effects, effects_end, delete_effect);
+}
+END_API_FUNC
+
+AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if LIKELY(context)
+    {
+        ALCdevice *device{context->mDevice.get()};
+        std::lock_guard<std::mutex> _{device->EffectLock};
+        if(!effect || LookupEffect(device, effect))
+            return AL_TRUE;
+    }
+    return AL_FALSE;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else if(param == AL_EFFECT_TYPE)
+    {
+        bool isOk{value == AL_EFFECT_NULL};
+        if(!isOk)
+        {
+            for(const EffectList &effectitem : gEffectList)
+            {
+                if(value == effectitem.val && !DisabledEffects[effectitem.type])
+                {
+                    isOk = true;
+                    break;
+                }
+            }
+        }
+
+        if(isOk)
+            InitEffectParams(aleffect, value);
+        else
+            context->setError(AL_INVALID_VALUE, "Effect type 0x%04x not supported", value);
+    }
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_setParami(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_EFFECT_TYPE:
+        alEffecti(effect, param, values[0]);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_setParamiv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_setParamf(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *values)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_setParamfv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    const ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else if(param == AL_EFFECT_TYPE)
+        *value = aleffect->type;
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_getParami(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_EFFECT_TYPE:
+        alGetEffecti(effect, param, values);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    const ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_getParamiv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    const ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_getParamf(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *values)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+
+    const ALeffect *aleffect{LookupEffect(device, effect)};
+    if UNLIKELY(!aleffect)
+        context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
+    else try
+    {
+        /* Call the appropriate handler */
+        ALeffect_getParamfv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+
+void InitEffect(ALeffect *effect)
+{
+    InitEffectParams(effect, AL_EFFECT_NULL);
+}
+
+EffectSubList::~EffectSubList()
+{
+    uint64_t usemask{~FreeMask};
+    while(usemask)
+    {
+        const int idx{al::countr_zero(usemask)};
+        al::destroy_at(Effects+idx);
+        usemask &= ~(1_u64 << idx);
+    }
+    FreeMask = ~usemask;
+    al_free(Effects);
+    Effects = nullptr;
+}
+
+
+#define DECL(x) { #x, EFX_REVERB_PRESET_##x }
+static const struct {
+    const char name[32];
+    EFXEAXREVERBPROPERTIES props;
+} reverblist[] = {
+    DECL(GENERIC),
+    DECL(PADDEDCELL),
+    DECL(ROOM),
+    DECL(BATHROOM),
+    DECL(LIVINGROOM),
+    DECL(STONEROOM),
+    DECL(AUDITORIUM),
+    DECL(CONCERTHALL),
+    DECL(CAVE),
+    DECL(ARENA),
+    DECL(HANGAR),
+    DECL(CARPETEDHALLWAY),
+    DECL(HALLWAY),
+    DECL(STONECORRIDOR),
+    DECL(ALLEY),
+    DECL(FOREST),
+    DECL(CITY),
+    DECL(MOUNTAINS),
+    DECL(QUARRY),
+    DECL(PLAIN),
+    DECL(PARKINGLOT),
+    DECL(SEWERPIPE),
+    DECL(UNDERWATER),
+    DECL(DRUGGED),
+    DECL(DIZZY),
+    DECL(PSYCHOTIC),
+
+    DECL(CASTLE_SMALLROOM),
+    DECL(CASTLE_SHORTPASSAGE),
+    DECL(CASTLE_MEDIUMROOM),
+    DECL(CASTLE_LARGEROOM),
+    DECL(CASTLE_LONGPASSAGE),
+    DECL(CASTLE_HALL),
+    DECL(CASTLE_CUPBOARD),
+    DECL(CASTLE_COURTYARD),
+    DECL(CASTLE_ALCOVE),
+
+    DECL(FACTORY_SMALLROOM),
+    DECL(FACTORY_SHORTPASSAGE),
+    DECL(FACTORY_MEDIUMROOM),
+    DECL(FACTORY_LARGEROOM),
+    DECL(FACTORY_LONGPASSAGE),
+    DECL(FACTORY_HALL),
+    DECL(FACTORY_CUPBOARD),
+    DECL(FACTORY_COURTYARD),
+    DECL(FACTORY_ALCOVE),
+
+    DECL(ICEPALACE_SMALLROOM),
+    DECL(ICEPALACE_SHORTPASSAGE),
+    DECL(ICEPALACE_MEDIUMROOM),
+    DECL(ICEPALACE_LARGEROOM),
+    DECL(ICEPALACE_LONGPASSAGE),
+    DECL(ICEPALACE_HALL),
+    DECL(ICEPALACE_CUPBOARD),
+    DECL(ICEPALACE_COURTYARD),
+    DECL(ICEPALACE_ALCOVE),
+
+    DECL(SPACESTATION_SMALLROOM),
+    DECL(SPACESTATION_SHORTPASSAGE),
+    DECL(SPACESTATION_MEDIUMROOM),
+    DECL(SPACESTATION_LARGEROOM),
+    DECL(SPACESTATION_LONGPASSAGE),
+    DECL(SPACESTATION_HALL),
+    DECL(SPACESTATION_CUPBOARD),
+    DECL(SPACESTATION_ALCOVE),
+
+    DECL(WOODEN_SMALLROOM),
+    DECL(WOODEN_SHORTPASSAGE),
+    DECL(WOODEN_MEDIUMROOM),
+    DECL(WOODEN_LARGEROOM),
+    DECL(WOODEN_LONGPASSAGE),
+    DECL(WOODEN_HALL),
+    DECL(WOODEN_CUPBOARD),
+    DECL(WOODEN_COURTYARD),
+    DECL(WOODEN_ALCOVE),
+
+    DECL(SPORT_EMPTYSTADIUM),
+    DECL(SPORT_SQUASHCOURT),
+    DECL(SPORT_SMALLSWIMMINGPOOL),
+    DECL(SPORT_LARGESWIMMINGPOOL),
+    DECL(SPORT_GYMNASIUM),
+    DECL(SPORT_FULLSTADIUM),
+    DECL(SPORT_STADIUMTANNOY),
+
+    DECL(PREFAB_WORKSHOP),
+    DECL(PREFAB_SCHOOLROOM),
+    DECL(PREFAB_PRACTISEROOM),
+    DECL(PREFAB_OUTHOUSE),
+    DECL(PREFAB_CARAVAN),
+
+    DECL(DOME_TOMB),
+    DECL(PIPE_SMALL),
+    DECL(DOME_SAINTPAULS),
+    DECL(PIPE_LONGTHIN),
+    DECL(PIPE_LARGE),
+    DECL(PIPE_RESONANT),
+
+    DECL(OUTDOORS_BACKYARD),
+    DECL(OUTDOORS_ROLLINGPLAINS),
+    DECL(OUTDOORS_DEEPCANYON),
+    DECL(OUTDOORS_CREEK),
+    DECL(OUTDOORS_VALLEY),
+
+    DECL(MOOD_HEAVEN),
+    DECL(MOOD_HELL),
+    DECL(MOOD_MEMORY),
+
+    DECL(DRIVING_COMMENTATOR),
+    DECL(DRIVING_PITGARAGE),
+    DECL(DRIVING_INCAR_RACER),
+    DECL(DRIVING_INCAR_SPORTS),
+    DECL(DRIVING_INCAR_LUXURY),
+    DECL(DRIVING_FULLGRANDSTAND),
+    DECL(DRIVING_EMPTYGRANDSTAND),
+    DECL(DRIVING_TUNNEL),
+
+    DECL(CITY_STREETS),
+    DECL(CITY_SUBWAY),
+    DECL(CITY_MUSEUM),
+    DECL(CITY_LIBRARY),
+    DECL(CITY_UNDERPASS),
+    DECL(CITY_ABANDONED),
+
+    DECL(DUSTYROOM),
+    DECL(CHAPEL),
+    DECL(SMALLWATERROOM),
+};
+#undef DECL
+
+void LoadReverbPreset(const char *name, ALeffect *effect)
+{
+    if(al::strcasecmp(name, "NONE") == 0)
+    {
+        InitEffectParams(effect, AL_EFFECT_NULL);
+        TRACE("Loading reverb '%s'\n", "NONE");
+        return;
+    }
+
+    if(!DisabledEffects[EAXREVERB_EFFECT])
+        InitEffectParams(effect, AL_EFFECT_EAXREVERB);
+    else if(!DisabledEffects[REVERB_EFFECT])
+        InitEffectParams(effect, AL_EFFECT_REVERB);
+    else
+        InitEffectParams(effect, AL_EFFECT_NULL);
+    for(const auto &reverbitem : reverblist)
+    {
+        const EFXEAXREVERBPROPERTIES *props;
+
+        if(al::strcasecmp(name, reverbitem.name) != 0)
+            continue;
+
+        TRACE("Loading reverb '%s'\n", reverbitem.name);
+        props = &reverbitem.props;
+        effect->Props.Reverb.Density   = props->flDensity;
+        effect->Props.Reverb.Diffusion = props->flDiffusion;
+        effect->Props.Reverb.Gain   = props->flGain;
+        effect->Props.Reverb.GainHF = props->flGainHF;
+        effect->Props.Reverb.GainLF = props->flGainLF;
+        effect->Props.Reverb.DecayTime    = props->flDecayTime;
+        effect->Props.Reverb.DecayHFRatio = props->flDecayHFRatio;
+        effect->Props.Reverb.DecayLFRatio = props->flDecayLFRatio;
+        effect->Props.Reverb.ReflectionsGain   = props->flReflectionsGain;
+        effect->Props.Reverb.ReflectionsDelay  = props->flReflectionsDelay;
+        effect->Props.Reverb.ReflectionsPan[0] = props->flReflectionsPan[0];
+        effect->Props.Reverb.ReflectionsPan[1] = props->flReflectionsPan[1];
+        effect->Props.Reverb.ReflectionsPan[2] = props->flReflectionsPan[2];
+        effect->Props.Reverb.LateReverbGain   = props->flLateReverbGain;
+        effect->Props.Reverb.LateReverbDelay  = props->flLateReverbDelay;
+        effect->Props.Reverb.LateReverbPan[0] = props->flLateReverbPan[0];
+        effect->Props.Reverb.LateReverbPan[1] = props->flLateReverbPan[1];
+        effect->Props.Reverb.LateReverbPan[2] = props->flLateReverbPan[2];
+        effect->Props.Reverb.EchoTime  = props->flEchoTime;
+        effect->Props.Reverb.EchoDepth = props->flEchoDepth;
+        effect->Props.Reverb.ModulationTime  = props->flModulationTime;
+        effect->Props.Reverb.ModulationDepth = props->flModulationDepth;
+        effect->Props.Reverb.AirAbsorptionGainHF = props->flAirAbsorptionGainHF;
+        effect->Props.Reverb.HFReference = props->flHFReference;
+        effect->Props.Reverb.LFReference = props->flLFReference;
+        effect->Props.Reverb.RoomRolloffFactor = props->flRoomRolloffFactor;
+        effect->Props.Reverb.DecayHFLimit = props->iDecayHFLimit ? AL_TRUE : AL_FALSE;
+        return;
+    }
+
+    WARN("Reverb preset '%s' not found\n", name);
+}

Engine/lib/openal-soft/al/effect.h

@@ -0,0 +1,60 @@
+#ifndef AL_EFFECT_H
+#define AL_EFFECT_H
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "al/effects/effects.h"
+#include "alc/effects/base.h"
+
+
+enum {
+    EAXREVERB_EFFECT = 0,
+    REVERB_EFFECT,
+    AUTOWAH_EFFECT,
+    CHORUS_EFFECT,
+    COMPRESSOR_EFFECT,
+    DISTORTION_EFFECT,
+    ECHO_EFFECT,
+    EQUALIZER_EFFECT,
+    FLANGER_EFFECT,
+    FSHIFTER_EFFECT,
+    MODULATOR_EFFECT,
+    PSHIFTER_EFFECT,
+    VMORPHER_EFFECT,
+    DEDICATED_EFFECT,
+    CONVOLUTION_EFFECT,
+
+    MAX_EFFECTS
+};
+extern bool DisabledEffects[MAX_EFFECTS];
+
+extern float ReverbBoost;
+
+struct EffectList {
+    const char name[16];
+    int type;
+    ALenum val;
+};
+extern const EffectList gEffectList[16];
+
+
+struct ALeffect {
+    // Effect type (AL_EFFECT_NULL, ...)
+    ALenum type{AL_EFFECT_NULL};
+
+    EffectProps Props{};
+
+    const EffectVtable *vtab{nullptr};
+
+    /* Self ID */
+    ALuint id{0u};
+
+    DISABLE_ALLOC()
+};
+
+void InitEffect(ALeffect *effect);
+
+void LoadReverbPreset(const char *name, ALeffect *effect);
+
+#endif

Engine/lib/openal-soft/al/effects/autowah.cpp

@@ -0,0 +1,109 @@
+
+#include "config.h"
+
+#include <cmath>
+#include <cstdlib>
+
+#include <algorithm>
+
+#include "AL/efx.h"
+
+#include "effects/base.h"
+#include "effects.h"
+
+namespace {
+
+void Autowah_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_AUTOWAH_ATTACK_TIME:
+        if(!(val >= AL_AUTOWAH_MIN_ATTACK_TIME && val <= AL_AUTOWAH_MAX_ATTACK_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "Autowah attack time out of range"};
+        props->Autowah.AttackTime = val;
+        break;
+
+    case AL_AUTOWAH_RELEASE_TIME:
+        if(!(val >= AL_AUTOWAH_MIN_RELEASE_TIME && val <= AL_AUTOWAH_MAX_RELEASE_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "Autowah release time out of range"};
+        props->Autowah.ReleaseTime = val;
+        break;
+
+    case AL_AUTOWAH_RESONANCE:
+        if(!(val >= AL_AUTOWAH_MIN_RESONANCE && val <= AL_AUTOWAH_MAX_RESONANCE))
+            throw effect_exception{AL_INVALID_VALUE, "Autowah resonance out of range"};
+        props->Autowah.Resonance = val;
+        break;
+
+    case AL_AUTOWAH_PEAK_GAIN:
+        if(!(val >= AL_AUTOWAH_MIN_PEAK_GAIN && val <= AL_AUTOWAH_MAX_PEAK_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Autowah peak gain out of range"};
+        props->Autowah.PeakGain = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param};
+    }
+}
+void Autowah_setParamfv(EffectProps *props,  ALenum param, const float *vals)
+{ Autowah_setParamf(props, param, vals[0]); }
+
+void Autowah_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param}; }
+void Autowah_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x",
+        param};
+}
+
+void Autowah_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_AUTOWAH_ATTACK_TIME:
+        *val = props->Autowah.AttackTime;
+        break;
+
+    case AL_AUTOWAH_RELEASE_TIME:
+        *val = props->Autowah.ReleaseTime;
+        break;
+
+    case AL_AUTOWAH_RESONANCE:
+        *val = props->Autowah.Resonance;
+        break;
+
+    case AL_AUTOWAH_PEAK_GAIN:
+        *val = props->Autowah.PeakGain;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param};
+    }
+
+}
+void Autowah_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Autowah_getParamf(props, param, vals); }
+
+void Autowah_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param}; }
+void Autowah_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x",
+        param};
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Autowah.AttackTime = AL_AUTOWAH_DEFAULT_ATTACK_TIME;
+    props.Autowah.ReleaseTime = AL_AUTOWAH_DEFAULT_RELEASE_TIME;
+    props.Autowah.Resonance = AL_AUTOWAH_DEFAULT_RESONANCE;
+    props.Autowah.PeakGain = AL_AUTOWAH_DEFAULT_PEAK_GAIN;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Autowah);
+
+const EffectProps AutowahEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/chorus.cpp

@@ -0,0 +1,276 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "aloptional.h"
+#include "core/logging.h"
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+static_assert(AL_CHORUS_WAVEFORM_SINUSOID == AL_FLANGER_WAVEFORM_SINUSOID, "Chorus/Flanger waveform value mismatch");
+static_assert(AL_CHORUS_WAVEFORM_TRIANGLE == AL_FLANGER_WAVEFORM_TRIANGLE, "Chorus/Flanger waveform value mismatch");
+
+inline al::optional<ChorusWaveform> WaveformFromEnum(ALenum type)
+{
+    switch(type)
+    {
+    case AL_CHORUS_WAVEFORM_SINUSOID: return al::make_optional(ChorusWaveform::Sinusoid);
+    case AL_CHORUS_WAVEFORM_TRIANGLE: return al::make_optional(ChorusWaveform::Triangle);
+    }
+    return al::nullopt;
+}
+inline ALenum EnumFromWaveform(ChorusWaveform type)
+{
+    switch(type)
+    {
+    case ChorusWaveform::Sinusoid: return AL_CHORUS_WAVEFORM_SINUSOID;
+    case ChorusWaveform::Triangle: return AL_CHORUS_WAVEFORM_TRIANGLE;
+    }
+    throw std::runtime_error{"Invalid chorus waveform: "+std::to_string(static_cast<int>(type))};
+}
+
+void Chorus_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_CHORUS_WAVEFORM:
+        if(auto formopt = WaveformFromEnum(val))
+            props->Chorus.Waveform = *formopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Invalid chorus waveform: 0x%04x", val};
+        break;
+
+    case AL_CHORUS_PHASE:
+        if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
+            throw effect_exception{AL_INVALID_VALUE, "Chorus phase out of range: %d", val};
+        props->Chorus.Phase = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param};
+    }
+}
+void Chorus_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Chorus_setParami(props, param, vals[0]); }
+void Chorus_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_CHORUS_RATE:
+        if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
+            throw effect_exception{AL_INVALID_VALUE, "Chorus rate out of range: %f", val};
+        props->Chorus.Rate = val;
+        break;
+
+    case AL_CHORUS_DEPTH:
+        if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
+            throw effect_exception{AL_INVALID_VALUE, "Chorus depth out of range: %f", val};
+        props->Chorus.Depth = val;
+        break;
+
+    case AL_CHORUS_FEEDBACK:
+        if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
+            throw effect_exception{AL_INVALID_VALUE, "Chorus feedback out of range: %f", val};
+        props->Chorus.Feedback = val;
+        break;
+
+    case AL_CHORUS_DELAY:
+        if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Chorus delay out of range: %f", val};
+        props->Chorus.Delay = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param};
+    }
+}
+void Chorus_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Chorus_setParamf(props, param, vals[0]); }
+
+void Chorus_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_CHORUS_WAVEFORM:
+        *val = EnumFromWaveform(props->Chorus.Waveform);
+        break;
+
+    case AL_CHORUS_PHASE:
+        *val = props->Chorus.Phase;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param};
+    }
+}
+void Chorus_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Chorus_getParami(props, param, vals); }
+void Chorus_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_CHORUS_RATE:
+        *val = props->Chorus.Rate;
+        break;
+
+    case AL_CHORUS_DEPTH:
+        *val = props->Chorus.Depth;
+        break;
+
+    case AL_CHORUS_FEEDBACK:
+        *val = props->Chorus.Feedback;
+        break;
+
+    case AL_CHORUS_DELAY:
+        *val = props->Chorus.Delay;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param};
+    }
+}
+void Chorus_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Chorus_getParamf(props, param, vals); }
+
+const EffectProps genDefaultChorusProps() noexcept
+{
+    EffectProps props{};
+    props.Chorus.Waveform = *WaveformFromEnum(AL_CHORUS_DEFAULT_WAVEFORM);
+    props.Chorus.Phase = AL_CHORUS_DEFAULT_PHASE;
+    props.Chorus.Rate = AL_CHORUS_DEFAULT_RATE;
+    props.Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH;
+    props.Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK;
+    props.Chorus.Delay = AL_CHORUS_DEFAULT_DELAY;
+    return props;
+}
+
+
+void Flanger_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_FLANGER_WAVEFORM:
+        if(auto formopt = WaveformFromEnum(val))
+            props->Chorus.Waveform = *formopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Invalid flanger waveform: 0x%04x", val};
+        break;
+
+    case AL_FLANGER_PHASE:
+        if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE))
+            throw effect_exception{AL_INVALID_VALUE, "Flanger phase out of range: %d", val};
+        props->Chorus.Phase = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param};
+    }
+}
+void Flanger_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Flanger_setParami(props, param, vals[0]); }
+void Flanger_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_FLANGER_RATE:
+        if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE))
+            throw effect_exception{AL_INVALID_VALUE, "Flanger rate out of range: %f", val};
+        props->Chorus.Rate = val;
+        break;
+
+    case AL_FLANGER_DEPTH:
+        if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH))
+            throw effect_exception{AL_INVALID_VALUE, "Flanger depth out of range: %f", val};
+        props->Chorus.Depth = val;
+        break;
+
+    case AL_FLANGER_FEEDBACK:
+        if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK))
+            throw effect_exception{AL_INVALID_VALUE, "Flanger feedback out of range: %f", val};
+        props->Chorus.Feedback = val;
+        break;
+
+    case AL_FLANGER_DELAY:
+        if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Flanger delay out of range: %f", val};
+        props->Chorus.Delay = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param};
+    }
+}
+void Flanger_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Flanger_setParamf(props, param, vals[0]); }
+
+void Flanger_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_FLANGER_WAVEFORM:
+        *val = EnumFromWaveform(props->Chorus.Waveform);
+        break;
+
+    case AL_FLANGER_PHASE:
+        *val = props->Chorus.Phase;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param};
+    }
+}
+void Flanger_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Flanger_getParami(props, param, vals); }
+void Flanger_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_FLANGER_RATE:
+        *val = props->Chorus.Rate;
+        break;
+
+    case AL_FLANGER_DEPTH:
+        *val = props->Chorus.Depth;
+        break;
+
+    case AL_FLANGER_FEEDBACK:
+        *val = props->Chorus.Feedback;
+        break;
+
+    case AL_FLANGER_DELAY:
+        *val = props->Chorus.Delay;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param};
+    }
+}
+void Flanger_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Flanger_getParamf(props, param, vals); }
+
+EffectProps genDefaultFlangerProps() noexcept
+{
+    EffectProps props{};
+    props.Chorus.Waveform = *WaveformFromEnum(AL_FLANGER_DEFAULT_WAVEFORM);
+    props.Chorus.Phase = AL_FLANGER_DEFAULT_PHASE;
+    props.Chorus.Rate = AL_FLANGER_DEFAULT_RATE;
+    props.Chorus.Depth = AL_FLANGER_DEFAULT_DEPTH;
+    props.Chorus.Feedback = AL_FLANGER_DEFAULT_FEEDBACK;
+    props.Chorus.Delay = AL_FLANGER_DEFAULT_DELAY;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Chorus);
+
+const EffectProps ChorusEffectProps{genDefaultChorusProps()};
+
+DEFINE_ALEFFECT_VTABLE(Flanger);
+
+const EffectProps FlangerEffectProps{genDefaultFlangerProps()};

Engine/lib/openal-soft/al/effects/compressor.cpp

@@ -0,0 +1,72 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Compressor_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_COMPRESSOR_ONOFF:
+        if(!(val >= AL_COMPRESSOR_MIN_ONOFF && val <= AL_COMPRESSOR_MAX_ONOFF))
+            throw effect_exception{AL_INVALID_VALUE, "Compressor state out of range"};
+        props->Compressor.OnOff = (val != AL_FALSE);
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
+            param};
+    }
+}
+void Compressor_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Compressor_setParami(props, param, vals[0]); }
+void Compressor_setParamf(EffectProps*, ALenum param, float)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param}; }
+void Compressor_setParamfv(EffectProps*, ALenum param, const float*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x",
+        param};
+}
+
+void Compressor_getParami(const EffectProps *props, ALenum param, int *val)
+{ 
+    switch(param)
+    {
+    case AL_COMPRESSOR_ONOFF:
+        *val = props->Compressor.OnOff;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
+            param};
+    }
+}
+void Compressor_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Compressor_getParami(props, param, vals); }
+void Compressor_getParamf(const EffectProps*, ALenum param, float*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param}; }
+void Compressor_getParamfv(const EffectProps*, ALenum param, float*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x",
+        param};
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Compressor.OnOff = AL_COMPRESSOR_DEFAULT_ONOFF;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Compressor);
+
+const EffectProps CompressorEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/convolution.cpp

@@ -0,0 +1,93 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "inprogext.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Convolution_setParami(EffectProps* /*props*/, ALenum param, int /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x",
+            param};
+    }
+}
+void Convolution_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{
+    switch(param)
+    {
+    default:
+        Convolution_setParami(props, param, vals[0]);
+    }
+}
+void Convolution_setParamf(EffectProps* /*props*/, ALenum param, float /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect float property 0x%04x",
+            param};
+    }
+}
+void Convolution_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{
+    switch(param)
+    {
+    default:
+        Convolution_setParamf(props, param, vals[0]);
+    }
+}
+
+void Convolution_getParami(const EffectProps* /*props*/, ALenum param, int* /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x",
+            param};
+    }
+}
+void Convolution_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{
+    switch(param)
+    {
+    default:
+        Convolution_getParami(props, param, vals);
+    }
+}
+void Convolution_getParamf(const EffectProps* /*props*/, ALenum param, float* /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect float property 0x%04x",
+            param};
+    }
+}
+void Convolution_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{
+    switch(param)
+    {
+    default:
+        Convolution_getParamf(props, param, vals);
+    }
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Convolution);
+
+const EffectProps ConvolutionEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/dedicated.cpp

@@ -0,0 +1,72 @@
+
+#include "config.h"
+
+#include <cmath>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Dedicated_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
+void Dedicated_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
+        param};
+}
+void Dedicated_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_DEDICATED_GAIN:
+        if(!(val >= 0.0f && std::isfinite(val)))
+            throw effect_exception{AL_INVALID_VALUE, "Dedicated gain out of range"};
+        props->Dedicated.Gain = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
+    }
+}
+void Dedicated_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Dedicated_setParamf(props, param, vals[0]); }
+
+void Dedicated_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
+void Dedicated_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
+        param};
+}
+void Dedicated_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_DEDICATED_GAIN:
+        *val = props->Dedicated.Gain;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
+    }
+}
+void Dedicated_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Dedicated_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Dedicated.Gain = 1.0f;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Dedicated);
+
+const EffectProps DedicatedEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/distortion.cpp

@@ -0,0 +1,114 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Distortion_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
+void Distortion_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
+        param};
+}
+void Distortion_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_DISTORTION_EDGE:
+        if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
+            throw effect_exception{AL_INVALID_VALUE, "Distortion edge out of range"};
+        props->Distortion.Edge = val;
+        break;
+
+    case AL_DISTORTION_GAIN:
+        if(!(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Distortion gain out of range"};
+        props->Distortion.Gain = val;
+        break;
+
+    case AL_DISTORTION_LOWPASS_CUTOFF:
+        if(!(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF))
+            throw effect_exception{AL_INVALID_VALUE, "Distortion low-pass cutoff out of range"};
+        props->Distortion.LowpassCutoff = val;
+        break;
+
+    case AL_DISTORTION_EQCENTER:
+        if(!(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER))
+            throw effect_exception{AL_INVALID_VALUE, "Distortion EQ center out of range"};
+        props->Distortion.EQCenter = val;
+        break;
+
+    case AL_DISTORTION_EQBANDWIDTH:
+        if(!(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH))
+            throw effect_exception{AL_INVALID_VALUE, "Distortion EQ bandwidth out of range"};
+        props->Distortion.EQBandwidth = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
+    }
+}
+void Distortion_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Distortion_setParamf(props, param, vals[0]); }
+
+void Distortion_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
+void Distortion_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
+        param};
+}
+void Distortion_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_DISTORTION_EDGE:
+        *val = props->Distortion.Edge;
+        break;
+
+    case AL_DISTORTION_GAIN:
+        *val = props->Distortion.Gain;
+        break;
+
+    case AL_DISTORTION_LOWPASS_CUTOFF:
+        *val = props->Distortion.LowpassCutoff;
+        break;
+
+    case AL_DISTORTION_EQCENTER:
+        *val = props->Distortion.EQCenter;
+        break;
+
+    case AL_DISTORTION_EQBANDWIDTH:
+        *val = props->Distortion.EQBandwidth;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
+    }
+}
+void Distortion_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Distortion_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE;
+    props.Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN;
+    props.Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF;
+    props.Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER;
+    props.Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Distortion);
+
+const EffectProps DistortionEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/echo.cpp

@@ -0,0 +1,111 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+static_assert(EchoMaxDelay >= AL_ECHO_MAX_DELAY, "Echo max delay too short");
+static_assert(EchoMaxLRDelay >= AL_ECHO_MAX_LRDELAY, "Echo max left-right delay too short");
+
+void Echo_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param}; }
+void Echo_setParamiv(EffectProps*, ALenum param, const int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param}; }
+void Echo_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_ECHO_DELAY:
+        if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Echo delay out of range"};
+        props->Echo.Delay = val;
+        break;
+
+    case AL_ECHO_LRDELAY:
+        if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Echo LR delay out of range"};
+        props->Echo.LRDelay = val;
+        break;
+
+    case AL_ECHO_DAMPING:
+        if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING))
+            throw effect_exception{AL_INVALID_VALUE, "Echo damping out of range"};
+        props->Echo.Damping = val;
+        break;
+
+    case AL_ECHO_FEEDBACK:
+        if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK))
+            throw effect_exception{AL_INVALID_VALUE, "Echo feedback out of range"};
+        props->Echo.Feedback = val;
+        break;
+
+    case AL_ECHO_SPREAD:
+        if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD))
+            throw effect_exception{AL_INVALID_VALUE, "Echo spread out of range"};
+        props->Echo.Spread = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param};
+    }
+}
+void Echo_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Echo_setParamf(props, param, vals[0]); }
+
+void Echo_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param}; }
+void Echo_getParamiv(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param}; }
+void Echo_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_ECHO_DELAY:
+        *val = props->Echo.Delay;
+        break;
+
+    case AL_ECHO_LRDELAY:
+        *val = props->Echo.LRDelay;
+        break;
+
+    case AL_ECHO_DAMPING:
+        *val = props->Echo.Damping;
+        break;
+
+    case AL_ECHO_FEEDBACK:
+        *val = props->Echo.Feedback;
+        break;
+
+    case AL_ECHO_SPREAD:
+        *val = props->Echo.Spread;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param};
+    }
+}
+void Echo_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Echo_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Echo.Delay    = AL_ECHO_DEFAULT_DELAY;
+    props.Echo.LRDelay  = AL_ECHO_DEFAULT_LRDELAY;
+    props.Echo.Damping  = AL_ECHO_DEFAULT_DAMPING;
+    props.Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
+    props.Echo.Spread   = AL_ECHO_DEFAULT_SPREAD;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Echo);
+
+const EffectProps EchoEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/effects.h

@@ -0,0 +1,79 @@
+#ifndef AL_EFFECTS_EFFECTS_H
+#define AL_EFFECTS_EFFECTS_H
+
+#include "AL/al.h"
+
+#include "core/except.h"
+
+union EffectProps;
+
+
+class effect_exception final : public al::base_exception {
+    ALenum mErrorCode;
+
+public:
+    [[gnu::format(printf, 3, 4)]]
+    effect_exception(ALenum code, const char *msg, ...);
+
+    ALenum errorCode() const noexcept { return mErrorCode; }
+};
+
+
+struct EffectVtable {
+    void (*const setParami)(EffectProps *props, ALenum param, int val);
+    void (*const setParamiv)(EffectProps *props, ALenum param, const int *vals);
+    void (*const setParamf)(EffectProps *props, ALenum param, float val);
+    void (*const setParamfv)(EffectProps *props, ALenum param, const float *vals);
+
+    void (*const getParami)(const EffectProps *props, ALenum param, int *val);
+    void (*const getParamiv)(const EffectProps *props, ALenum param, int *vals);
+    void (*const getParamf)(const EffectProps *props, ALenum param, float *val);
+    void (*const getParamfv)(const EffectProps *props, ALenum param, float *vals);
+};
+
+#define DEFINE_ALEFFECT_VTABLE(T)           \
+const EffectVtable T##EffectVtable = {      \
+    T##_setParami, T##_setParamiv,          \
+    T##_setParamf, T##_setParamfv,          \
+    T##_getParami, T##_getParamiv,          \
+    T##_getParamf, T##_getParamfv,          \
+}
+
+
+/* Default properties for the given effect types. */
+extern const EffectProps NullEffectProps;
+extern const EffectProps ReverbEffectProps;
+extern const EffectProps StdReverbEffectProps;
+extern const EffectProps AutowahEffectProps;
+extern const EffectProps ChorusEffectProps;
+extern const EffectProps CompressorEffectProps;
+extern const EffectProps DistortionEffectProps;
+extern const EffectProps EchoEffectProps;
+extern const EffectProps EqualizerEffectProps;
+extern const EffectProps FlangerEffectProps;
+extern const EffectProps FshifterEffectProps;
+extern const EffectProps ModulatorEffectProps;
+extern const EffectProps PshifterEffectProps;
+extern const EffectProps VmorpherEffectProps;
+extern const EffectProps DedicatedEffectProps;
+extern const EffectProps ConvolutionEffectProps;
+
+/* Vtables to get/set properties for the given effect types. */
+extern const EffectVtable NullEffectVtable;
+extern const EffectVtable ReverbEffectVtable;
+extern const EffectVtable StdReverbEffectVtable;
+extern const EffectVtable AutowahEffectVtable;
+extern const EffectVtable ChorusEffectVtable;
+extern const EffectVtable CompressorEffectVtable;
+extern const EffectVtable DistortionEffectVtable;
+extern const EffectVtable EchoEffectVtable;
+extern const EffectVtable EqualizerEffectVtable;
+extern const EffectVtable FlangerEffectVtable;
+extern const EffectVtable FshifterEffectVtable;
+extern const EffectVtable ModulatorEffectVtable;
+extern const EffectVtable PshifterEffectVtable;
+extern const EffectVtable VmorpherEffectVtable;
+extern const EffectVtable DedicatedEffectVtable;
+extern const EffectVtable ConvolutionEffectVtable;
+
+#endif /* AL_EFFECTS_EFFECTS_H */

Engine/lib/openal-soft/al/effects/equalizer.cpp

@@ -0,0 +1,169 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Equalizer_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param}; }
+void Equalizer_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x",
+        param};
+}
+void Equalizer_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_EQUALIZER_LOW_GAIN:
+        if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer low-band gain out of range"};
+        props->Equalizer.LowGain = val;
+        break;
+
+    case AL_EQUALIZER_LOW_CUTOFF:
+        if(!(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer low-band cutoff out of range"};
+        props->Equalizer.LowCutoff = val;
+        break;
+
+    case AL_EQUALIZER_MID1_GAIN:
+        if(!(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band gain out of range"};
+        props->Equalizer.Mid1Gain = val;
+        break;
+
+    case AL_EQUALIZER_MID1_CENTER:
+        if(!(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band center out of range"};
+        props->Equalizer.Mid1Center = val;
+        break;
+
+    case AL_EQUALIZER_MID1_WIDTH:
+        if(!(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band width out of range"};
+        props->Equalizer.Mid1Width = val;
+        break;
+
+    case AL_EQUALIZER_MID2_GAIN:
+        if(!(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band gain out of range"};
+        props->Equalizer.Mid2Gain = val;
+        break;
+
+    case AL_EQUALIZER_MID2_CENTER:
+        if(!(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band center out of range"};
+        props->Equalizer.Mid2Center = val;
+        break;
+
+    case AL_EQUALIZER_MID2_WIDTH:
+        if(!(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band width out of range"};
+        props->Equalizer.Mid2Width = val;
+        break;
+
+    case AL_EQUALIZER_HIGH_GAIN:
+        if(!(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer high-band gain out of range"};
+        props->Equalizer.HighGain = val;
+        break;
+
+    case AL_EQUALIZER_HIGH_CUTOFF:
+        if(!(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF))
+            throw effect_exception{AL_INVALID_VALUE, "Equalizer high-band cutoff out of range"};
+        props->Equalizer.HighCutoff = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param};
+    }
+}
+void Equalizer_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Equalizer_setParamf(props, param, vals[0]); }
+
+void Equalizer_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param}; }
+void Equalizer_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x",
+        param};
+}
+void Equalizer_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_EQUALIZER_LOW_GAIN:
+        *val = props->Equalizer.LowGain;
+        break;
+
+    case AL_EQUALIZER_LOW_CUTOFF:
+        *val = props->Equalizer.LowCutoff;
+        break;
+
+    case AL_EQUALIZER_MID1_GAIN:
+        *val = props->Equalizer.Mid1Gain;
+        break;
+
+    case AL_EQUALIZER_MID1_CENTER:
+        *val = props->Equalizer.Mid1Center;
+        break;
+
+    case AL_EQUALIZER_MID1_WIDTH:
+        *val = props->Equalizer.Mid1Width;
+        break;
+
+    case AL_EQUALIZER_MID2_GAIN:
+        *val = props->Equalizer.Mid2Gain;
+        break;
+
+    case AL_EQUALIZER_MID2_CENTER:
+        *val = props->Equalizer.Mid2Center;
+        break;
+
+    case AL_EQUALIZER_MID2_WIDTH:
+        *val = props->Equalizer.Mid2Width;
+        break;
+
+    case AL_EQUALIZER_HIGH_GAIN:
+        *val = props->Equalizer.HighGain;
+        break;
+
+    case AL_EQUALIZER_HIGH_CUTOFF:
+        *val = props->Equalizer.HighCutoff;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param};
+    }
+}
+void Equalizer_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Equalizer_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF;
+    props.Equalizer.LowGain = AL_EQUALIZER_DEFAULT_LOW_GAIN;
+    props.Equalizer.Mid1Center = AL_EQUALIZER_DEFAULT_MID1_CENTER;
+    props.Equalizer.Mid1Gain = AL_EQUALIZER_DEFAULT_MID1_GAIN;
+    props.Equalizer.Mid1Width = AL_EQUALIZER_DEFAULT_MID1_WIDTH;
+    props.Equalizer.Mid2Center = AL_EQUALIZER_DEFAULT_MID2_CENTER;
+    props.Equalizer.Mid2Gain = AL_EQUALIZER_DEFAULT_MID2_GAIN;
+    props.Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH;
+    props.Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF;
+    props.Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Equalizer);
+
+const EffectProps EqualizerEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/fshifter.cpp

@@ -0,0 +1,128 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "aloptional.h"
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+al::optional<FShifterDirection> DirectionFromEmum(ALenum value)
+{
+    switch(value)
+    {
+    case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN: return al::make_optional(FShifterDirection::Down);
+    case AL_FREQUENCY_SHIFTER_DIRECTION_UP: return al::make_optional(FShifterDirection::Up);
+    case AL_FREQUENCY_SHIFTER_DIRECTION_OFF: return al::make_optional(FShifterDirection::Off);
+    }
+    return al::nullopt;
+}
+ALenum EnumFromDirection(FShifterDirection dir)
+{
+    switch(dir)
+    {
+    case FShifterDirection::Down: return AL_FREQUENCY_SHIFTER_DIRECTION_DOWN;
+    case FShifterDirection::Up: return AL_FREQUENCY_SHIFTER_DIRECTION_UP;
+    case FShifterDirection::Off: return AL_FREQUENCY_SHIFTER_DIRECTION_OFF;
+    }
+    throw std::runtime_error{"Invalid direction: "+std::to_string(static_cast<int>(dir))};
+}
+
+void Fshifter_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_FREQUENCY_SHIFTER_FREQUENCY:
+        if(!(val >= AL_FREQUENCY_SHIFTER_MIN_FREQUENCY && val <= AL_FREQUENCY_SHIFTER_MAX_FREQUENCY))
+            throw effect_exception{AL_INVALID_VALUE, "Frequency shifter frequency out of range"};
+        props->Fshifter.Frequency = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x",
+            param};
+    }
+}
+void Fshifter_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Fshifter_setParamf(props, param, vals[0]); }
+
+void Fshifter_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
+        if(auto diropt = DirectionFromEmum(val))
+            props->Fshifter.LeftDirection = *diropt;
+        else
+            throw effect_exception{AL_INVALID_VALUE,
+                "Unsupported frequency shifter left direction: 0x%04x", val};
+        break;
+
+    case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
+        if(auto diropt = DirectionFromEmum(val))
+            props->Fshifter.RightDirection = *diropt;
+        else
+            throw effect_exception{AL_INVALID_VALUE,
+                "Unsupported frequency shifter right direction: 0x%04x", val};
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM,
+            "Invalid frequency shifter integer property 0x%04x", param};
+    }
+}
+void Fshifter_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Fshifter_setParami(props, param, vals[0]); }
+
+void Fshifter_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
+        *val = EnumFromDirection(props->Fshifter.LeftDirection);
+        break;
+    case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
+        *val = EnumFromDirection(props->Fshifter.RightDirection);
+        break;
+    default:
+        throw effect_exception{AL_INVALID_ENUM,
+            "Invalid frequency shifter integer property 0x%04x", param};
+    }
+}
+void Fshifter_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Fshifter_getParami(props, param, vals); }
+
+void Fshifter_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_FREQUENCY_SHIFTER_FREQUENCY:
+        *val = props->Fshifter.Frequency;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x",
+            param};
+    }
+}
+void Fshifter_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Fshifter_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Fshifter.Frequency      = AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY;
+    props.Fshifter.LeftDirection  = *DirectionFromEmum(AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION);
+    props.Fshifter.RightDirection = *DirectionFromEmum(AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION);
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Fshifter);
+
+const EffectProps FshifterEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/modulator.cpp

@@ -0,0 +1,134 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "aloptional.h"
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+al::optional<ModulatorWaveform> WaveformFromEmum(ALenum value)
+{
+    switch(value)
+    {
+    case AL_RING_MODULATOR_SINUSOID: return al::make_optional(ModulatorWaveform::Sinusoid);
+    case AL_RING_MODULATOR_SAWTOOTH: return al::make_optional(ModulatorWaveform::Sawtooth);
+    case AL_RING_MODULATOR_SQUARE: return al::make_optional(ModulatorWaveform::Square);
+    }
+    return al::nullopt;
+}
+ALenum EnumFromWaveform(ModulatorWaveform type)
+{
+    switch(type)
+    {
+    case ModulatorWaveform::Sinusoid: return AL_RING_MODULATOR_SINUSOID;
+    case ModulatorWaveform::Sawtooth: return AL_RING_MODULATOR_SAWTOOTH;
+    case ModulatorWaveform::Square: return AL_RING_MODULATOR_SQUARE;
+    }
+    throw std::runtime_error{"Invalid modulator waveform: " +
+        std::to_string(static_cast<int>(type))};
+}
+
+void Modulator_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_RING_MODULATOR_FREQUENCY:
+        if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
+            throw effect_exception{AL_INVALID_VALUE, "Modulator frequency out of range: %f", val};
+        props->Modulator.Frequency = val;
+        break;
+
+    case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+        if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
+            throw effect_exception{AL_INVALID_VALUE, "Modulator high-pass cutoff out of range: %f", val};
+        props->Modulator.HighPassCutoff = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
+    }
+}
+void Modulator_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Modulator_setParamf(props, param, vals[0]); }
+void Modulator_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_RING_MODULATOR_FREQUENCY:
+    case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+        Modulator_setParamf(props, param, static_cast<float>(val));
+        break;
+
+    case AL_RING_MODULATOR_WAVEFORM:
+        if(auto formopt = WaveformFromEmum(val))
+            props->Modulator.Waveform = *formopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Invalid modulator waveform: 0x%04x", val};
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
+            param};
+    }
+}
+void Modulator_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Modulator_setParami(props, param, vals[0]); }
+
+void Modulator_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_RING_MODULATOR_FREQUENCY:
+        *val = static_cast<int>(props->Modulator.Frequency);
+        break;
+    case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+        *val = static_cast<int>(props->Modulator.HighPassCutoff);
+        break;
+    case AL_RING_MODULATOR_WAVEFORM:
+        *val = EnumFromWaveform(props->Modulator.Waveform);
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
+            param};
+    }
+}
+void Modulator_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Modulator_getParami(props, param, vals); }
+void Modulator_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_RING_MODULATOR_FREQUENCY:
+        *val = props->Modulator.Frequency;
+        break;
+    case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+        *val = props->Modulator.HighPassCutoff;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
+    }
+}
+void Modulator_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Modulator_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Modulator.Frequency      = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
+    props.Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
+    props.Modulator.Waveform       = *WaveformFromEmum(AL_RING_MODULATOR_DEFAULT_WAVEFORM);
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Modulator);
+
+const EffectProps ModulatorEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/null.cpp

@@ -0,0 +1,93 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Null_setParami(EffectProps* /*props*/, ALenum param, int /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x",
+            param};
+    }
+}
+void Null_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{
+    switch(param)
+    {
+    default:
+        Null_setParami(props, param, vals[0]);
+    }
+}
+void Null_setParamf(EffectProps* /*props*/, ALenum param, float /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect float property 0x%04x",
+            param};
+    }
+}
+void Null_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{
+    switch(param)
+    {
+    default:
+        Null_setParamf(props, param, vals[0]);
+    }
+}
+
+void Null_getParami(const EffectProps* /*props*/, ALenum param, int* /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x",
+            param};
+    }
+}
+void Null_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{
+    switch(param)
+    {
+    default:
+        Null_getParami(props, param, vals);
+    }
+}
+void Null_getParamf(const EffectProps* /*props*/, ALenum param, float* /*val*/)
+{
+    switch(param)
+    {
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid null effect float property 0x%04x",
+            param};
+    }
+}
+void Null_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{
+    switch(param)
+    {
+    default:
+        Null_getParamf(props, param, vals);
+    }
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Null);
+
+const EffectProps NullEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/pshifter.cpp

@@ -0,0 +1,84 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Pshifter_setParamf(EffectProps*, ALenum param, float)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param}; }
+void Pshifter_setParamfv(EffectProps*, ALenum param, const float*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float-vector property 0x%04x",
+        param};
+}
+
+void Pshifter_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_PITCH_SHIFTER_COARSE_TUNE:
+        if(!(val >= AL_PITCH_SHIFTER_MIN_COARSE_TUNE && val <= AL_PITCH_SHIFTER_MAX_COARSE_TUNE))
+            throw effect_exception{AL_INVALID_VALUE, "Pitch shifter coarse tune out of range"};
+        props->Pshifter.CoarseTune = val;
+        break;
+
+    case AL_PITCH_SHIFTER_FINE_TUNE:
+        if(!(val >= AL_PITCH_SHIFTER_MIN_FINE_TUNE && val <= AL_PITCH_SHIFTER_MAX_FINE_TUNE))
+            throw effect_exception{AL_INVALID_VALUE, "Pitch shifter fine tune out of range"};
+        props->Pshifter.FineTune = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
+            param};
+    }
+}
+void Pshifter_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Pshifter_setParami(props, param, vals[0]); }
+
+void Pshifter_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_PITCH_SHIFTER_COARSE_TUNE:
+        *val = props->Pshifter.CoarseTune;
+        break;
+    case AL_PITCH_SHIFTER_FINE_TUNE:
+        *val = props->Pshifter.FineTune;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
+            param};
+    }
+}
+void Pshifter_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Pshifter_getParami(props, param, vals); }
+
+void Pshifter_getParamf(const EffectProps*, ALenum param, float*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param}; }
+void Pshifter_getParamfv(const EffectProps*, ALenum param, float*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float vector-property 0x%04x",
+        param};
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Pshifter.CoarseTune = AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE;
+    props.Pshifter.FineTune   = AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Pshifter);
+
+const EffectProps PshifterEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/effects/reverb.cpp

@@ -0,0 +1,556 @@
+
+#include "config.h"
+
+#include <cmath>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+void Reverb_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_DECAY_HFLIMIT:
+        if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay hflimit out of range"};
+        props->Reverb.DecayHFLimit = val != AL_FALSE;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
+            param};
+    }
+}
+void Reverb_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ Reverb_setParami(props, param, vals[0]); }
+void Reverb_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_DENSITY:
+        if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb density out of range"};
+        props->Reverb.Density = val;
+        break;
+
+    case AL_EAXREVERB_DIFFUSION:
+        if(!(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb diffusion out of range"};
+        props->Reverb.Diffusion = val;
+        break;
+
+    case AL_EAXREVERB_GAIN:
+        if(!(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gain out of range"};
+        props->Reverb.Gain = val;
+        break;
+
+    case AL_EAXREVERB_GAINHF:
+        if(!(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gainhf out of range"};
+        props->Reverb.GainHF = val;
+        break;
+
+    case AL_EAXREVERB_GAINLF:
+        if(!(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gainlf out of range"};
+        props->Reverb.GainLF = val;
+        break;
+
+    case AL_EAXREVERB_DECAY_TIME:
+        if(!(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay time out of range"};
+        props->Reverb.DecayTime = val;
+        break;
+
+    case AL_EAXREVERB_DECAY_HFRATIO:
+        if(!(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay hfratio out of range"};
+        props->Reverb.DecayHFRatio = val;
+        break;
+
+    case AL_EAXREVERB_DECAY_LFRATIO:
+        if(!(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay lfratio out of range"};
+        props->Reverb.DecayLFRatio = val;
+        break;
+
+    case AL_EAXREVERB_REFLECTIONS_GAIN:
+        if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections gain out of range"};
+        props->Reverb.ReflectionsGain = val;
+        break;
+
+    case AL_EAXREVERB_REFLECTIONS_DELAY:
+        if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections delay out of range"};
+        props->Reverb.ReflectionsDelay = val;
+        break;
+
+    case AL_EAXREVERB_LATE_REVERB_GAIN:
+        if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb gain out of range"};
+        props->Reverb.LateReverbGain = val;
+        break;
+
+    case AL_EAXREVERB_LATE_REVERB_DELAY:
+        if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb delay out of range"};
+        props->Reverb.LateReverbDelay = val;
+        break;
+
+    case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+        if(!(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb air absorption gainhf out of range"};
+        props->Reverb.AirAbsorptionGainHF = val;
+        break;
+
+    case AL_EAXREVERB_ECHO_TIME:
+        if(!(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb echo time out of range"};
+        props->Reverb.EchoTime = val;
+        break;
+
+    case AL_EAXREVERB_ECHO_DEPTH:
+        if(!(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb echo depth out of range"};
+        props->Reverb.EchoDepth = val;
+        break;
+
+    case AL_EAXREVERB_MODULATION_TIME:
+        if(!(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb modulation time out of range"};
+        props->Reverb.ModulationTime = val;
+        break;
+
+    case AL_EAXREVERB_MODULATION_DEPTH:
+        if(!(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb modulation depth out of range"};
+        props->Reverb.ModulationDepth = val;
+        break;
+
+    case AL_EAXREVERB_HFREFERENCE:
+        if(!(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb hfreference out of range"};
+        props->Reverb.HFReference = val;
+        break;
+
+    case AL_EAXREVERB_LFREFERENCE:
+        if(!(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb lfreference out of range"};
+        props->Reverb.LFReference = val;
+        break;
+
+    case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+        if(!(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb room rolloff factor out of range"};
+        props->Reverb.RoomRolloffFactor = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param};
+    }
+}
+void Reverb_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_REFLECTIONS_PAN:
+        if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections pan out of range"};
+        props->Reverb.ReflectionsPan[0] = vals[0];
+        props->Reverb.ReflectionsPan[1] = vals[1];
+        props->Reverb.ReflectionsPan[2] = vals[2];
+        break;
+    case AL_EAXREVERB_LATE_REVERB_PAN:
+        if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
+            throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb pan out of range"};
+        props->Reverb.LateReverbPan[0] = vals[0];
+        props->Reverb.LateReverbPan[1] = vals[1];
+        props->Reverb.LateReverbPan[2] = vals[2];
+        break;
+
+    default:
+        Reverb_setParamf(props, param, vals[0]);
+        break;
+    }
+}
+
+void Reverb_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_DECAY_HFLIMIT:
+        *val = props->Reverb.DecayHFLimit;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
+            param};
+    }
+}
+void Reverb_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ Reverb_getParami(props, param, vals); }
+void Reverb_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_DENSITY:
+        *val = props->Reverb.Density;
+        break;
+
+    case AL_EAXREVERB_DIFFUSION:
+        *val = props->Reverb.Diffusion;
+        break;
+
+    case AL_EAXREVERB_GAIN:
+        *val = props->Reverb.Gain;
+        break;
+
+    case AL_EAXREVERB_GAINHF:
+        *val = props->Reverb.GainHF;
+        break;
+
+    case AL_EAXREVERB_GAINLF:
+        *val = props->Reverb.GainLF;
+        break;
+
+    case AL_EAXREVERB_DECAY_TIME:
+        *val = props->Reverb.DecayTime;
+        break;
+
+    case AL_EAXREVERB_DECAY_HFRATIO:
+        *val = props->Reverb.DecayHFRatio;
+        break;
+
+    case AL_EAXREVERB_DECAY_LFRATIO:
+        *val = props->Reverb.DecayLFRatio;
+        break;
+
+    case AL_EAXREVERB_REFLECTIONS_GAIN:
+        *val = props->Reverb.ReflectionsGain;
+        break;
+
+    case AL_EAXREVERB_REFLECTIONS_DELAY:
+        *val = props->Reverb.ReflectionsDelay;
+        break;
+
+    case AL_EAXREVERB_LATE_REVERB_GAIN:
+        *val = props->Reverb.LateReverbGain;
+        break;
+
+    case AL_EAXREVERB_LATE_REVERB_DELAY:
+        *val = props->Reverb.LateReverbDelay;
+        break;
+
+    case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+        *val = props->Reverb.AirAbsorptionGainHF;
+        break;
+
+    case AL_EAXREVERB_ECHO_TIME:
+        *val = props->Reverb.EchoTime;
+        break;
+
+    case AL_EAXREVERB_ECHO_DEPTH:
+        *val = props->Reverb.EchoDepth;
+        break;
+
+    case AL_EAXREVERB_MODULATION_TIME:
+        *val = props->Reverb.ModulationTime;
+        break;
+
+    case AL_EAXREVERB_MODULATION_DEPTH:
+        *val = props->Reverb.ModulationDepth;
+        break;
+
+    case AL_EAXREVERB_HFREFERENCE:
+        *val = props->Reverb.HFReference;
+        break;
+
+    case AL_EAXREVERB_LFREFERENCE:
+        *val = props->Reverb.LFReference;
+        break;
+
+    case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+        *val = props->Reverb.RoomRolloffFactor;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param};
+    }
+}
+void Reverb_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{
+    switch(param)
+    {
+    case AL_EAXREVERB_REFLECTIONS_PAN:
+        vals[0] = props->Reverb.ReflectionsPan[0];
+        vals[1] = props->Reverb.ReflectionsPan[1];
+        vals[2] = props->Reverb.ReflectionsPan[2];
+        break;
+    case AL_EAXREVERB_LATE_REVERB_PAN:
+        vals[0] = props->Reverb.LateReverbPan[0];
+        vals[1] = props->Reverb.LateReverbPan[1];
+        vals[2] = props->Reverb.LateReverbPan[2];
+        break;
+
+    default:
+        Reverb_getParamf(props, param, vals);
+        break;
+    }
+}
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Reverb.Density   = AL_EAXREVERB_DEFAULT_DENSITY;
+    props.Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
+    props.Reverb.Gain   = AL_EAXREVERB_DEFAULT_GAIN;
+    props.Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
+    props.Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
+    props.Reverb.DecayTime    = AL_EAXREVERB_DEFAULT_DECAY_TIME;
+    props.Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
+    props.Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
+    props.Reverb.ReflectionsGain   = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
+    props.Reverb.ReflectionsDelay  = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
+    props.Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+    props.Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+    props.Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+    props.Reverb.LateReverbGain   = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
+    props.Reverb.LateReverbDelay  = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
+    props.Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+    props.Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+    props.Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+    props.Reverb.EchoTime  = AL_EAXREVERB_DEFAULT_ECHO_TIME;
+    props.Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
+    props.Reverb.ModulationTime  = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
+    props.Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
+    props.Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
+    props.Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
+    props.Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
+    props.Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
+    props.Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
+    return props;
+}
+
+
+void StdReverb_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_REVERB_DECAY_HFLIMIT:
+        if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb decay hflimit out of range"};
+        props->Reverb.DecayHFLimit = val != AL_FALSE;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param};
+    }
+}
+void StdReverb_setParamiv(EffectProps *props, ALenum param, const int *vals)
+{ StdReverb_setParami(props, param, vals[0]); }
+void StdReverb_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_REVERB_DENSITY:
+        if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb density out of range"};
+        props->Reverb.Density = val;
+        break;
+
+    case AL_REVERB_DIFFUSION:
+        if(!(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb diffusion out of range"};
+        props->Reverb.Diffusion = val;
+        break;
+
+    case AL_REVERB_GAIN:
+        if(!(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb gain out of range"};
+        props->Reverb.Gain = val;
+        break;
+
+    case AL_REVERB_GAINHF:
+        if(!(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb gainhf out of range"};
+        props->Reverb.GainHF = val;
+        break;
+
+    case AL_REVERB_DECAY_TIME:
+        if(!(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb decay time out of range"};
+        props->Reverb.DecayTime = val;
+        break;
+
+    case AL_REVERB_DECAY_HFRATIO:
+        if(!(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb decay hfratio out of range"};
+        props->Reverb.DecayHFRatio = val;
+        break;
+
+    case AL_REVERB_REFLECTIONS_GAIN:
+        if(!(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb reflections gain out of range"};
+        props->Reverb.ReflectionsGain = val;
+        break;
+
+    case AL_REVERB_REFLECTIONS_DELAY:
+        if(!(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb reflections delay out of range"};
+        props->Reverb.ReflectionsDelay = val;
+        break;
+
+    case AL_REVERB_LATE_REVERB_GAIN:
+        if(!(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb late reverb gain out of range"};
+        props->Reverb.LateReverbGain = val;
+        break;
+
+    case AL_REVERB_LATE_REVERB_DELAY:
+        if(!(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb late reverb delay out of range"};
+        props->Reverb.LateReverbDelay = val;
+        break;
+
+    case AL_REVERB_AIR_ABSORPTION_GAINHF:
+        if(!(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb air absorption gainhf out of range"};
+        props->Reverb.AirAbsorptionGainHF = val;
+        break;
+
+    case AL_REVERB_ROOM_ROLLOFF_FACTOR:
+        if(!(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR))
+            throw effect_exception{AL_INVALID_VALUE, "Reverb room rolloff factor out of range"};
+        props->Reverb.RoomRolloffFactor = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param};
+    }
+}
+void StdReverb_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ StdReverb_setParamf(props, param, vals[0]); }
+
+void StdReverb_getParami(const EffectProps *props, ALenum param, int *val)
+{
+    switch(param)
+    {
+    case AL_REVERB_DECAY_HFLIMIT:
+        *val = props->Reverb.DecayHFLimit;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param};
+    }
+}
+void StdReverb_getParamiv(const EffectProps *props, ALenum param, int *vals)
+{ StdReverb_getParami(props, param, vals); }
+void StdReverb_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_REVERB_DENSITY:
+        *val = props->Reverb.Density;
+        break;
+
+    case AL_REVERB_DIFFUSION:
+        *val = props->Reverb.Diffusion;
+        break;
+
+    case AL_REVERB_GAIN:
+        *val = props->Reverb.Gain;
+        break;
+
+    case AL_REVERB_GAINHF:
+        *val = props->Reverb.GainHF;
+        break;
+
+    case AL_REVERB_DECAY_TIME:
+        *val = props->Reverb.DecayTime;
+        break;
+
+    case AL_REVERB_DECAY_HFRATIO:
+        *val = props->Reverb.DecayHFRatio;
+        break;
+
+    case AL_REVERB_REFLECTIONS_GAIN:
+        *val = props->Reverb.ReflectionsGain;
+        break;
+
+    case AL_REVERB_REFLECTIONS_DELAY:
+        *val = props->Reverb.ReflectionsDelay;
+        break;
+
+    case AL_REVERB_LATE_REVERB_GAIN:
+        *val = props->Reverb.LateReverbGain;
+        break;
+
+    case AL_REVERB_LATE_REVERB_DELAY:
+        *val = props->Reverb.LateReverbDelay;
+        break;
+
+    case AL_REVERB_AIR_ABSORPTION_GAINHF:
+        *val = props->Reverb.AirAbsorptionGainHF;
+        break;
+
+    case AL_REVERB_ROOM_ROLLOFF_FACTOR:
+        *val = props->Reverb.RoomRolloffFactor;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param};
+    }
+}
+void StdReverb_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ StdReverb_getParamf(props, param, vals); }
+
+EffectProps genDefaultStdProps() noexcept
+{
+    EffectProps props{};
+    props.Reverb.Density   = AL_REVERB_DEFAULT_DENSITY;
+    props.Reverb.Diffusion = AL_REVERB_DEFAULT_DIFFUSION;
+    props.Reverb.Gain   = AL_REVERB_DEFAULT_GAIN;
+    props.Reverb.GainHF = AL_REVERB_DEFAULT_GAINHF;
+    props.Reverb.GainLF = 1.0f;
+    props.Reverb.DecayTime    = AL_REVERB_DEFAULT_DECAY_TIME;
+    props.Reverb.DecayHFRatio = AL_REVERB_DEFAULT_DECAY_HFRATIO;
+    props.Reverb.DecayLFRatio = 1.0f;
+    props.Reverb.ReflectionsGain   = AL_REVERB_DEFAULT_REFLECTIONS_GAIN;
+    props.Reverb.ReflectionsDelay  = AL_REVERB_DEFAULT_REFLECTIONS_DELAY;
+    props.Reverb.ReflectionsPan[0] = 0.0f;
+    props.Reverb.ReflectionsPan[1] = 0.0f;
+    props.Reverb.ReflectionsPan[2] = 0.0f;
+    props.Reverb.LateReverbGain   = AL_REVERB_DEFAULT_LATE_REVERB_GAIN;
+    props.Reverb.LateReverbDelay  = AL_REVERB_DEFAULT_LATE_REVERB_DELAY;
+    props.Reverb.LateReverbPan[0] = 0.0f;
+    props.Reverb.LateReverbPan[1] = 0.0f;
+    props.Reverb.LateReverbPan[2] = 0.0f;
+    props.Reverb.EchoTime  = 0.25f;
+    props.Reverb.EchoDepth = 0.0f;
+    props.Reverb.ModulationTime  = 0.25f;
+    props.Reverb.ModulationDepth = 0.0f;
+    props.Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
+    props.Reverb.HFReference = 5000.0f;
+    props.Reverb.LFReference = 250.0f;
+    props.Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
+    props.Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT;
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Reverb);
+
+const EffectProps ReverbEffectProps{genDefaultProps()};
+
+DEFINE_ALEFFECT_VTABLE(StdReverb);
+
+const EffectProps StdReverbEffectProps{genDefaultStdProps()};

Engine/lib/openal-soft/al/effects/vmorpher.cpp

@@ -0,0 +1,247 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "aloptional.h"
+#include "effects.h"
+#include "effects/base.h"
+
+
+namespace {
+
+al::optional<VMorpherPhenome> PhenomeFromEnum(ALenum val)
+{
+#define HANDLE_PHENOME(x) case AL_VOCAL_MORPHER_PHONEME_ ## x:                \
+    return al::make_optional(VMorpherPhenome::x)
+    switch(val)
+    {
+    HANDLE_PHENOME(A);
+    HANDLE_PHENOME(E);
+    HANDLE_PHENOME(I);
+    HANDLE_PHENOME(O);
+    HANDLE_PHENOME(U);
+    HANDLE_PHENOME(AA);
+    HANDLE_PHENOME(AE);
+    HANDLE_PHENOME(AH);
+    HANDLE_PHENOME(AO);
+    HANDLE_PHENOME(EH);
+    HANDLE_PHENOME(ER);
+    HANDLE_PHENOME(IH);
+    HANDLE_PHENOME(IY);
+    HANDLE_PHENOME(UH);
+    HANDLE_PHENOME(UW);
+    HANDLE_PHENOME(B);
+    HANDLE_PHENOME(D);
+    HANDLE_PHENOME(F);
+    HANDLE_PHENOME(G);
+    HANDLE_PHENOME(J);
+    HANDLE_PHENOME(K);
+    HANDLE_PHENOME(L);
+    HANDLE_PHENOME(M);
+    HANDLE_PHENOME(N);
+    HANDLE_PHENOME(P);
+    HANDLE_PHENOME(R);
+    HANDLE_PHENOME(S);
+    HANDLE_PHENOME(T);
+    HANDLE_PHENOME(V);
+    HANDLE_PHENOME(Z);
+    }
+    return al::nullopt;
+#undef HANDLE_PHENOME
+}
+ALenum EnumFromPhenome(VMorpherPhenome phenome)
+{
+#define HANDLE_PHENOME(x) case VMorpherPhenome::x: return AL_VOCAL_MORPHER_PHONEME_ ## x
+    switch(phenome)
+    {
+    HANDLE_PHENOME(A);
+    HANDLE_PHENOME(E);
+    HANDLE_PHENOME(I);
+    HANDLE_PHENOME(O);
+    HANDLE_PHENOME(U);
+    HANDLE_PHENOME(AA);
+    HANDLE_PHENOME(AE);
+    HANDLE_PHENOME(AH);
+    HANDLE_PHENOME(AO);
+    HANDLE_PHENOME(EH);
+    HANDLE_PHENOME(ER);
+    HANDLE_PHENOME(IH);
+    HANDLE_PHENOME(IY);
+    HANDLE_PHENOME(UH);
+    HANDLE_PHENOME(UW);
+    HANDLE_PHENOME(B);
+    HANDLE_PHENOME(D);
+    HANDLE_PHENOME(F);
+    HANDLE_PHENOME(G);
+    HANDLE_PHENOME(J);
+    HANDLE_PHENOME(K);
+    HANDLE_PHENOME(L);
+    HANDLE_PHENOME(M);
+    HANDLE_PHENOME(N);
+    HANDLE_PHENOME(P);
+    HANDLE_PHENOME(R);
+    HANDLE_PHENOME(S);
+    HANDLE_PHENOME(T);
+    HANDLE_PHENOME(V);
+    HANDLE_PHENOME(Z);
+    }
+    throw std::runtime_error{"Invalid phenome: "+std::to_string(static_cast<int>(phenome))};
+#undef HANDLE_PHENOME
+}
+
+al::optional<VMorpherWaveform> WaveformFromEmum(ALenum value)
+{
+    switch(value)
+    {
+    case AL_VOCAL_MORPHER_WAVEFORM_SINUSOID: return al::make_optional(VMorpherWaveform::Sinusoid);
+    case AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE: return al::make_optional(VMorpherWaveform::Triangle);
+    case AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH: return al::make_optional(VMorpherWaveform::Sawtooth);
+    }
+    return al::nullopt;
+}
+ALenum EnumFromWaveform(VMorpherWaveform type)
+{
+    switch(type)
+    {
+    case VMorpherWaveform::Sinusoid: return AL_VOCAL_MORPHER_WAVEFORM_SINUSOID;
+    case VMorpherWaveform::Triangle: return AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE;
+    case VMorpherWaveform::Sawtooth: return AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH;
+    }
+    throw std::runtime_error{"Invalid vocal morpher waveform: " +
+        std::to_string(static_cast<int>(type))};
+}
+
+void Vmorpher_setParami(EffectProps *props, ALenum param, int val)
+{
+    switch(param)
+    {
+    case AL_VOCAL_MORPHER_PHONEMEA:
+        if(auto phenomeopt = PhenomeFromEnum(val))
+            props->Vmorpher.PhonemeA = *phenomeopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-a out of range: 0x%04x", val};
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING:
+        if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING && val <= AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING))
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-a coarse tuning out of range"};
+        props->Vmorpher.PhonemeACoarseTuning = val;
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEB:
+        if(auto phenomeopt = PhenomeFromEnum(val))
+            props->Vmorpher.PhonemeB = *phenomeopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-b out of range: 0x%04x", val};
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING:
+        if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING && val <= AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING))
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-b coarse tuning out of range"};
+        props->Vmorpher.PhonemeBCoarseTuning = val;
+        break;
+
+    case AL_VOCAL_MORPHER_WAVEFORM:
+        if(auto formopt = WaveformFromEmum(val))
+            props->Vmorpher.Waveform = *formopt;
+        else
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher waveform out of range: 0x%04x", val};
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
+            param};
+    }
+}
+void Vmorpher_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x",
+        param};
+}
+void Vmorpher_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_VOCAL_MORPHER_RATE:
+        if(!(val >= AL_VOCAL_MORPHER_MIN_RATE && val <= AL_VOCAL_MORPHER_MAX_RATE))
+            throw effect_exception{AL_INVALID_VALUE, "Vocal morpher rate out of range"};
+        props->Vmorpher.Rate = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
+            param};
+    }
+}
+void Vmorpher_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ Vmorpher_setParamf(props, param, vals[0]); }
+
+void Vmorpher_getParami(const EffectProps *props, ALenum param, int* val)
+{
+    switch(param)
+    {
+    case AL_VOCAL_MORPHER_PHONEMEA:
+        *val = EnumFromPhenome(props->Vmorpher.PhonemeA);
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING:
+        *val = props->Vmorpher.PhonemeACoarseTuning;
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEB:
+        *val = EnumFromPhenome(props->Vmorpher.PhonemeB);
+        break;
+
+    case AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING:
+        *val = props->Vmorpher.PhonemeBCoarseTuning;
+        break;
+
+    case AL_VOCAL_MORPHER_WAVEFORM:
+        *val = EnumFromWaveform(props->Vmorpher.Waveform);
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
+            param};
+    }
+}
+void Vmorpher_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x",
+        param};
+}
+void Vmorpher_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_VOCAL_MORPHER_RATE:
+        *val = props->Vmorpher.Rate;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
+            param};
+    }
+}
+void Vmorpher_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ Vmorpher_getParamf(props, param, vals); }
+
+EffectProps genDefaultProps() noexcept
+{
+    EffectProps props{};
+    props.Vmorpher.Rate                 = AL_VOCAL_MORPHER_DEFAULT_RATE;
+    props.Vmorpher.PhonemeA             = *PhenomeFromEnum(AL_VOCAL_MORPHER_DEFAULT_PHONEMEA);
+    props.Vmorpher.PhonemeB             = *PhenomeFromEnum(AL_VOCAL_MORPHER_DEFAULT_PHONEMEB);
+    props.Vmorpher.PhonemeACoarseTuning = AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING;
+    props.Vmorpher.PhonemeBCoarseTuning = AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING;
+    props.Vmorpher.Waveform             = *WaveformFromEmum(AL_VOCAL_MORPHER_DEFAULT_WAVEFORM);
+    return props;
+}
+
+} // namespace
+
+DEFINE_ALEFFECT_VTABLE(Vmorpher);
+
+const EffectProps VmorpherEffectProps{genDefaultProps()};

Engine/lib/openal-soft/al/error.cpp

@@ -0,0 +1,106 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include <atomic>
+#include <csignal>
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <mutex>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#include "alcontext.h"
+#include "almalloc.h"
+#include "core/except.h"
+#include "core/logging.h"
+#include "opthelpers.h"
+#include "vector.h"
+
+
+bool TrapALError{false};
+
+void ALCcontext::setError(ALenum errorCode, const char *msg, ...)
+{
+    auto message = al::vector<char>(256);
+
+    va_list args, args2;
+    va_start(args, msg);
+    va_copy(args2, args);
+    int msglen{std::vsnprintf(message.data(), message.size(), msg, args)};
+    if(msglen >= 0 && static_cast<size_t>(msglen) >= message.size())
+    {
+        message.resize(static_cast<size_t>(msglen) + 1u);
+        msglen = std::vsnprintf(message.data(), message.size(), msg, args2);
+    }
+    va_end(args2);
+    va_end(args);
+
+    if(msglen >= 0) msg = message.data();
+    else msg = "<internal error constructing message>";
+
+    WARN("Error generated on context %p, code 0x%04x, \"%s\"\n",
+        decltype(std::declval<void*>()){this}, errorCode, msg);
+    if(TrapALError)
+    {
+#ifdef _WIN32
+        /* DebugBreak will cause an exception if there is no debugger */
+        if(IsDebuggerPresent())
+            DebugBreak();
+#elif defined(SIGTRAP)
+        raise(SIGTRAP);
+#endif
+    }
+
+    ALenum curerr{AL_NO_ERROR};
+    mLastError.compare_exchange_strong(curerr, errorCode);
+}
+
+AL_API ALenum AL_APIENTRY alGetError(void)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context)
+    {
+        constexpr ALenum deferror{AL_INVALID_OPERATION};
+        WARN("Querying error state on null context (implicitly 0x%04x)\n", deferror);
+        if(TrapALError)
+        {
+#ifdef _WIN32
+            if(IsDebuggerPresent())
+                DebugBreak();
+#elif defined(SIGTRAP)
+            raise(SIGTRAP);
+#endif
+        }
+        return deferror;
+    }
+
+    return context->mLastError.exchange(AL_NO_ERROR);
+}
+END_API_FUNC

Engine/lib/openal-soft/al/event.cpp

@@ -0,0 +1,223 @@
+
+#include "config.h"
+
+#include "event.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cstring>
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#include "albyte.h"
+#include "alcontext.h"
+#include "almalloc.h"
+#include "async_event.h"
+#include "core/except.h"
+#include "core/logging.h"
+#include "effects/base.h"
+#include "inprogext.h"
+#include "opthelpers.h"
+#include "ringbuffer.h"
+#include "threads.h"
+#include "voice_change.h"
+
+
+static int EventThread(ALCcontext *context)
+{
+    RingBuffer *ring{context->mAsyncEvents.get()};
+    bool quitnow{false};
+    while LIKELY(!quitnow)
+    {
+        auto evt_data = ring->getReadVector().first;
+        if(evt_data.len == 0)
+        {
+            context->mEventSem.wait();
+            continue;
+        }
+
+        std::lock_guard<std::mutex> _{context->mEventCbLock};
+        do {
+            auto *evt_ptr = reinterpret_cast<AsyncEvent*>(evt_data.buf);
+            evt_data.buf += sizeof(AsyncEvent);
+            evt_data.len -= 1;
+
+            AsyncEvent evt{*evt_ptr};
+            al::destroy_at(evt_ptr);
+            ring->readAdvance(1);
+
+            quitnow = evt.EnumType == EventType_KillThread;
+            if UNLIKELY(quitnow) break;
+
+            if(evt.EnumType == EventType_ReleaseEffectState)
+            {
+                evt.u.mEffectState->release();
+                continue;
+            }
+
+            uint enabledevts{context->mEnabledEvts.load(std::memory_order_acquire)};
+            if(!context->mEventCb) continue;
+
+            if(evt.EnumType == EventType_SourceStateChange)
+            {
+                if(!(enabledevts&EventType_SourceStateChange))
+                    continue;
+                ALuint state{};
+                std::string msg{"Source ID " + std::to_string(evt.u.srcstate.id)};
+                msg += " state has changed to ";
+                switch(evt.u.srcstate.state)
+                {
+                case VChangeState::Reset:
+                    msg += "AL_INITIAL";
+                    state = AL_INITIAL;
+                    break;
+                case VChangeState::Stop:
+                    msg += "AL_STOPPED";
+                    state = AL_STOPPED;
+                    break;
+                case VChangeState::Play:
+                    msg += "AL_PLAYING";
+                    state = AL_PLAYING;
+                    break;
+                case VChangeState::Pause:
+                    msg += "AL_PAUSED";
+                    state = AL_PAUSED;
+                    break;
+                /* Shouldn't happen */
+                case VChangeState::Restart:
+                    break;
+                }
+                context->mEventCb(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT, evt.u.srcstate.id,
+                    state, static_cast<ALsizei>(msg.length()), msg.c_str(), context->mEventParam);
+            }
+            else if(evt.EnumType == EventType_BufferCompleted)
+            {
+                if(!(enabledevts&EventType_BufferCompleted))
+                    continue;
+                std::string msg{std::to_string(evt.u.bufcomp.count)};
+                if(evt.u.bufcomp.count == 1) msg += " buffer completed";
+                else msg += " buffers completed";
+                context->mEventCb(AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT, evt.u.bufcomp.id,
+                    evt.u.bufcomp.count, static_cast<ALsizei>(msg.length()), msg.c_str(),
+                    context->mEventParam);
+            }
+            else if(evt.EnumType == EventType_Disconnected)
+            {
+                if(!(enabledevts&EventType_Disconnected))
+                    continue;
+                context->mEventCb(AL_EVENT_TYPE_DISCONNECTED_SOFT, 0, 0,
+                    static_cast<ALsizei>(strlen(evt.u.disconnect.msg)), evt.u.disconnect.msg,
+                    context->mEventParam);
+            }
+        } while(evt_data.len != 0);
+    }
+    return 0;
+}
+
+void StartEventThrd(ALCcontext *ctx)
+{
+    try {
+        ctx->mEventThread = std::thread{EventThread, ctx};
+    }
+    catch(std::exception& e) {
+        ERR("Failed to start event thread: %s\n", e.what());
+    }
+    catch(...) {
+        ERR("Failed to start event thread! Expect problems.\n");
+    }
+}
+
+void StopEventThrd(ALCcontext *ctx)
+{
+    RingBuffer *ring{ctx->mAsyncEvents.get()};
+    auto evt_data = ring->getWriteVector().first;
+    if(evt_data.len == 0)
+    {
+        do {
+            std::this_thread::yield();
+            evt_data = ring->getWriteVector().first;
+        } while(evt_data.len == 0);
+    }
+    ::new(evt_data.buf) AsyncEvent{EventType_KillThread};
+    ring->writeAdvance(1);
+
+    ctx->mEventSem.post();
+    if(ctx->mEventThread.joinable())
+        ctx->mEventThread.join();
+}
+
+AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(count < 0) context->setError(AL_INVALID_VALUE, "Controlling %d events", count);
+    if(count <= 0) return;
+    if(!types) SETERR_RETURN(context, AL_INVALID_VALUE,, "NULL pointer");
+
+    uint flags{0};
+    const ALenum *types_end = types+count;
+    auto bad_type = std::find_if_not(types, types_end,
+        [&flags](ALenum type) noexcept -> bool
+        {
+            if(type == AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT)
+                flags |= EventType_BufferCompleted;
+            else if(type == AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT)
+                flags |= EventType_SourceStateChange;
+            else if(type == AL_EVENT_TYPE_DISCONNECTED_SOFT)
+                flags |= EventType_Disconnected;
+            else
+                return false;
+            return true;
+        }
+    );
+    if(bad_type != types_end)
+        SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid event type 0x%04x", *bad_type);
+
+    if(enable)
+    {
+        uint enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)};
+        while(context->mEnabledEvts.compare_exchange_weak(enabledevts, enabledevts|flags,
+            std::memory_order_acq_rel, std::memory_order_acquire) == 0)
+        {
+            /* enabledevts is (re-)filled with the current value on failure, so
+             * just try again.
+             */
+        }
+    }
+    else
+    {
+        uint enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)};
+        while(context->mEnabledEvts.compare_exchange_weak(enabledevts, enabledevts&~flags,
+            std::memory_order_acq_rel, std::memory_order_acquire) == 0)
+        {
+        }
+        /* Wait to ensure the event handler sees the changed flags before
+         * returning.
+         */
+        std::lock_guard<std::mutex>{context->mEventCbLock};
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    std::lock_guard<std::mutex> __{context->mEventCbLock};
+    context->mEventCb = callback;
+    context->mEventParam = userParam;
+}
+END_API_FUNC

Engine/lib/openal-soft/al/event.h

@@ -0,0 +1,9 @@
+#ifndef AL_EVENT_H
+#define AL_EVENT_H
+
+struct ALCcontext;
+
+void StartEventThrd(ALCcontext *ctx);
+void StopEventThrd(ALCcontext *ctx);
+
+#endif

Engine/lib/openal-soft/al/extension.cpp

@@ -0,0 +1,79 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <cctype>
+#include <cstdlib>
+#include <cstring>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#include "alcontext.h"
+#include "alstring.h"
+#include "core/except.h"
+#include "opthelpers.h"
+
+
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extName)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return AL_FALSE;
+
+    if(!extName)
+        SETERR_RETURN(context, AL_INVALID_VALUE, AL_FALSE, "NULL pointer");
+
+    size_t len{strlen(extName)};
+    const char *ptr{context->mExtensionList};
+    while(ptr && *ptr)
+    {
+        if(al::strncasecmp(ptr, extName, len) == 0 && (ptr[len] == '\0' || isspace(ptr[len])))
+            return AL_TRUE;
+
+        if((ptr=strchr(ptr, ' ')) != nullptr)
+        {
+            do {
+                ++ptr;
+            } while(isspace(*ptr));
+        }
+    }
+
+    return AL_FALSE;
+}
+END_API_FUNC
+
+
+AL_API ALvoid* AL_APIENTRY alGetProcAddress(const ALchar *funcName)
+START_API_FUNC
+{
+    if(!funcName) return nullptr;
+    return alcGetProcAddress(nullptr, funcName);
+}
+END_API_FUNC
+
+AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *enumName)
+START_API_FUNC
+{
+    if(!enumName) return static_cast<ALenum>(0);
+    return alcGetEnumValue(nullptr, enumName);
+}
+END_API_FUNC

Engine/lib/openal-soft/al/filter.cpp

@@ -0,0 +1,715 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "filter.h"
+
+#include <algorithm>
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <numeric>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/efx.h"
+
+#include "albit.h"
+#include "alcmain.h"
+#include "alcontext.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "core/except.h"
+#include "opthelpers.h"
+#include "vector.h"
+
+
+namespace {
+
+class filter_exception final : public al::base_exception {
+    ALenum mErrorCode;
+
+public:
+    [[gnu::format(printf, 3, 4)]]
+    filter_exception(ALenum code, const char *msg, ...) : mErrorCode{code}
+    {
+        std::va_list args;
+        va_start(args, msg);
+        setMessage(msg, args);
+        va_end(args);
+    }
+    ALenum errorCode() const noexcept { return mErrorCode; }
+};
+
+#define FILTER_MIN_GAIN 0.0f
+#define FILTER_MAX_GAIN 4.0f /* +12dB */
+
+#define DEFINE_ALFILTER_VTABLE(T)                                  \
+const ALfilter::Vtable T##_vtable = {                              \
+    T##_setParami, T##_setParamiv, T##_setParamf, T##_setParamfv,  \
+    T##_getParami, T##_getParamiv, T##_getParamf, T##_getParamfv,  \
+}
+
+void ALlowpass_setParami(ALfilter*, ALenum param, int)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param}; }
+void ALlowpass_setParamiv(ALfilter*, ALenum param, const int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x",
+        param};
+}
+void ALlowpass_setParamf(ALfilter *filter, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_LOWPASS_GAIN:
+        if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
+            throw filter_exception{AL_INVALID_VALUE, "Low-pass gain %f out of range", val};
+        filter->Gain = val;
+        break;
+
+    case AL_LOWPASS_GAINHF:
+        if(!(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF))
+            throw filter_exception{AL_INVALID_VALUE, "Low-pass gainhf %f out of range", val};
+        filter->GainHF = val;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param};
+    }
+}
+void ALlowpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
+{ ALlowpass_setParamf(filter, param, vals[0]); }
+
+void ALlowpass_getParami(const ALfilter*, ALenum param, int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param}; }
+void ALlowpass_getParamiv(const ALfilter*, ALenum param, int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x",
+        param};
+}
+void ALlowpass_getParamf(const ALfilter *filter, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_LOWPASS_GAIN:
+        *val = filter->Gain;
+        break;
+
+    case AL_LOWPASS_GAINHF:
+        *val = filter->GainHF;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param};
+    }
+}
+void ALlowpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALlowpass_getParamf(filter, param, vals); }
+
+DEFINE_ALFILTER_VTABLE(ALlowpass);
+
+
+void ALhighpass_setParami(ALfilter*, ALenum param, int)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param}; }
+void ALhighpass_setParamiv(ALfilter*, ALenum param, const int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x",
+        param};
+}
+void ALhighpass_setParamf(ALfilter *filter, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_HIGHPASS_GAIN:
+        if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
+            throw filter_exception{AL_INVALID_VALUE, "High-pass gain %f out of range", val};
+        filter->Gain = val;
+        break;
+
+    case AL_HIGHPASS_GAINLF:
+        if(!(val >= AL_HIGHPASS_MIN_GAINLF && val <= AL_HIGHPASS_MAX_GAINLF))
+            throw filter_exception{AL_INVALID_VALUE, "High-pass gainlf %f out of range", val};
+        filter->GainLF = val;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param};
+    }
+}
+void ALhighpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
+{ ALhighpass_setParamf(filter, param, vals[0]); }
+
+void ALhighpass_getParami(const ALfilter*, ALenum param, int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param}; }
+void ALhighpass_getParamiv(const ALfilter*, ALenum param, int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x",
+        param};
+}
+void ALhighpass_getParamf(const ALfilter *filter, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_HIGHPASS_GAIN:
+        *val = filter->Gain;
+        break;
+
+    case AL_HIGHPASS_GAINLF:
+        *val = filter->GainLF;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param};
+    }
+}
+void ALhighpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALhighpass_getParamf(filter, param, vals); }
+
+DEFINE_ALFILTER_VTABLE(ALhighpass);
+
+
+void ALbandpass_setParami(ALfilter*, ALenum param, int)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param}; }
+void ALbandpass_setParamiv(ALfilter*, ALenum param, const int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x",
+        param};
+}
+void ALbandpass_setParamf(ALfilter *filter, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_BANDPASS_GAIN:
+        if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
+            throw filter_exception{AL_INVALID_VALUE, "Band-pass gain %f out of range", val};
+        filter->Gain = val;
+        break;
+
+    case AL_BANDPASS_GAINHF:
+        if(!(val >= AL_BANDPASS_MIN_GAINHF && val <= AL_BANDPASS_MAX_GAINHF))
+            throw filter_exception{AL_INVALID_VALUE, "Band-pass gainhf %f out of range", val};
+        filter->GainHF = val;
+        break;
+
+    case AL_BANDPASS_GAINLF:
+        if(!(val >= AL_BANDPASS_MIN_GAINLF && val <= AL_BANDPASS_MAX_GAINLF))
+            throw filter_exception{AL_INVALID_VALUE, "Band-pass gainlf %f out of range", val};
+        filter->GainLF = val;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param};
+    }
+}
+void ALbandpass_setParamfv(ALfilter *filter, ALenum param, const float *vals)
+{ ALbandpass_setParamf(filter, param, vals[0]); }
+
+void ALbandpass_getParami(const ALfilter*, ALenum param, int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param}; }
+void ALbandpass_getParamiv(const ALfilter*, ALenum param, int*)
+{
+    throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x",
+        param};
+}
+void ALbandpass_getParamf(const ALfilter *filter, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_BANDPASS_GAIN:
+        *val = filter->Gain;
+        break;
+
+    case AL_BANDPASS_GAINHF:
+        *val = filter->GainHF;
+        break;
+
+    case AL_BANDPASS_GAINLF:
+        *val = filter->GainLF;
+        break;
+
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param};
+    }
+}
+void ALbandpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALbandpass_getParamf(filter, param, vals); }
+
+DEFINE_ALFILTER_VTABLE(ALbandpass);
+
+
+void ALnullfilter_setParami(ALfilter*, ALenum param, int)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_setParamiv(ALfilter*, ALenum param, const int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_setParamf(ALfilter*, ALenum param, float)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_setParamfv(ALfilter*, ALenum param, const float*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+
+void ALnullfilter_getParami(const ALfilter*, ALenum param, int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_getParamiv(const ALfilter*, ALenum param, int*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_getParamf(const ALfilter*, ALenum param, float*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+void ALnullfilter_getParamfv(const ALfilter*, ALenum param, float*)
+{ throw filter_exception{AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param}; }
+
+DEFINE_ALFILTER_VTABLE(ALnullfilter);
+
+
+void InitFilterParams(ALfilter *filter, ALenum type)
+{
+    if(type == AL_FILTER_LOWPASS)
+    {
+        filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
+        filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = 1.0f;
+        filter->LFReference = HIGHPASSFREQREF;
+        filter->vtab = &ALlowpass_vtable;
+    }
+    else if(type == AL_FILTER_HIGHPASS)
+    {
+        filter->Gain = AL_HIGHPASS_DEFAULT_GAIN;
+        filter->GainHF = 1.0f;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = AL_HIGHPASS_DEFAULT_GAINLF;
+        filter->LFReference = HIGHPASSFREQREF;
+        filter->vtab = &ALhighpass_vtable;
+    }
+    else if(type == AL_FILTER_BANDPASS)
+    {
+        filter->Gain = AL_BANDPASS_DEFAULT_GAIN;
+        filter->GainHF = AL_BANDPASS_DEFAULT_GAINHF;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = AL_BANDPASS_DEFAULT_GAINLF;
+        filter->LFReference = HIGHPASSFREQREF;
+        filter->vtab = &ALbandpass_vtable;
+    }
+    else
+    {
+        filter->Gain = 1.0f;
+        filter->GainHF = 1.0f;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = 1.0f;
+        filter->LFReference = HIGHPASSFREQREF;
+        filter->vtab = &ALnullfilter_vtable;
+    }
+    filter->type = type;
+}
+
+bool EnsureFilters(ALCdevice *device, size_t needed)
+{
+    size_t count{std::accumulate(device->FilterList.cbegin(), device->FilterList.cend(), size_t{0},
+        [](size_t cur, const FilterSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
+
+    while(needed > count)
+    {
+        if UNLIKELY(device->FilterList.size() >= 1<<25)
+            return false;
+
+        device->FilterList.emplace_back();
+        auto sublist = device->FilterList.end() - 1;
+        sublist->FreeMask = ~0_u64;
+        sublist->Filters = static_cast<ALfilter*>(al_calloc(alignof(ALfilter), sizeof(ALfilter)*64));
+        if UNLIKELY(!sublist->Filters)
+        {
+            device->FilterList.pop_back();
+            return false;
+        }
+        count += 64;
+    }
+    return true;
+}
+
+
+ALfilter *AllocFilter(ALCdevice *device)
+{
+    auto sublist = std::find_if(device->FilterList.begin(), device->FilterList.end(),
+        [](const FilterSubList &entry) noexcept -> bool
+        { return entry.FreeMask != 0; }
+    );
+    auto lidx = static_cast<ALuint>(std::distance(device->FilterList.begin(), sublist));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+
+    ALfilter *filter{::new(sublist->Filters + slidx) ALfilter{}};
+    InitFilterParams(filter, AL_FILTER_NULL);
+
+    /* Add 1 to avoid filter ID 0. */
+    filter->id = ((lidx<<6) | slidx) + 1;
+
+    sublist->FreeMask &= ~(1_u64 << slidx);
+
+    return filter;
+}
+
+void FreeFilter(ALCdevice *device, ALfilter *filter)
+{
+    const ALuint id{filter->id - 1};
+    const size_t lidx{id >> 6};
+    const ALuint slidx{id & 0x3f};
+
+    al::destroy_at(filter);
+
+    device->FilterList[lidx].FreeMask |= 1_u64 << slidx;
+}
+
+
+inline ALfilter *LookupFilter(ALCdevice *device, ALuint id)
+{
+    const size_t lidx{(id-1) >> 6};
+    const ALuint slidx{(id-1) & 0x3f};
+
+    if UNLIKELY(lidx >= device->FilterList.size())
+        return nullptr;
+    FilterSubList &sublist = device->FilterList[lidx];
+    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+        return nullptr;
+    return sublist.Filters + slidx;
+}
+
+} // namespace
+
+AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if UNLIKELY(n < 0)
+        context->setError(AL_INVALID_VALUE, "Generating %d filters", n);
+    if UNLIKELY(n <= 0) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->EffectLock};
+    if(!EnsureFilters(device, static_cast<ALuint>(n)))
+    {
+        context->setError(AL_OUT_OF_MEMORY, "Failed to allocate %d filter%s", n, (n==1)?"":"s");
+        return;
+    }
+
+    if LIKELY(n == 1)
+    {
+        /* Special handling for the easy and normal case. */
+        ALfilter *filter{AllocFilter(device)};
+        if(filter) filters[0] = filter->id;
+    }
+    else
+    {
+        /* Store the allocated buffer IDs in a separate local list, to avoid
+         * modifying the user storage in case of failure.
+         */
+        al::vector<ALuint> ids;
+        ids.reserve(static_cast<ALuint>(n));
+        do {
+            ALfilter *filter{AllocFilter(device)};
+            ids.emplace_back(filter->id);
+        } while(--n);
+        std::copy(ids.begin(), ids.end(), filters);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if UNLIKELY(n < 0)
+        context->setError(AL_INVALID_VALUE, "Deleting %d filters", n);
+    if UNLIKELY(n <= 0) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    /* First try to find any filters that are invalid. */
+    auto validate_filter = [device](const ALuint fid) -> bool
+    { return !fid || LookupFilter(device, fid) != nullptr; };
+
+    const ALuint *filters_end = filters + n;
+    auto invflt = std::find_if_not(filters, filters_end, validate_filter);
+    if UNLIKELY(invflt != filters_end)
+    {
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", *invflt);
+        return;
+    }
+
+    /* All good. Delete non-0 filter IDs. */
+    auto delete_filter = [device](const ALuint fid) -> void
+    {
+        ALfilter *filter{fid ? LookupFilter(device, fid) : nullptr};
+        if(filter) FreeFilter(device, filter);
+    };
+    std::for_each(filters, filters_end, delete_filter);
+}
+END_API_FUNC
+
+AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if LIKELY(context)
+    {
+        ALCdevice *device{context->mDevice.get()};
+        std::lock_guard<std::mutex> _{device->FilterLock};
+        if(!filter || LookupFilter(device, filter))
+            return AL_TRUE;
+    }
+    return AL_FALSE;
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else
+    {
+        if(param == AL_FILTER_TYPE)
+        {
+            if(value == AL_FILTER_NULL || value == AL_FILTER_LOWPASS
+                || value == AL_FILTER_HIGHPASS || value == AL_FILTER_BANDPASS)
+                InitFilterParams(alfilt, value);
+            else
+                context->setError(AL_INVALID_VALUE, "Invalid filter type 0x%04x", value);
+        }
+        else try
+        {
+            /* Call the appropriate handler */
+            alfilt->setParami(param, value);
+        }
+        catch(filter_exception &e) {
+            context->setError(e.errorCode(), "%s", e.what());
+        }
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_FILTER_TYPE:
+        alFilteri(filter, param, values[0]);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->setParamiv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->setParamf(param, value);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->setParamfv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else
+    {
+        if(param == AL_FILTER_TYPE)
+            *value = alfilt->type;
+        else try
+        {
+            /* Call the appropriate handler */
+            alfilt->getParami(param, value);
+        }
+        catch(filter_exception &e) {
+            context->setError(e.errorCode(), "%s", e.what());
+        }
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_FILTER_TYPE:
+        alGetFilteri(filter, param, values);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->getParamiv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->getParamf(param, value);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
+
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if UNLIKELY(!alfilt)
+        context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
+    else try
+    {
+        /* Call the appropriate handler */
+        alfilt->getParamfv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
+    }
+}
+END_API_FUNC
+
+
+FilterSubList::~FilterSubList()
+{
+    uint64_t usemask{~FreeMask};
+    while(usemask)
+    {
+        const int idx{al::countr_zero(usemask)};
+        al::destroy_at(Filters+idx);
+        usemask &= ~(1_u64 << idx);
+    }
+    FreeMask = ~usemask;
+    al_free(Filters);
+    Filters = nullptr;
+}

Engine/lib/openal-soft/al/filter.h

@@ -0,0 +1,52 @@
+#ifndef AL_FILTER_H
+#define AL_FILTER_H
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "almalloc.h"
+
+
+#define LOWPASSFREQREF  5000.0f
+#define HIGHPASSFREQREF  250.0f
+
+
+struct ALfilter {
+    ALenum type{AL_FILTER_NULL};
+
+    float Gain{1.0f};
+    float GainHF{1.0f};
+    float HFReference{LOWPASSFREQREF};
+    float GainLF{1.0f};
+    float LFReference{HIGHPASSFREQREF};
+
+    struct Vtable {
+        void (*const setParami )(ALfilter *filter, ALenum param, int val);
+        void (*const setParamiv)(ALfilter *filter, ALenum param, const int *vals);
+        void (*const setParamf )(ALfilter *filter, ALenum param, float val);
+        void (*const setParamfv)(ALfilter *filter, ALenum param, const float *vals);
+
+        void (*const getParami )(const ALfilter *filter, ALenum param, int *val);
+        void (*const getParamiv)(const ALfilter *filter, ALenum param, int *vals);
+        void (*const getParamf )(const ALfilter *filter, ALenum param, float *val);
+        void (*const getParamfv)(const ALfilter *filter, ALenum param, float *vals);
+    };
+    const Vtable *vtab{nullptr};
+
+    /* Self ID */
+    ALuint id{0};
+
+    void setParami(ALenum param, int value) { vtab->setParami(this, param, value); }
+    void setParamiv(ALenum param, const int *values) { vtab->setParamiv(this, param, values); }
+    void setParamf(ALenum param, float value) { vtab->setParamf(this, param, value); }
+    void setParamfv(ALenum param, const float *values) { vtab->setParamfv(this, param, values); }
+    void getParami(ALenum param, int *value) const { vtab->getParami(this, param, value); }
+    void getParamiv(ALenum param, int *values) const { vtab->getParamiv(this, param, values); }
+    void getParamf(ALenum param, float *value) const { vtab->getParamf(this, param, value); }
+    void getParamfv(ALenum param, float *values) const { vtab->getParamfv(this, param, values); }
+
+    DISABLE_ALLOC()
+};
+
+#endif

Engine/lib/openal-soft/al/listener.cpp

@@ -0,0 +1,452 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "listener.h"
+
+#include <cmath>
+#include <mutex>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/efx.h"
+
+#include "alcontext.h"
+#include "almalloc.h"
+#include "atomic.h"
+#include "core/except.h"
+#include "opthelpers.h"
+
+
+#define DO_UPDATEPROPS() do {                                                 \
+    if(!context->mDeferUpdates.load(std::memory_order_acquire))               \
+        UpdateListenerProps(context.get());                                   \
+    else                                                                      \
+        listener.PropsClean.clear(std::memory_order_release);                 \
+} while(0)
+
+
+AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(param)
+    {
+    case AL_GAIN:
+        if(!(value >= 0.0f && std::isfinite(value)))
+            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener gain out of range");
+        listener.Gain = value;
+        DO_UPDATEPROPS();
+        break;
+
+    case AL_METERS_PER_UNIT:
+        if(!(value >= AL_MIN_METERS_PER_UNIT && value <= AL_MAX_METERS_PER_UNIT))
+            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener meters per unit out of range");
+        listener.mMetersPerUnit = value;
+        DO_UPDATEPROPS();
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener float property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(param)
+    {
+    case AL_POSITION:
+        if(!(std::isfinite(value1) && std::isfinite(value2) && std::isfinite(value3)))
+            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener position out of range");
+        listener.Position[0] = value1;
+        listener.Position[1] = value2;
+        listener.Position[2] = value3;
+        DO_UPDATEPROPS();
+        break;
+
+    case AL_VELOCITY:
+        if(!(std::isfinite(value1) && std::isfinite(value2) && std::isfinite(value3)))
+            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener velocity out of range");
+        listener.Velocity[0] = value1;
+        listener.Velocity[1] = value2;
+        listener.Velocity[2] = value3;
+        DO_UPDATEPROPS();
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener 3-float property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(param)
+        {
+        case AL_GAIN:
+        case AL_METERS_PER_UNIT:
+            alListenerf(param, values[0]);
+            return;
+
+        case AL_POSITION:
+        case AL_VELOCITY:
+            alListener3f(param, values[0], values[1], values[2]);
+            return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!values) SETERR_RETURN(context, AL_INVALID_VALUE,, "NULL pointer");
+    switch(param)
+    {
+    case AL_ORIENTATION:
+        if(!(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]) &&
+             std::isfinite(values[3]) && std::isfinite(values[4]) && std::isfinite(values[5])))
+            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener orientation out of range");
+        /* AT then UP */
+        listener.OrientAt[0] = values[0];
+        listener.OrientAt[1] = values[1];
+        listener.OrientAt[2] = values[2];
+        listener.OrientUp[0] = values[3];
+        listener.OrientUp[1] = values[4];
+        listener.OrientUp[2] = values[5];
+        DO_UPDATEPROPS();
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener float-vector property");
+    }
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alListeneri(ALenum param, ALint /*value*/)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(param)
+    {
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener integer property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alListener3f(param, static_cast<ALfloat>(value1), static_cast<ALfloat>(value2), static_cast<ALfloat>(value3));
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(param)
+    {
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener 3-integer property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        ALfloat fvals[6];
+        switch(param)
+        {
+        case AL_POSITION:
+        case AL_VELOCITY:
+            alListener3f(param, static_cast<ALfloat>(values[0]), static_cast<ALfloat>(values[1]), static_cast<ALfloat>(values[2]));
+            return;
+
+        case AL_ORIENTATION:
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
+            fvals[3] = static_cast<ALfloat>(values[3]);
+            fvals[4] = static_cast<ALfloat>(values[4]);
+            fvals[5] = static_cast<ALfloat>(values[5]);
+            alListenerfv(param, fvals);
+            return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener integer-vector property");
+    }
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!value)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_GAIN:
+        *value = listener.Gain;
+        break;
+
+    case AL_METERS_PER_UNIT:
+        *value = listener.mMetersPerUnit;
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener float property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!value1 || !value2 || !value3)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_POSITION:
+        *value1 = listener.Position[0];
+        *value2 = listener.Position[1];
+        *value3 = listener.Position[2];
+        break;
+
+    case AL_VELOCITY:
+        *value1 = listener.Velocity[0];
+        *value2 = listener.Velocity[1];
+        *value3 = listener.Velocity[2];
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener 3-float property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_GAIN:
+    case AL_METERS_PER_UNIT:
+        alGetListenerf(param, values);
+        return;
+
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alGetListener3f(param, values+0, values+1, values+2);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_ORIENTATION:
+        // AT then UP
+        values[0] = listener.OrientAt[0];
+        values[1] = listener.OrientAt[1];
+        values[2] = listener.OrientAt[2];
+        values[3] = listener.OrientUp[0];
+        values[4] = listener.OrientUp[1];
+        values[5] = listener.OrientUp[2];
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener float-vector property");
+    }
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!value)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener integer property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!value1 || !value2 || !value3)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_POSITION:
+        *value1 = static_cast<ALint>(listener.Position[0]);
+        *value2 = static_cast<ALint>(listener.Position[1]);
+        *value3 = static_cast<ALint>(listener.Position[2]);
+        break;
+
+    case AL_VELOCITY:
+        *value1 = static_cast<ALint>(listener.Velocity[0]);
+        *value2 = static_cast<ALint>(listener.Velocity[1]);
+        *value3 = static_cast<ALint>(listener.Velocity[2]);
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener 3-integer property");
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint* values)
+START_API_FUNC
+{
+    switch(param)
+    {
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alGetListener3i(param, values+0, values+1, values+2);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    ALlistener &listener = context->mListener;
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_ORIENTATION:
+        // AT then UP
+        values[0] = static_cast<ALint>(listener.OrientAt[0]);
+        values[1] = static_cast<ALint>(listener.OrientAt[1]);
+        values[2] = static_cast<ALint>(listener.OrientAt[2]);
+        values[3] = static_cast<ALint>(listener.OrientUp[0]);
+        values[4] = static_cast<ALint>(listener.OrientUp[1]);
+        values[5] = static_cast<ALint>(listener.OrientUp[2]);
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid listener integer-vector property");
+    }
+}
+END_API_FUNC
+
+
+void UpdateListenerProps(ALCcontext *context)
+{
+    /* Get an unused proprty container, or allocate a new one as needed. */
+    ListenerProps *props{context->mFreeListenerProps.load(std::memory_order_acquire)};
+    if(!props)
+        props = new ListenerProps{};
+    else
+    {
+        ListenerProps *next;
+        do {
+            next = props->next.load(std::memory_order_relaxed);
+        } while(context->mFreeListenerProps.compare_exchange_weak(props, next,
+                std::memory_order_seq_cst, std::memory_order_acquire) == 0);
+    }
+
+    /* Copy in current property values. */
+    ALlistener &listener = context->mListener;
+    props->Position = listener.Position;
+    props->Velocity = listener.Velocity;
+    props->OrientAt = listener.OrientAt;
+    props->OrientUp = listener.OrientUp;
+    props->Gain = listener.Gain;
+    props->MetersPerUnit = listener.mMetersPerUnit;
+
+    /* Set the new container for updating internal parameters. */
+    props = context->mParams.ListenerUpdate.exchange(props, std::memory_order_acq_rel);
+    if(props)
+    {
+        /* If there was an unused update container, put it back in the
+         * freelist.
+         */
+        AtomicReplaceHead(context->mFreeListenerProps, props);
+    }
+}

Engine/lib/openal-soft/al/listener.h

@@ -0,0 +1,31 @@
+#ifndef AL_LISTENER_H
+#define AL_LISTENER_H
+
+#include <array>
+#include <atomic>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/efx.h"
+
+#include "almalloc.h"
+
+
+struct ALlistener {
+    std::array<float,3> Position{{0.0f, 0.0f, 0.0f}};
+    std::array<float,3> Velocity{{0.0f, 0.0f, 0.0f}};
+    std::array<float,3> OrientAt{{0.0f, 0.0f, -1.0f}};
+    std::array<float,3> OrientUp{{0.0f, 1.0f, 0.0f}};
+    float Gain{1.0f};
+    float mMetersPerUnit{AL_DEFAULT_METERS_PER_UNIT};
+
+    std::atomic_flag PropsClean;
+
+    ALlistener() { PropsClean.test_and_set(std::memory_order_relaxed); }
+
+    DISABLE_ALLOC()
+};
+
+void UpdateListenerProps(ALCcontext *context);
+
+#endif

Engine/lib/openal-soft/al/source.h

@@ -0,0 +1,134 @@
+#ifndef AL_SOURCE_H
+#define AL_SOURCE_H
+
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <deque>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+#include "alcontext.h"
+#include "aldeque.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alu.h"
+#include "math_defs.h"
+#include "vector.h"
+#include "voice.h"
+
+struct ALbuffer;
+struct ALeffectslot;
+
+
+#define DEFAULT_SENDS  2
+
+#define INVALID_VOICE_IDX static_cast<ALuint>(-1)
+
+struct ALbufferQueueItem : public VoiceBufferItem {
+    ALbuffer *mBuffer{nullptr};
+
+    DISABLE_ALLOC()
+};
+
+
+struct ALsource {
+    /** Source properties. */
+    float Pitch{1.0f};
+    float Gain{1.0f};
+    float OuterGain{0.0f};
+    float MinGain{0.0f};
+    float MaxGain{1.0f};
+    float InnerAngle{360.0f};
+    float OuterAngle{360.0f};
+    float RefDistance{1.0f};
+    float MaxDistance{std::numeric_limits<float>::max()};
+    float RolloffFactor{1.0f};
+    std::array<float,3> Position{{0.0f, 0.0f, 0.0f}};
+    std::array<float,3> Velocity{{0.0f, 0.0f, 0.0f}};
+    std::array<float,3> Direction{{0.0f, 0.0f, 0.0f}};
+    std::array<float,3> OrientAt{{0.0f, 0.0f, -1.0f}};
+    std::array<float,3> OrientUp{{0.0f, 1.0f,  0.0f}};
+    bool HeadRelative{false};
+    bool Looping{false};
+    DistanceModel mDistanceModel{DistanceModel::Default};
+    Resampler mResampler{ResamplerDefault};
+    DirectMode DirectChannels{DirectMode::Off};
+    SpatializeMode mSpatialize{SpatializeMode::Auto};
+
+    bool DryGainHFAuto{true};
+    bool WetGainAuto{true};
+    bool WetGainHFAuto{true};
+    float OuterGainHF{1.0f};
+
+    float AirAbsorptionFactor{0.0f};
+    float RoomRolloffFactor{0.0f};
+    float DopplerFactor{1.0f};
+
+    /* NOTE: Stereo pan angles are specified in radians, counter-clockwise
+     * rather than clockwise.
+     */
+    std::array<float,2> StereoPan{{Deg2Rad( 30.0f), Deg2Rad(-30.0f)}};
+
+    float Radius{0.0f};
+
+    /** Direct filter and auxiliary send info. */
+    struct {
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
+    } Direct;
+    struct SendData {
+        ALeffectslot *Slot;
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
+    };
+    std::array<SendData,MAX_SENDS> Send;
+
+    /**
+     * Last user-specified offset, and the offset type (bytes, samples, or
+     * seconds).
+     */
+    double Offset{0.0};
+    ALenum OffsetType{AL_NONE};
+
+    /** Source type (static, streaming, or undetermined) */
+    ALenum SourceType{AL_UNDETERMINED};
+
+    /** Source state (initial, playing, paused, or stopped) */
+    ALenum state{AL_INITIAL};
+
+    /** Source Buffer Queue head. */
+    al::deque<ALbufferQueueItem> mQueue;
+
+    std::atomic_flag PropsClean;
+
+    /* Index into the context's Voices array. Lazily updated, only checked and
+     * reset when looking up the voice.
+     */
+    ALuint VoiceIdx{INVALID_VOICE_IDX};
+
+    /** Self ID */
+    ALuint id{0};
+
+
+    ALsource();
+    ~ALsource();
+
+    ALsource(const ALsource&) = delete;
+    ALsource& operator=(const ALsource&) = delete;
+
+    DISABLE_ALLOC()
+};
+
+void UpdateAllSourceProps(ALCcontext *context);
+
+#endif

Engine/lib/openal-soft/al/state.cpp

@@ -0,0 +1,893 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "version.h"
+
+#include <atomic>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <mutex>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "alcontext.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "alu.h"
+#include "atomic.h"
+#include "core/except.h"
+#include "event.h"
+#include "inprogext.h"
+#include "opthelpers.h"
+#include "strutils.h"
+#include "voice.h"
+
+
+namespace {
+
+constexpr ALchar alVendor[] = "OpenAL Community";
+constexpr ALchar alVersion[] = "1.1 ALSOFT " ALSOFT_VERSION;
+constexpr ALchar alRenderer[] = "OpenAL Soft";
+
+// Error Messages
+constexpr ALchar alNoError[] = "No Error";
+constexpr ALchar alErrInvalidName[] = "Invalid Name";
+constexpr ALchar alErrInvalidEnum[] = "Invalid Enum";
+constexpr ALchar alErrInvalidValue[] = "Invalid Value";
+constexpr ALchar alErrInvalidOp[] = "Invalid Operation";
+constexpr ALchar alErrOutOfMemory[] = "Out of Memory";
+
+/* Resampler strings */
+template<Resampler rtype> struct ResamplerName { };
+template<> struct ResamplerName<Resampler::Point>
+{ static constexpr const ALchar *Get() noexcept { return "Nearest"; } };
+template<> struct ResamplerName<Resampler::Linear>
+{ static constexpr const ALchar *Get() noexcept { return "Linear"; } };
+template<> struct ResamplerName<Resampler::Cubic>
+{ static constexpr const ALchar *Get() noexcept { return "Cubic"; } };
+template<> struct ResamplerName<Resampler::FastBSinc12>
+{ static constexpr const ALchar *Get() noexcept { return "11th order Sinc (fast)"; } };
+template<> struct ResamplerName<Resampler::BSinc12>
+{ static constexpr const ALchar *Get() noexcept { return "11th order Sinc"; } };
+template<> struct ResamplerName<Resampler::FastBSinc24>
+{ static constexpr const ALchar *Get() noexcept { return "23rd order Sinc (fast)"; } };
+template<> struct ResamplerName<Resampler::BSinc24>
+{ static constexpr const ALchar *Get() noexcept { return "23rd order Sinc"; } };
+
+const ALchar *GetResamplerName(const Resampler rtype)
+{
+#define HANDLE_RESAMPLER(r) case r: return ResamplerName<r>::Get()
+    switch(rtype)
+    {
+    HANDLE_RESAMPLER(Resampler::Point);
+    HANDLE_RESAMPLER(Resampler::Linear);
+    HANDLE_RESAMPLER(Resampler::Cubic);
+    HANDLE_RESAMPLER(Resampler::FastBSinc12);
+    HANDLE_RESAMPLER(Resampler::BSinc12);
+    HANDLE_RESAMPLER(Resampler::FastBSinc24);
+    HANDLE_RESAMPLER(Resampler::BSinc24);
+    }
+#undef HANDLE_RESAMPLER
+    /* Should never get here. */
+    throw std::runtime_error{"Unexpected resampler index"};
+}
+
+al::optional<DistanceModel> DistanceModelFromALenum(ALenum model)
+{
+    switch(model)
+    {
+    case AL_NONE: return al::make_optional(DistanceModel::Disable);
+    case AL_INVERSE_DISTANCE: return al::make_optional(DistanceModel::Inverse);
+    case AL_INVERSE_DISTANCE_CLAMPED: return al::make_optional(DistanceModel::InverseClamped);
+    case AL_LINEAR_DISTANCE: return al::make_optional(DistanceModel::Linear);
+    case AL_LINEAR_DISTANCE_CLAMPED: return al::make_optional(DistanceModel::LinearClamped);
+    case AL_EXPONENT_DISTANCE: return al::make_optional(DistanceModel::Exponent);
+    case AL_EXPONENT_DISTANCE_CLAMPED: return al::make_optional(DistanceModel::ExponentClamped);
+    }
+    return al::nullopt;
+}
+ALenum ALenumFromDistanceModel(DistanceModel model)
+{
+    switch(model)
+    {
+    case DistanceModel::Disable: return AL_NONE;
+    case DistanceModel::Inverse: return AL_INVERSE_DISTANCE;
+    case DistanceModel::InverseClamped: return AL_INVERSE_DISTANCE_CLAMPED;
+    case DistanceModel::Linear: return AL_LINEAR_DISTANCE;
+    case DistanceModel::LinearClamped: return AL_LINEAR_DISTANCE_CLAMPED;
+    case DistanceModel::Exponent: return AL_EXPONENT_DISTANCE;
+    case DistanceModel::ExponentClamped: return AL_EXPONENT_DISTANCE_CLAMPED;
+    }
+    throw std::runtime_error{"Unexpected distance model "+std::to_string(static_cast<int>(model))};
+}
+
+} // namespace
+
+/* WARNING: Non-standard export! Not part of any extension, or exposed in the
+ * alcFunctions list.
+ */
+extern "C" AL_API const ALchar* AL_APIENTRY alsoft_get_version(void)
+START_API_FUNC
+{
+    static const auto spoof = al::getenv("ALSOFT_SPOOF_VERSION");
+    if(spoof) return spoof->c_str();
+    return ALSOFT_VERSION;
+}
+END_API_FUNC
+
+#define DO_UPDATEPROPS() do {                                                 \
+    if(!context->mDeferUpdates.load(std::memory_order_acquire))               \
+        UpdateContextProps(context.get());                                    \
+    else                                                                      \
+        context->mPropsClean.clear(std::memory_order_release);                \
+} while(0)
+
+
+AL_API void AL_APIENTRY alEnable(ALenum capability)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(capability)
+    {
+    case AL_SOURCE_DISTANCE_MODEL:
+        context->mSourceDistanceModel = true;
+        DO_UPDATEPROPS();
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid enable property 0x%04x", capability);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDisable(ALenum capability)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    switch(capability)
+    {
+    case AL_SOURCE_DISTANCE_MODEL:
+        context->mSourceDistanceModel = false;
+        DO_UPDATEPROPS();
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid disable property 0x%04x", capability);
+    }
+}
+END_API_FUNC
+
+AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return AL_FALSE;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALboolean value{AL_FALSE};
+    switch(capability)
+    {
+    case AL_SOURCE_DISTANCE_MODEL:
+        value = context->mSourceDistanceModel ? AL_TRUE : AL_FALSE;
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid is enabled property 0x%04x", capability);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return AL_FALSE;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALboolean value{AL_FALSE};
+    switch(pname)
+    {
+    case AL_DOPPLER_FACTOR:
+        if(context->mDopplerFactor != 0.0f)
+            value = AL_TRUE;
+        break;
+
+    case AL_DOPPLER_VELOCITY:
+        if(context->mDopplerVelocity != 0.0f)
+            value = AL_TRUE;
+        break;
+
+    case AL_DISTANCE_MODEL:
+        if(context->mDistanceModel == DistanceModel::Default)
+            value = AL_TRUE;
+        break;
+
+    case AL_SPEED_OF_SOUND:
+        if(context->mSpeedOfSound != 0.0f)
+            value = AL_TRUE;
+        break;
+
+    case AL_DEFERRED_UPDATES_SOFT:
+        if(context->mDeferUpdates.load(std::memory_order_acquire))
+            value = AL_TRUE;
+        break;
+
+    case AL_GAIN_LIMIT_SOFT:
+        if(GainMixMax/context->mGainBoost != 0.0f)
+            value = AL_TRUE;
+        break;
+
+    case AL_NUM_RESAMPLERS_SOFT:
+        /* Always non-0. */
+        value = AL_TRUE;
+        break;
+
+    case AL_DEFAULT_RESAMPLER_SOFT:
+        value = static_cast<int>(ResamplerDefault) ? AL_TRUE : AL_FALSE;
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid boolean property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return 0.0;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALdouble value{0.0};
+    switch(pname)
+    {
+    case AL_DOPPLER_FACTOR:
+        value = context->mDopplerFactor;
+        break;
+
+    case AL_DOPPLER_VELOCITY:
+        value = context->mDopplerVelocity;
+        break;
+
+    case AL_DISTANCE_MODEL:
+        value = static_cast<ALdouble>(ALenumFromDistanceModel(context->mDistanceModel));
+        break;
+
+    case AL_SPEED_OF_SOUND:
+        value = context->mSpeedOfSound;
+        break;
+
+    case AL_DEFERRED_UPDATES_SOFT:
+        if(context->mDeferUpdates.load(std::memory_order_acquire))
+            value = static_cast<ALdouble>(AL_TRUE);
+        break;
+
+    case AL_GAIN_LIMIT_SOFT:
+        value = ALdouble{GainMixMax}/context->mGainBoost;
+        break;
+
+    case AL_NUM_RESAMPLERS_SOFT:
+        value = static_cast<ALdouble>(Resampler::Max) + 1.0;
+        break;
+
+    case AL_DEFAULT_RESAMPLER_SOFT:
+        value = static_cast<ALdouble>(ResamplerDefault);
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid double property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return 0.0f;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALfloat value{0.0f};
+    switch(pname)
+    {
+    case AL_DOPPLER_FACTOR:
+        value = context->mDopplerFactor;
+        break;
+
+    case AL_DOPPLER_VELOCITY:
+        value = context->mDopplerVelocity;
+        break;
+
+    case AL_DISTANCE_MODEL:
+        value = static_cast<ALfloat>(ALenumFromDistanceModel(context->mDistanceModel));
+        break;
+
+    case AL_SPEED_OF_SOUND:
+        value = context->mSpeedOfSound;
+        break;
+
+    case AL_DEFERRED_UPDATES_SOFT:
+        if(context->mDeferUpdates.load(std::memory_order_acquire))
+            value = static_cast<ALfloat>(AL_TRUE);
+        break;
+
+    case AL_GAIN_LIMIT_SOFT:
+        value = GainMixMax/context->mGainBoost;
+        break;
+
+    case AL_NUM_RESAMPLERS_SOFT:
+        value = static_cast<ALfloat>(Resampler::Max) + 1.0f;
+        break;
+
+    case AL_DEFAULT_RESAMPLER_SOFT:
+        value = static_cast<ALfloat>(ResamplerDefault);
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid float property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return 0;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALint value{0};
+    switch(pname)
+    {
+    case AL_DOPPLER_FACTOR:
+        value = static_cast<ALint>(context->mDopplerFactor);
+        break;
+
+    case AL_DOPPLER_VELOCITY:
+        value = static_cast<ALint>(context->mDopplerVelocity);
+        break;
+
+    case AL_DISTANCE_MODEL:
+        value = ALenumFromDistanceModel(context->mDistanceModel);
+        break;
+
+    case AL_SPEED_OF_SOUND:
+        value = static_cast<ALint>(context->mSpeedOfSound);
+        break;
+
+    case AL_DEFERRED_UPDATES_SOFT:
+        if(context->mDeferUpdates.load(std::memory_order_acquire))
+            value = AL_TRUE;
+        break;
+
+    case AL_GAIN_LIMIT_SOFT:
+        value = static_cast<ALint>(GainMixMax/context->mGainBoost);
+        break;
+
+    case AL_NUM_RESAMPLERS_SOFT:
+        value = static_cast<int>(Resampler::Max) + 1;
+        break;
+
+    case AL_DEFAULT_RESAMPLER_SOFT:
+        value = static_cast<int>(ResamplerDefault);
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid integer property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+extern "C" AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return 0_i64;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    ALint64SOFT value{0};
+    switch(pname)
+    {
+    case AL_DOPPLER_FACTOR:
+        value = static_cast<ALint64SOFT>(context->mDopplerFactor);
+        break;
+
+    case AL_DOPPLER_VELOCITY:
+        value = static_cast<ALint64SOFT>(context->mDopplerVelocity);
+        break;
+
+    case AL_DISTANCE_MODEL:
+        value = ALenumFromDistanceModel(context->mDistanceModel);
+        break;
+
+    case AL_SPEED_OF_SOUND:
+        value = static_cast<ALint64SOFT>(context->mSpeedOfSound);
+        break;
+
+    case AL_DEFERRED_UPDATES_SOFT:
+        if(context->mDeferUpdates.load(std::memory_order_acquire))
+            value = AL_TRUE;
+        break;
+
+    case AL_GAIN_LIMIT_SOFT:
+        value = static_cast<ALint64SOFT>(GainMixMax/context->mGainBoost);
+        break;
+
+    case AL_NUM_RESAMPLERS_SOFT:
+        value = static_cast<ALint64SOFT>(Resampler::Max) + 1;
+        break;
+
+    case AL_DEFAULT_RESAMPLER_SOFT:
+        value = static_cast<ALint64SOFT>(ResamplerDefault);
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid integer64 property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API ALvoid* AL_APIENTRY alGetPointerSOFT(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return nullptr;
+
+    std::lock_guard<std::mutex> _{context->mPropLock};
+    void *value{nullptr};
+    switch(pname)
+    {
+    case AL_EVENT_CALLBACK_FUNCTION_SOFT:
+        value = reinterpret_cast<void*>(context->mEventCb);
+        break;
+
+    case AL_EVENT_CALLBACK_USER_PARAM_SOFT:
+        value = context->mEventParam;
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid pointer property 0x%04x", pname);
+    }
+
+    return value;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetBooleanv(ALenum pname, ALboolean *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+            case AL_DOPPLER_VELOCITY:
+            case AL_DISTANCE_MODEL:
+            case AL_SPEED_OF_SOUND:
+            case AL_DEFERRED_UPDATES_SOFT:
+            case AL_GAIN_LIMIT_SOFT:
+            case AL_NUM_RESAMPLERS_SOFT:
+            case AL_DEFAULT_RESAMPLER_SOFT:
+                values[0] = alGetBoolean(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid boolean-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetDoublev(ALenum pname, ALdouble *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+            case AL_DOPPLER_VELOCITY:
+            case AL_DISTANCE_MODEL:
+            case AL_SPEED_OF_SOUND:
+            case AL_DEFERRED_UPDATES_SOFT:
+            case AL_GAIN_LIMIT_SOFT:
+            case AL_NUM_RESAMPLERS_SOFT:
+            case AL_DEFAULT_RESAMPLER_SOFT:
+                values[0] = alGetDouble(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid double-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetFloatv(ALenum pname, ALfloat *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+            case AL_DOPPLER_VELOCITY:
+            case AL_DISTANCE_MODEL:
+            case AL_SPEED_OF_SOUND:
+            case AL_DEFERRED_UPDATES_SOFT:
+            case AL_GAIN_LIMIT_SOFT:
+            case AL_NUM_RESAMPLERS_SOFT:
+            case AL_DEFAULT_RESAMPLER_SOFT:
+                values[0] = alGetFloat(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid float-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+            case AL_DOPPLER_VELOCITY:
+            case AL_DISTANCE_MODEL:
+            case AL_SPEED_OF_SOUND:
+            case AL_DEFERRED_UPDATES_SOFT:
+            case AL_GAIN_LIMIT_SOFT:
+            case AL_NUM_RESAMPLERS_SOFT:
+            case AL_DEFAULT_RESAMPLER_SOFT:
+                values[0] = alGetInteger(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid integer-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+extern "C" AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_DOPPLER_FACTOR:
+            case AL_DOPPLER_VELOCITY:
+            case AL_DISTANCE_MODEL:
+            case AL_SPEED_OF_SOUND:
+            case AL_DEFERRED_UPDATES_SOFT:
+            case AL_GAIN_LIMIT_SOFT:
+            case AL_NUM_RESAMPLERS_SOFT:
+            case AL_DEFAULT_RESAMPLER_SOFT:
+                values[0] = alGetInteger64SOFT(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid integer64-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, ALvoid **values)
+START_API_FUNC
+{
+    if(values)
+    {
+        switch(pname)
+        {
+            case AL_EVENT_CALLBACK_FUNCTION_SOFT:
+            case AL_EVENT_CALLBACK_USER_PARAM_SOFT:
+                values[0] = alGetPointerSOFT(pname);
+                return;
+        }
+    }
+
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!values)
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(pname)
+    {
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid pointer-vector property 0x%04x", pname);
+    }
+}
+END_API_FUNC
+
+AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return nullptr;
+
+    const ALchar *value{nullptr};
+    switch(pname)
+    {
+    case AL_VENDOR:
+        value = alVendor;
+        break;
+
+    case AL_VERSION:
+        value = alVersion;
+        break;
+
+    case AL_RENDERER:
+        value = alRenderer;
+        break;
+
+    case AL_EXTENSIONS:
+        value = context->mExtensionList;
+        break;
+
+    case AL_NO_ERROR:
+        value = alNoError;
+        break;
+
+    case AL_INVALID_NAME:
+        value = alErrInvalidName;
+        break;
+
+    case AL_INVALID_ENUM:
+        value = alErrInvalidEnum;
+        break;
+
+    case AL_INVALID_VALUE:
+        value = alErrInvalidValue;
+        break;
+
+    case AL_INVALID_OPERATION:
+        value = alErrInvalidOp;
+        break;
+
+    case AL_OUT_OF_MEMORY:
+        value = alErrOutOfMemory;
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid string property 0x%04x", pname);
+    }
+    return value;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDopplerFactor(ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!(value >= 0.0f && std::isfinite(value)))
+        context->setError(AL_INVALID_VALUE, "Doppler factor %f out of range", value);
+    else
+    {
+        std::lock_guard<std::mutex> _{context->mPropLock};
+        context->mDopplerFactor = value;
+        DO_UPDATEPROPS();
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!(value >= 0.0f && std::isfinite(value)))
+        context->setError(AL_INVALID_VALUE, "Doppler velocity %f out of range", value);
+    else
+    {
+        std::lock_guard<std::mutex> _{context->mPropLock};
+        context->mDopplerVelocity = value;
+        DO_UPDATEPROPS();
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(!(value > 0.0f && std::isfinite(value)))
+        context->setError(AL_INVALID_VALUE, "Speed of sound %f out of range", value);
+    else
+    {
+        std::lock_guard<std::mutex> _{context->mPropLock};
+        context->mSpeedOfSound = value;
+        DO_UPDATEPROPS();
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alDistanceModel(ALenum value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    if(auto model = DistanceModelFromALenum(value))
+    {
+        std::lock_guard<std::mutex> _{context->mPropLock};
+        context->mDistanceModel = *model;
+        if(!context->mSourceDistanceModel)
+            DO_UPDATEPROPS();
+    }
+    else
+        context->setError(AL_INVALID_VALUE, "Distance model 0x%04x out of range", value);
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alDeferUpdatesSOFT(void)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    context->deferUpdates();
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alProcessUpdatesSOFT(void)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return;
+
+    context->processUpdates();
+}
+END_API_FUNC
+
+
+AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if UNLIKELY(!context) return nullptr;
+
+    const ALchar *value{nullptr};
+    switch(pname)
+    {
+    case AL_RESAMPLER_NAME_SOFT:
+        if(index < 0 || index > static_cast<ALint>(Resampler::Max))
+            context->setError(AL_INVALID_VALUE, "Resampler name index %d out of range", index);
+        else
+            value = GetResamplerName(static_cast<Resampler>(index));
+        break;
+
+    default:
+        context->setError(AL_INVALID_VALUE, "Invalid string indexed property");
+    }
+    return value;
+}
+END_API_FUNC
+
+
+void UpdateContextProps(ALCcontext *context)
+{
+    /* Get an unused proprty container, or allocate a new one as needed. */
+    ContextProps *props{context->mFreeContextProps.load(std::memory_order_acquire)};
+    if(!props)
+        props = new ContextProps{};
+    else
+    {
+        ContextProps *next;
+        do {
+            next = props->next.load(std::memory_order_relaxed);
+        } while(context->mFreeContextProps.compare_exchange_weak(props, next,
+                std::memory_order_seq_cst, std::memory_order_acquire) == 0);
+    }
+
+    /* Copy in current property values. */
+    props->DopplerFactor = context->mDopplerFactor;
+    props->DopplerVelocity = context->mDopplerVelocity;
+    props->SpeedOfSound = context->mSpeedOfSound;
+
+    props->SourceDistanceModel = context->mSourceDistanceModel;
+    props->mDistanceModel = context->mDistanceModel;
+
+    /* Set the new container for updating internal parameters. */
+    props = context->mParams.ContextUpdate.exchange(props, std::memory_order_acq_rel);
+    if(props)
+    {
+        /* If there was an unused update container, put it back in the
+         * freelist.
+         */
+        AtomicReplaceHead(context->mFreeContextProps, props);
+    }
+}