Merge branch 'v1.23.1'

Resolved Conflicts:
	CMakeLists.txt

328 files changed, 54161 insertions, 29067 deletions

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..1a94c760
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,116 @@
+name: CI
+
+on: [push]
+
+jobs:
+  build:
+    name: ${{matrix.config.name}}
+    runs-on: ${{matrix.config.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+        - {
+            name: "Win32-Release",
+            os: windows-latest,
+            cmake_opts: "-A Win32 \
+              -DALSOFT_BUILD_ROUTER=ON \
+              -DALSOFT_REQUIRE_WINMM=ON \
+              -DALSOFT_REQUIRE_DSOUND=ON \
+              -DALSOFT_REQUIRE_WASAPI=ON",
+            build_type: "Release"
+          }
+        - {
+            name: "Win32-Debug",
+            os: windows-latest,
+            cmake_opts: "-A Win32 \
+              -DALSOFT_BUILD_ROUTER=ON \
+              -DALSOFT_REQUIRE_WINMM=ON \
+              -DALSOFT_REQUIRE_DSOUND=ON \
+              -DALSOFT_REQUIRE_WASAPI=ON",
+            build_type: "Debug"
+          }
+        - {
+            name: "Win64-Release",
+            os: windows-latest,
+            cmake_opts: "-A x64 \
+              -DALSOFT_BUILD_ROUTER=ON \
+              -DALSOFT_REQUIRE_WINMM=ON \
+              -DALSOFT_REQUIRE_DSOUND=ON \
+              -DALSOFT_REQUIRE_WASAPI=ON",
+            build_type: "Release"
+          }
+        - {
+            name: "Win64-Debug",
+            os: windows-latest,
+            cmake_opts: "-A x64 \
+              -DALSOFT_BUILD_ROUTER=ON \
+              -DALSOFT_REQUIRE_WINMM=ON \
+              -DALSOFT_REQUIRE_DSOUND=ON \
+              -DALSOFT_REQUIRE_WASAPI=ON",
+            build_type: "Debug"
+          }
+        - {
+            name: "macOS-Release",
+            os: macos-latest,
+            cmake_opts: "-DALSOFT_REQUIRE_COREAUDIO=ON",
+            build_type: "Release"
+          }
+        - {
+            name: "Linux-Release",
+            os: ubuntu-latest,
+            cmake_opts: "-DALSOFT_REQUIRE_RTKIT=ON \
+              -DALSOFT_REQUIRE_ALSA=ON \
+              -DALSOFT_REQUIRE_OSS=ON \
+              -DALSOFT_REQUIRE_PORTAUDIO=ON \
+              -DALSOFT_REQUIRE_PULSEAUDIO=ON \
+              -DALSOFT_REQUIRE_JACK=ON \
+              -DALSOFT_REQUIRE_PIPEWIRE=ON",
+            deps_cmdline: "sudo apt update && sudo apt-get install -qq \
+              libpulse-dev \
+              portaudio19-dev \
+              libasound2-dev \
+              libjack-dev \
+              libpipewire-0.3-dev \
+              qtbase5-dev \
+              libdbus-1-dev",
+            build_type: "Release"
+          }
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Install Dependencies
+      shell: bash
+      run: |
+        if [[ ! -z "${{matrix.config.deps_cmdline}}" ]]; then
+          eval ${{matrix.config.deps_cmdline}}
+        fi
+
+    - name: Configure
+      shell: bash
+      run: |
+        cmake -B build -DCMAKE_BUILD_TYPE=${{matrix.config.build_type}} ${{matrix.config.cmake_opts}} .
+
+    - name: Build
+      shell: bash
+      run: |
+        cmake --build build --config ${{matrix.config.build_type}}
+
+    - name: Create Archive
+      if: ${{ matrix.config.os == 'windows-latest' }}
+      shell: bash
+      run: |
+        cd build
+        mkdir archive
+        mkdir archive/router
+        cp ${{matrix.config.build_type}}/soft_oal.dll archive
+        cp ${{matrix.config.build_type}}/OpenAL32.dll archive/router
+
+    - name: Upload Archive
+      # Upload package as an artifact of this workflow.
+      uses: actions/[email protected]
+      if: ${{ matrix.config.os == 'windows-latest' }}
+      with:
+        name: soft_oal-${{matrix.config.name}}
+        path: build/archive
diff --git a/.github/workflows/makemhr.yml b/.github/workflows/makemhr.yml
new file mode 100644
index 00000000..7bde284c
--- /dev/null
+++ b/.github/workflows/makemhr.yml
@@ -0,0 +1,76 @@
+name: makemhr
+
+on:
+  push:
+    paths:
+      - 'utils/makemhr/**'
+      - '.github/workflows/makemhr.yml'
+
+  workflow_dispatch:
+
+env:
+  BUILD_TYPE: Release
+
+jobs:
+  Win64:
+    runs-on: windows-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Get current date
+      run: echo "CurrentDate=$(date +'%Y-%m-%d')" >> $env:GITHUB_ENV
+
+    - name: Get commit hash
+      run: echo "CommitHash=$(git rev-parse --short=7 HEAD)" >> $env:GITHUB_ENV
+
+    - name: Clone libmysofa
+      run: git clone --depth 1 --branch v1.3.1 https://github.com/hoene/libmysofa.git libmysofa
+
+    - name: Add MSBuild to PATH
+      uses: microsoft/[email protected]
+
+    - name: Restore libmysofa NuGet packages
+      working-directory: ${{github.workspace}}/libmysofa
+      run: nuget restore ${{github.workspace}}/libmysofa/windows/libmysofa.sln
+
+    - name: Build libmysofa
+      working-directory: ${{github.workspace}}/libmysofa
+      run: msbuild /m /p:Configuration=${{env.BUILD_TYPE}} ${{github.workspace}}/libmysofa/windows/libmysofa.sln
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -D "MYSOFA_LIBRARY=${{github.workspace}}/libmysofa/windows/bin/x64/Release/mysofa.lib" -D "MYSOFA_INCLUDE_DIR=${{github.workspace}}/libmysofa/src/hrtf" -D "ZLIB_LIBRARY=${{github.workspace}}/libmysofa/windows/third-party/zlib-1.2.11/lib/zlib.lib" -D "ZLIB_INCLUDE_DIR=${{github.workspace}}/libmysofa/windows/third-party/zlib-1.2.11/include"
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Make Artifacts folder
+      run: |
+        mkdir "Artifacts"
+        mkdir "Release"
+
+    - name: Collect artifacts
+      run: |
+        copy "build/Release/makemhr.exe" "Artifacts/makemhr.exe"
+        copy "libmysofa/windows/third-party/zlib-1.2.11/bin/zlib.dll" "Artifacts/zlib.dll"
+
+    - name: Upload makemhr artifact
+      uses: actions/[email protected]
+      with:
+        name: makemhr
+        path: "Artifacts/"
+
+    - name: Compress artifacts
+      uses: papeloto/action-zip@v1
+      with:
+        files: Artifacts/
+        dest: "Release/makemhr.zip"
+
+    - name: GitHub pre-release
+      uses: "marvinpinto/action-automatic-releases@latest"
+      with:
+        repo_token: "${{secrets.GITHUB_TOKEN}}"
+        automatic_release_tag: "makemhr"
+        prerelease: true
+        title: "[${{env.CurrentDate}}] makemhr-${{env.CommitHash}}"
+        files: "Release/makemhr.zip"
diff --git a/.gitignore b/.gitignore
index de57ef22..4a8212b5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,9 @@
 build*/
-winbuild/
-win64build/
-openal-soft.kdev4
-.kdev4/
+winbuild
+win64build
+
+## kdevelop
+*.kdev4
+
+## qt-creator
+CMakeLists.txt.user*
diff --git a/.travis.yml b/.travis.yml
index 98b5adcc..f85da593 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,7 +7,13 @@ matrix:
       dist: trusty
       env:
         - BUILD_ANDROID=true
+    - os: freebsd
+      compiler: clang
     - os: osx
+    - os: osx
+      osx_image: xcode11
+      env:
+        - BUILD_IOS=true
 sudo: required
 install:
   - >
@@ -20,24 +26,49 @@ install:
         portaudio19-dev \
         libasound2-dev \
         libjack-dev \
-        qtbase5-dev
+        qtbase5-dev \
+        libdbus-1-dev
     fi
   - >
     if [[ "${TRAVIS_OS_NAME}" == "linux" && "${BUILD_ANDROID}" == "true" ]]; then
-      curl -o ~/android-ndk.zip https://dl.google.com/android/repository/android-ndk-r16b-linux-x86_64.zip
+      curl -o ~/android-ndk.zip https://dl.google.com/android/repository/android-ndk-r21-linux-x86_64.zip
       unzip -q ~/android-ndk.zip -d ~ \
-        'android-ndk-r16b/build/cmake/*' \
-        'android-ndk-r16b/build/core/toolchains/arm-linux-androideabi-*/*' \
-        'android-ndk-r16b/platforms/android-14/arch-arm/*' \
-        'android-ndk-r16b/source.properties' \
-        'android-ndk-r16b/sources/android/support/include/*' \
-        'android-ndk-r16b/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/*' \
-        'android-ndk-r16b/sources/cxx-stl/llvm-libc++/include/*' \
-        'android-ndk-r16b/sysroot/*' \
-        'android-ndk-r16b/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/*' \
-        'android-ndk-r16b/toolchains/llvm/prebuilt/linux-x86_64/*'
+        'android-ndk-r21/build/cmake/*' \
+        'android-ndk-r21/build/core/toolchains/arm-linux-androideabi-*/*' \
+        'android-ndk-r21/platforms/android-16/arch-arm/*' \
+        'android-ndk-r21/source.properties' \
+        'android-ndk-r21/sources/android/support/include/*' \
+        'android-ndk-r21/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/*' \
+        'android-ndk-r21/sources/cxx-stl/llvm-libc++/include/*' \
+        'android-ndk-r21/sysroot/*' \
+        'android-ndk-r21/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/*' \
+        'android-ndk-r21/toolchains/llvm/prebuilt/linux-x86_64/*'
+      export OBOE_LOC=~/oboe
+      git clone --depth 1 -b 1.3-stable https://github.com/google/oboe "$OBOE_LOC"
+    fi
+  - >
+    if [[ "${TRAVIS_OS_NAME}" == "freebsd" ]]; then
+      # Install Ninja as it's used downstream.
+      # Install dependencies for all supported backends.
+      # Install Qt5 dependency for alsoft-config.
+      # Install ffmpeg for examples.
+      sudo pkg install -y \
+        alsa-lib \
+        ffmpeg \
+        jackit \
+        libmysofa \
+        ninja \
+        portaudio \
+        pulseaudio \
+        qt5-buildtools \
+        qt5-qmake \
+        qt5-widgets \
+        sdl2 \
+        sndio \
+        $NULL
     fi
 script:
+  - cmake --version
   - >
     if [[ "${TRAVIS_OS_NAME}" == "linux" && -z "${BUILD_ANDROID}" ]]; then
       cmake \
@@ -53,16 +84,42 @@ script:
     if [[ "${TRAVIS_OS_NAME}" == "linux" && "${BUILD_ANDROID}" == "true" ]]; then
       cmake \
         -DANDROID_STL=c++_shared \
-        -DCMAKE_TOOLCHAIN_FILE=~/android-ndk-r16b/build/cmake/android.toolchain.cmake \
+        -DCMAKE_TOOLCHAIN_FILE=~/android-ndk-r21/build/cmake/android.toolchain.cmake \
+        -DOBOE_SOURCE="$OBOE_LOC" \
+        -DALSOFT_REQUIRE_OBOE=ON \
         -DALSOFT_REQUIRE_OPENSL=ON \
         -DALSOFT_EMBED_HRTF_DATA=YES \
         .
     fi
   - >
-    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+    if [[ "${TRAVIS_OS_NAME}" == "freebsd" ]]; then
+      cmake -GNinja \
+        -DALSOFT_REQUIRE_ALSA=ON \
+        -DALSOFT_REQUIRE_JACK=ON \
+        -DALSOFT_REQUIRE_OSS=ON \
+        -DALSOFT_REQUIRE_PORTAUDIO=ON \
+        -DALSOFT_REQUIRE_PULSEAUDIO=ON \
+        -DALSOFT_REQUIRE_SDL2=ON \
+        -DALSOFT_REQUIRE_SNDIO=ON \
+        -DALSOFT_EMBED_HRTF_DATA=YES \
+        .
+    fi
+  - >
+    if [[ "${TRAVIS_OS_NAME}" == "osx" && -z "${BUILD_IOS}" ]]; then
+      cmake \
+        -DALSOFT_REQUIRE_COREAUDIO=ON \
+        -DALSOFT_EMBED_HRTF_DATA=YES \
+        .
+    fi
+  - >
+    if [[ "${TRAVIS_OS_NAME}" == "osx" && "${BUILD_IOS}" == "true" ]]; then
       cmake \
+        -GXcode \
+        -DCMAKE_SYSTEM_NAME=iOS \
+        -DALSOFT_OSX_FRAMEWORK=ON \
         -DALSOFT_REQUIRE_COREAUDIO=ON \
         -DALSOFT_EMBED_HRTF_DATA=YES \
+        "-DCMAKE_OSX_ARCHITECTURES=armv7;arm64" \
         .
     fi
-  - make -j2
+  - cmake --build . --clean-first
diff --git a/BSD-3Clause b/BSD-3Clause
new file mode 100644
index 00000000..b1c2dbd7
--- /dev/null
+++ b/BSD-3Clause
@@ -0,0 +1,31 @@
+Portions of this software are licensed under the BSD 3-Clause license.
+
+Copyright (c) 2015, Archontis Politis
+Copyright (c) 2019, Anis A. Hireche
+Copyright (c) 2019, Christopher Robinson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Spherical-Harmonic-Transform nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 824659b7..963c4346 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,67 +2,128 @@
 
 CMAKE_MINIMUM_REQUIRED(VERSION 3.2.0)
 
-PROJECT(OpenAL)
-
-IF(COMMAND CMAKE_POLICY)
-    CMAKE_POLICY(SET CMP0003 NEW)
-    CMAKE_POLICY(SET CMP0005 NEW)
-    IF(POLICY CMP0020)
-        CMAKE_POLICY(SET CMP0020 NEW)
-    ENDIF(POLICY CMP0020)
-    IF(POLICY CMP0042)
-        CMAKE_POLICY(SET CMP0042 NEW)
-    ENDIF(POLICY CMP0042)
-    IF(POLICY CMP0054)
-        CMAKE_POLICY(SET CMP0054 NEW)
-    ENDIF(POLICY CMP0054)
-    IF(POLICY CMP0075)
-        CMAKE_POLICY(SET CMP0075 NEW)
-    ENDIF(POLICY CMP0075)
-ENDIF(COMMAND CMAKE_POLICY)
-
-IF(NOT CMAKE_BUILD_TYPE)
-    SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
+if(APPLE)
+    # The workaround for try_compile failing with code signing
+    # since cmake-3.18.2, not required
+    set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        ${CMAKE_TRY_COMPILE_PLATFORM_VARIABLES}
+        "CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED"
+        "CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED")
+    set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED NO)
+    set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED NO)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    # Fix compile failure with armv7 deployment target >= 11.0, xcode clang
+    # will report:
+    # error: invalid iOS deployment version '--target=armv7-apple-ios13.6',
+    # iOS 10 is the maximum deployment target for 32-bit targets
+    # If CMAKE_OSX_DEPLOYMENT_TARGET is not defined, cmake will choose latest
+    # deployment target
+    if("${CMAKE_OSX_ARCHITECTURES}" MATCHES ".*armv7.*")
+        if(NOT DEFINED CMAKE_OSX_DEPLOYMENT_TARGET
+            OR NOT CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS "11.0")
+            message(STATUS "Forcing iOS deployment target to 10.0 for armv7")
+            set(CMAKE_OSX_DEPLOYMENT_TARGET "10.0" CACHE STRING "Minimum OS X deployment version"
+                FORCE)
+        endif()
+    endif()
+endif()
+
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+
+if(COMMAND CMAKE_POLICY)
+    cmake_policy(SET CMP0003 NEW)
+    cmake_policy(SET CMP0005 NEW)
+    if(POLICY CMP0020)
+        cmake_policy(SET CMP0020 NEW)
+    endif(POLICY CMP0020)
+    if(POLICY CMP0042)
+        cmake_policy(SET CMP0042 NEW)
+    endif(POLICY CMP0042)
+    if(POLICY CMP0054)
+        cmake_policy(SET CMP0054 NEW)
+    endif(POLICY CMP0054)
+    if(POLICY CMP0058)
+        cmake_policy(SET CMP0058 NEW)
+    endif(POLICY CMP0058)
+    if(POLICY CMP0063)
+        cmake_policy(SET CMP0063 NEW)
+    endif(POLICY CMP0063)
+    if(POLICY CMP0075)
+        cmake_policy(SET CMP0075 NEW)
+    endif(POLICY CMP0075)
+    if(POLICY CMP0092)
+        cmake_policy(SET CMP0092 NEW)
+    endif(POLICY CMP0092)
+    if(POLICY CMP0117)
+        cmake_policy(SET CMP0117 NEW)
+    endif(POLICY CMP0117)
+endif(COMMAND CMAKE_POLICY)
+
+project(OpenAL)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
         "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
         FORCE)
-ENDIF()
-IF(NOT CMAKE_DEBUG_POSTFIX)
-    SET(CMAKE_DEBUG_POSTFIX "" CACHE STRING
+endif()
+if(NOT CMAKE_DEBUG_POSTFIX)
+    set(CMAKE_DEBUG_POSTFIX "" CACHE STRING
         "Library postfix for debug builds. Normally left blank."
         FORCE)
-ENDIF()
-
-SET(CMAKE_MODULE_PATH "${OpenAL_SOURCE_DIR}/cmake")
-
+endif()
 
-INCLUDE(CheckFunctionExists)
-INCLUDE(CheckLibraryExists)
-INCLUDE(CheckIncludeFile)
-INCLUDE(CheckIncludeFiles)
-INCLUDE(CheckSymbolExists)
-INCLUDE(CheckCCompilerFlag)
-INCLUDE(CheckCXXCompilerFlag)
-INCLUDE(CheckCSourceCompiles)
-INCLUDE(CheckCXXSourceCompiles)
-INCLUDE(CheckTypeSize)
+set(DEFAULT_TARGET_PROPS
+    # Require C++14.
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED TRUE
+    # Prefer C11, but support C99 and earlier when possible.
+    C_STANDARD 11)
+
+set(CMAKE_MODULE_PATH "${OpenAL_SOURCE_DIR}/cmake")
+
+include(CheckFunctionExists)
+include(CheckLibraryExists)
+include(CheckIncludeFile)
+include(CheckIncludeFiles)
+include(CheckSymbolExists)
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
 include(CheckStructHasMember)
+include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
+find_package(PkgConfig)
+find_package(SDL2 QUIET)
 
-OPTION(ALSOFT_DLOPEN  "Check for the dlopen API for loading optional libs"  ON)
 
-OPTION(ALSOFT_WERROR  "Treat compile warnings as errors"      OFF)
+option(ALSOFT_DLOPEN  "Check for the dlopen API for loading optional libs"  ON)
 
-OPTION(ALSOFT_UTILS          "Build and install utility programs"         ON)
-OPTION(ALSOFT_NO_CONFIG_UTIL "Disable building the alsoft-config utility" OFF)
+option(ALSOFT_WERROR  "Treat compile warnings as errors"      OFF)
 
-OPTION(ALSOFT_EXAMPLES  "Build and install example programs"  ON)
-OPTION(ALSOFT_TESTS     "Build and install test programs"     ON)
+option(ALSOFT_UTILS "Build utility programs"  ON)
+option(ALSOFT_NO_CONFIG_UTIL "Disable building the alsoft-config utility" OFF)
 
-OPTION(ALSOFT_CONFIG "Install alsoft.conf sample configuration file" ON)
-OPTION(ALSOFT_HRTF_DEFS "Install HRTF definition files" ON)
-OPTION(ALSOFT_AMBDEC_PRESETS "Install AmbDec preset files" ON)
-OPTION(ALSOFT_INSTALL "Install headers and libraries" ON)
+option(ALSOFT_EXAMPLES  "Build example programs"  ON)
+
+option(ALSOFT_INSTALL "Install main library" ON)
+option(ALSOFT_INSTALL_CONFIG "Install alsoft.conf sample configuration file" ON)
+option(ALSOFT_INSTALL_HRTF_DATA "Install HRTF data files" ON)
+option(ALSOFT_INSTALL_AMBDEC_PRESETS "Install AmbDec preset files" ON)
+option(ALSOFT_INSTALL_EXAMPLES "Install example programs (alplay, alstream, ...)" ON)
+option(ALSOFT_INSTALL_UTILS "Install utility programs (openal-info, alsoft-config, ...)" ON)
+option(ALSOFT_UPDATE_BUILD_VERSION "Update git build version info" ON)
+
+option(ALSOFT_EAX "Enable legacy EAX extensions" ${WIN32})
+
+option(ALSOFT_SEARCH_INSTALL_DATADIR "Search the installation data directory" OFF)
+if(ALSOFT_SEARCH_INSTALL_DATADIR)
+    set(ALSOFT_INSTALL_DATADIR ${CMAKE_INSTALL_FULL_DATADIR})
+endif()
 
 if(DEFINED SHARE_INSTALL_DIR)
     message(WARNING "SHARE_INSTALL_DIR is deprecated.  Use the variables provided by the GNUInstallDirs module instead")
@@ -72,160 +133,167 @@ endif()
 if(DEFINED LIB_SUFFIX)
     message(WARNING "LIB_SUFFIX is deprecated.  Use the variables provided by the GNUInstallDirs module instead")
 endif()
+if(DEFINED ALSOFT_CONFIG)
+    message(WARNING "ALSOFT_CONFIG is deprecated. Use ALSOFT_INSTALL_CONFIG instead")
+endif()
+if(DEFINED ALSOFT_HRTF_DEFS)
+    message(WARNING "ALSOFT_HRTF_DEFS is deprecated. Use ALSOFT_INSTALL_HRTF_DATA instead")
+endif()
+if(DEFINED ALSOFT_AMBDEC_PRESETS)
+    message(WARNING "ALSOFT_AMBDEC_PRESETS is deprecated. Use ALSOFT_INSTALL_AMBDEC_PRESETS instead")
+endif()
 
 
-SET(CPP_DEFS ) # C pre-processor, not C++
-SET(INC_PATHS )
-SET(C_FLAGS )
-SET(LINKER_FLAGS )
-SET(EXTRA_LIBS )
-
-IF(WIN32)
-    SET(CPP_DEFS ${CPP_DEFS} _WIN32 _WIN32_WINNT=0x0502)
-
-    OPTION(ALSOFT_BUILD_ROUTER  "Build the router (EXPERIMENTAL; creates OpenAL32.dll and soft_oal.dll)"  OFF)
+set(CPP_DEFS ) # C pre-processor, not C++
+set(INC_PATHS )
+set(C_FLAGS )
+set(LINKER_FLAGS )
+set(EXTRA_LIBS )
 
-    # This option is mainly for static linking OpenAL Soft into another project
-    # that already defines the IDs. It is up to that project to ensure all
-    # required IDs are defined.
-    OPTION(ALSOFT_NO_UID_DEFS "Do not define GUIDs, IIDs, CLSIDs, or PropertyKeys" OFF)
+if(WIN32)
+    set(CPP_DEFS ${CPP_DEFS} _WIN32 NOMINMAX)
+    if(MINGW)
+        set(CPP_DEFS ${CPP_DEFS} __USE_MINGW_ANSI_STDIO)
+    endif()
 
-    IF(MINGW)
-        OPTION(ALSOFT_BUILD_IMPORT_LIB "Build an import .lib using dlltool (requires sed)" ON)
-        IF(NOT DLLTOOL)
-            IF(HOST)
-                SET(DLLTOOL "${HOST}-dlltool")
-            ELSE()
-                SET(DLLTOOL "dlltool")
-            ENDIF()
-        ENDIF()
-    ENDIF()
-ENDIF()
+    option(ALSOFT_BUILD_ROUTER  "Build the router (EXPERIMENTAL; creates OpenAL32.dll and soft_oal.dll)"  OFF)
+    if(MINGW)
+        option(ALSOFT_BUILD_IMPORT_LIB "Build an import .lib using dlltool (requires sed)" ON)
+    endif()
+elseif(APPLE)
+    option(ALSOFT_OSX_FRAMEWORK "Build as macOS framework" OFF)
+endif()
 
 
 # QNX's gcc do not uses /usr/include and /usr/lib pathes by default
-IF ("${CMAKE_C_PLATFORM_ID}" STREQUAL "QNX")
-    SET(INC_PATHS ${INC_PATHS} /usr/include)
-    SET(LINKER_FLAGS ${LINKER_FLAGS} -L/usr/lib)
-ENDIF()
-
-IF(NOT LIBTYPE)
-    SET(LIBTYPE SHARED)
-ENDIF()
-
-SET(LIB_MAJOR_VERSION "1")
-SET(LIB_MINOR_VERSION "20")
-SET(LIB_REVISION "0")
-SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_REVISION}")
-SET(LIB_VERSION_NUM ${LIB_MAJOR_VERSION},${LIB_MINOR_VERSION},${LIB_REVISION},0)
-
-SET(EXPORT_DECL "")
-
-
-CHECK_TYPE_SIZE("long" SIZEOF_LONG)
+if("${CMAKE_C_PLATFORM_ID}" STREQUAL "QNX")
+    set(INC_PATHS ${INC_PATHS} /usr/include)
+    set(LINKER_FLAGS ${LINKER_FLAGS} -L/usr/lib)
+endif()
 
+# When the library is built for static linking, apps should define
+# AL_LIBTYPE_STATIC when including the AL headers.
+if(NOT LIBTYPE)
+    set(LIBTYPE SHARED)
+endif()
 
-# Require C++11
-SET(CMAKE_CXX_STANDARD 11)
-SET(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(LIB_MAJOR_VERSION "1")
+set(LIB_MINOR_VERSION "23")
+set(LIB_REVISION "1")
+set(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_REVISION}")
+set(LIB_VERSION_NUM ${LIB_MAJOR_VERSION},${LIB_MINOR_VERSION},${LIB_REVISION},0)
 
-# Prefer C11, but support C99 and C90 too.
-SET(CMAKE_C_STANDARD 11)
+set(EXPORT_DECL "")
 
 
 if(NOT WIN32)
     # Check if _POSIX_C_SOURCE and _XOPEN_SOURCE needs to be set for POSIX functions
-    CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN_DEFAULT)
-    IF(NOT HAVE_POSIX_MEMALIGN_DEFAULT)
-        SET(OLD_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-        SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -D_POSIX_C_SOURCE=200112L -D_XOPEN_SOURCE=600")
-        CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN_POSIX)
-        IF(NOT HAVE_POSIX_MEMALIGN_POSIX)
-            SET(CMAKE_REQUIRED_FLAGS ${OLD_REQUIRED_FLAGS})
-        ELSE()
-            SET(CPP_DEFS ${CPP_DEFS} _POSIX_C_SOURCE=200112L _XOPEN_SOURCE=600)
-        ENDIF()
-    ENDIF()
-    UNSET(OLD_REQUIRED_FLAGS)
-ENDIF()
+    check_symbol_exists(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN_DEFAULT)
+    if(NOT HAVE_POSIX_MEMALIGN_DEFAULT)
+        set(OLD_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -D_POSIX_C_SOURCE=200112L -D_XOPEN_SOURCE=600")
+        check_symbol_exists(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN_POSIX)
+        if(NOT HAVE_POSIX_MEMALIGN_POSIX)
+            set(CMAKE_REQUIRED_FLAGS ${OLD_REQUIRED_FLAGS})
+        else()
+            set(CPP_DEFS ${CPP_DEFS} _POSIX_C_SOURCE=200112L _XOPEN_SOURCE=600)
+        endif()
+    endif()
+    unset(OLD_REQUIRED_FLAGS)
+endif()
 
 # C99 has restrict, but C++ does not, so we can only utilize __restrict.
-SET(RESTRICT_DECL )
-CHECK_CXX_SOURCE_COMPILES("int *__restrict foo;
+check_cxx_source_compiles("int *__restrict foo;
 int main() { return 0; }" HAVE___RESTRICT)
-IF(HAVE___RESTRICT)
-    SET(RESTRICT_DECL "__restrict")
-ENDIF()
+if(HAVE___RESTRICT)
+    set(CPP_DEFS ${CPP_DEFS} RESTRICT=__restrict)
+else()
+    set(CPP_DEFS ${CPP_DEFS} "RESTRICT=")
+endif()
 
 # Some systems may need libatomic for atomic functions to work
-SET(OLD_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-SET(CMAKE_REQUIRED_LIBRARIES ${OLD_REQUIRED_LIBRARIES} atomic)
-CHECK_CXX_SOURCE_COMPILES("#include <atomic>
+set(OLD_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+set(CMAKE_REQUIRED_LIBRARIES ${OLD_REQUIRED_LIBRARIES} atomic)
+check_cxx_source_compiles("#include <atomic>
 std::atomic<int> foo{0};
 int main() { return foo.fetch_add(2); }"
 HAVE_LIBATOMIC)
-IF(NOT HAVE_LIBATOMIC)
-    SET(CMAKE_REQUIRED_LIBRARIES "${OLD_REQUIRED_LIBRARIES}")
-ELSE()
-    SET(EXTRA_LIBS atomic ${EXTRA_LIBS})
-ENDIF()
-UNSET(OLD_REQUIRED_LIBRARIES)
-
-# Include liblog for Android logging
-CHECK_LIBRARY_EXISTS(log __android_log_print "" HAVE_LIBLOG)
-IF(HAVE_LIBLOG)
-    SET(EXTRA_LIBS log ${EXTRA_LIBS})
-    SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} log)
-ENDIF()
-
-IF(MSVC)
-    SET(CPP_DEFS ${CPP_DEFS} _CRT_SECURE_NO_WARNINGS NOMINMAX)
-    CHECK_CXX_COMPILER_FLAG(/permissive- HAVE_PERMISSIVE_SWITCH)
-    IF(HAVE_PERMISSIVE_SWITCH)
-        SET(C_FLAGS ${C_FLAGS} $<$<COMPILE_LANGUAGE:CXX>:/permissive->)
-    ENDIF()
-    SET(C_FLAGS ${C_FLAGS} /W4 /w14640 /wd4065 /wd4268 /wd4324)
+if(NOT HAVE_LIBATOMIC)
+    set(CMAKE_REQUIRED_LIBRARIES "${OLD_REQUIRED_LIBRARIES}")
+else()
+    set(EXTRA_LIBS atomic ${EXTRA_LIBS})
+endif()
+unset(OLD_REQUIRED_LIBRARIES)
+
+if(ANDROID)
+    # Include liblog for Android logging
+    check_library_exists(log __android_log_print "" HAVE_LIBLOG)
+    if(HAVE_LIBLOG)
+        set(EXTRA_LIBS log ${EXTRA_LIBS})
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} log)
+    endif()
+endif()
 
-    IF(NOT DXSDK_DIR)
-        STRING(REGEX REPLACE "\\\\" "/" DXSDK_DIR "$ENV{DXSDK_DIR}")
-    ELSE()
-        STRING(REGEX REPLACE "\\\\" "/" DXSDK_DIR "${DXSDK_DIR}")
-    ENDIF()
-    IF(DXSDK_DIR)
-        MESSAGE(STATUS "Using DirectX SDK directory: ${DXSDK_DIR}")
-    ENDIF()
+if(MSVC)
+    set(CPP_DEFS ${CPP_DEFS} _CRT_SECURE_NO_WARNINGS)
+    check_cxx_compiler_flag(/permissive- HAVE_PERMISSIVE_SWITCH)
+    if(HAVE_PERMISSIVE_SWITCH)
+        set(C_FLAGS ${C_FLAGS} $<$<COMPILE_LANGUAGE:CXX>:/permissive->)
+    endif()
+    set(C_FLAGS ${C_FLAGS} /W4 /w14640 /wd4065 /wd4127 /wd4268 /wd4324 /wd5030 /wd5051)
+
+    if(NOT DXSDK_DIR)
+        string(REGEX REPLACE "\\\\" "/" DXSDK_DIR "$ENV{DXSDK_DIR}")
+    else()
+        string(REGEX REPLACE "\\\\" "/" DXSDK_DIR "${DXSDK_DIR}")
+    endif()
+    if(DXSDK_DIR)
+        message(STATUS "Using DirectX SDK directory: ${DXSDK_DIR}")
+    endif()
 
-    OPTION(FORCE_STATIC_VCRT "Force /MT for static VC runtimes" OFF)
-    IF(FORCE_STATIC_VCRT)
-        FOREACH(flag_var
+    option(FORCE_STATIC_VCRT "Force /MT for static VC runtimes" OFF)
+    if(FORCE_STATIC_VCRT)
+        foreach(flag_var
                 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
-            IF(${flag_var} MATCHES "/MD")
-                STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-            ENDIF()
-        ENDFOREACH(flag_var)
-    ENDIF()
-ELSE()
-    SET(C_FLAGS ${C_FLAGS} -Winline -Wunused -Wall -Wextra -Wshadow -Wconversion -Wcast-align
+                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+                CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+            if(${flag_var} MATCHES "/MD")
+                string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+            endif()
+        endforeach(flag_var)
+    endif()
+else()
+    set(C_FLAGS ${C_FLAGS} -Winline -Wunused -Wall -Wextra -Wshadow -Wconversion -Wcast-align
         -Wpedantic
         $<$<COMPILE_LANGUAGE:CXX>:-Wold-style-cast -Wnon-virtual-dtor -Woverloaded-virtual>)
 
-    IF(ALSOFT_WERROR)
-        SET(C_FLAGS ${C_FLAGS} -Werror)
-    ENDIF()
+    check_cxx_compiler_flag(-Wno-c++20-attribute-extensions HAVE_WNO_CXX20_ATTR_EXT)
+    if(HAVE_WNO_CXX20_ATTR_EXT)
+        set(C_FLAGS ${C_FLAGS} $<$<COMPILE_LANGUAGE:CXX>:-Wno-c++20-attribute-extensions>)
+    else()
+        check_cxx_compiler_flag(-Wno-c++20-extensions HAVE_WNO_CXX20_EXT)
+        if(HAVE_WNO_CXX20_EXT)
+            set(C_FLAGS ${C_FLAGS} $<$<COMPILE_LANGUAGE:CXX>:-Wno-c++20-extensions>)
+        endif()
+    endif()
+
+    if(ALSOFT_WERROR)
+        set(C_FLAGS ${C_FLAGS} -Werror)
+    endif()
 
     # We want RelWithDebInfo to actually include debug stuff (define _DEBUG
     # instead of NDEBUG)
-    FOREACH(flag_var  CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-        IF(${flag_var} MATCHES "-DNDEBUG")
-            STRING(REGEX REPLACE "-DNDEBUG" "-D_DEBUG" ${flag_var} "${${flag_var}}")
-        ENDIF()
-    ENDFOREACH()
+    foreach(flag_var  CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+        if(${flag_var} MATCHES "-DNDEBUG")
+            string(REGEX REPLACE "-DNDEBUG" "-D_DEBUG" ${flag_var} "${${flag_var}}")
+        endif()
+    endforeach()
 
-    CHECK_C_COMPILER_FLAG(-fno-math-errno HAVE_FNO_MATH_ERRNO)
-    IF(HAVE_FNO_MATH_ERRNO)
-        SET(C_FLAGS ${C_FLAGS} -fno-math-errno)
-    ENDIF()
+    check_c_compiler_flag(-fno-math-errno HAVE_FNO_MATH_ERRNO)
+    if(HAVE_FNO_MATH_ERRNO)
+        set(C_FLAGS ${C_FLAGS} -fno-math-errno)
+    endif()
 
     option(ALSOFT_STATIC_LIBGCC "Force -static-libgcc for static GCC runtimes" OFF)
     if(ALSOFT_STATIC_LIBGCC)
@@ -270,190 +338,225 @@ ELSE()
             set(LINKER_FLAGS ${LINKER_FLAGS} "-Wl,--push-state,-Bstatic,-lwinpthread,--pop-state")
         endif()
     endif()
-ENDIF()
+endif()
 
 # Set visibility/export options if available
-IF(WIN32)
-    SET(EXPORT_DECL "__declspec(dllexport)")
-ELSE()
-    SET(OLD_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+if(WIN32)
+    if(NOT LIBTYPE STREQUAL "STATIC")
+        set(EXPORT_DECL "__declspec(dllexport)")
+    endif()
+else()
+    set(OLD_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
     # Yes GCC, really don't accept visibility modes you don't support
-    SET(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS} -Wattributes -Werror")
+    set(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS} -Wattributes -Werror")
 
-    CHECK_C_SOURCE_COMPILES("int foo() __attribute__((visibility(\"protected\")));
+    check_c_source_compiles("int foo() __attribute__((visibility(\"protected\")));
                              int main() {return 0;}" HAVE_GCC_PROTECTED_VISIBILITY)
-    IF(HAVE_GCC_PROTECTED_VISIBILITY)
-        SET(EXPORT_DECL "__attribute__((visibility(\"protected\")))")
-    ELSE()
-        CHECK_C_SOURCE_COMPILES("int foo() __attribute__((visibility(\"default\")));
+    if(HAVE_GCC_PROTECTED_VISIBILITY)
+        if(NOT LIBTYPE STREQUAL "STATIC")
+            set(EXPORT_DECL "__attribute__((visibility(\"protected\")))")
+        endif()
+    else()
+        check_c_source_compiles("int foo() __attribute__((visibility(\"default\")));
                                  int main() {return 0;}" HAVE_GCC_DEFAULT_VISIBILITY)
-        IF(HAVE_GCC_DEFAULT_VISIBILITY)
-            SET(EXPORT_DECL "__attribute__((visibility(\"default\")))")
-        ENDIF()
-    ENDIF()
+        if(HAVE_GCC_DEFAULT_VISIBILITY)
+            if(NOT LIBTYPE STREQUAL "STATIC")
+                set(EXPORT_DECL "__attribute__((visibility(\"default\")))")
+            endif()
+        endif()
+    endif()
 
-    IF(HAVE_GCC_PROTECTED_VISIBILITY OR HAVE_GCC_DEFAULT_VISIBILITY)
-        CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAVE_VISIBILITY_HIDDEN_SWITCH)
-        IF(HAVE_VISIBILITY_HIDDEN_SWITCH)
-            SET(C_FLAGS ${C_FLAGS} -fvisibility=hidden)
-        ENDIF()
-    ENDIF()
+    set(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS}")
+endif()
 
-    SET(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS}")
-ENDIF()
-
-SET(SSE2_SWITCH "")
-SET(SSE3_SWITCH "")
-SET(SSE4_1_SWITCH "")
-SET(FPU_NEON_SWITCH "")
-
-CHECK_C_COMPILER_FLAG(-msse2 HAVE_MSSE2_SWITCH)
-IF(HAVE_MSSE2_SWITCH)
-    SET(SSE2_SWITCH "-msse2")
-ENDIF()
-CHECK_C_COMPILER_FLAG(-msse3 HAVE_MSSE3_SWITCH)
-IF(HAVE_MSSE3_SWITCH)
-    SET(SSE3_SWITCH "-msse3")
-ENDIF()
-CHECK_C_COMPILER_FLAG(-msse4.1 HAVE_MSSE4_1_SWITCH)
-IF(HAVE_MSSE4_1_SWITCH)
-    SET(SSE4_1_SWITCH "-msse4.1")
-ENDIF()
-CHECK_C_COMPILER_FLAG(-mfpu=neon HAVE_MFPU_NEON_SWITCH)
-IF(HAVE_MFPU_NEON_SWITCH)
-    SET(FPU_NEON_SWITCH "-mfpu=neon")
-ENDIF()
-
-CHECK_INCLUDE_FILE(xmmintrin.h HAVE_XMMINTRIN_H "${SSE2_SWITCH}")
-CHECK_INCLUDE_FILE(emmintrin.h HAVE_EMMINTRIN_H "${SSE2_SWITCH}")
-CHECK_INCLUDE_FILE(pmmintrin.h HAVE_PMMINTRIN_H "${SSE3_SWITCH}")
-CHECK_INCLUDE_FILE(smmintrin.h HAVE_SMMINTRIN_H "${SSE4_1_SWITCH}")
-CHECK_INCLUDE_FILE(arm_neon.h HAVE_ARM_NEON_H "${FPU_NEON_SWITCH}")
-
-SET(SSE_FLAGS )
-SET(FPMATH_SET "0")
-IF(CMAKE_SIZEOF_VOID_P MATCHES "4")
-    IF(SSE2_SWITCH OR MSVC)
-        OPTION(ALSOFT_ENABLE_SSE2_CODEGEN "Enable SSE2 code generation instead of x87 for 32-bit targets." TRUE)
-    ENDIF()
 
-    IF(ALSOFT_ENABLE_SSE2_CODEGEN)
-        IF(SSE2_SWITCH)
-            CHECK_C_COMPILER_FLAG("${SSE2_SWITCH} -mfpmath=sse" HAVE_MFPMATH_SSE_2)
-            IF(HAVE_MFPMATH_SSE_2)
-                SET(SSE_FLAGS ${SSE_FLAGS} ${SSE2_SWITCH} -mfpmath=sse)
-                SET(C_FLAGS ${C_FLAGS} ${SSE_FLAGS})
-                SET(FPMATH_SET 2)
-            ENDIF()
-        ELSEIF(MSVC)
-            CHECK_C_COMPILER_FLAG("/arch:SSE2" HAVE_ARCH_SSE2)
-            IF(HAVE_ARCH_SSE2)
-                SET(SSE_FLAGS ${SSE_FLAGS} "/arch:SSE2")
-                SET(C_FLAGS ${C_FLAGS} ${SSE_FLAGS})
-                SET(FPMATH_SET 2)
-            ENDIF()
-        ENDIF()
-    ENDIF()
-ENDIF()
+set(SSE2_SWITCH "")
+
+if(NOT MSVC)
+    set(OLD_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+    # Yes GCC, really don't accept command line options you don't support
+    set(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS} -Werror")
+    check_c_compiler_flag(-msse2 HAVE_MSSE2_SWITCH)
+    if(HAVE_MSSE2_SWITCH)
+        set(SSE2_SWITCH "-msse2")
+    endif()
+    set(CMAKE_REQUIRED_FLAGS ${OLD_REQUIRED_FLAGS})
+    unset(OLD_REQUIRED_FLAGS)
+endif()
+
+check_include_file(xmmintrin.h HAVE_XMMINTRIN_H)
+check_include_file(emmintrin.h HAVE_EMMINTRIN_H)
+check_include_file(pmmintrin.h HAVE_PMMINTRIN_H)
+check_include_file(smmintrin.h HAVE_SMMINTRIN_H)
+check_include_file(arm_neon.h HAVE_ARM_NEON_H)
+
+set(HAVE_SSE        0)
+set(HAVE_SSE2       0)
+set(HAVE_SSE3       0)
+set(HAVE_SSE4_1     0)
+set(HAVE_NEON       0)
+
+# Check for SSE support
+option(ALSOFT_CPUEXT_SSE "Enable SSE support" ON)
+option(ALSOFT_REQUIRE_SSE "Require SSE support" OFF)
+if(ALSOFT_CPUEXT_SSE AND HAVE_XMMINTRIN_H)
+    set(HAVE_SSE 1)
+endif()
+if(ALSOFT_REQUIRE_SSE AND NOT HAVE_SSE)
+    message(FATAL_ERROR "Failed to enabled required SSE CPU extensions")
+endif()
 
-IF(HAVE_EMMINTRIN_H)
-    SET(OLD_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-    FOREACH(flag_var ${SSE_FLAGS})
-        SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag_var}")
-    ENDFOREACH()
+option(ALSOFT_CPUEXT_SSE2 "Enable SSE2 support" ON)
+option(ALSOFT_REQUIRE_SSE2 "Require SSE2 support" OFF)
+if(ALSOFT_CPUEXT_SSE2 AND HAVE_SSE AND HAVE_EMMINTRIN_H)
+    set(HAVE_SSE2 1)
+endif()
+if(ALSOFT_REQUIRE_SSE2 AND NOT HAVE_SSE2)
+    message(FATAL_ERROR "Failed to enable required SSE2 CPU extensions")
+endif()
 
-    CHECK_C_SOURCE_COMPILES("#include <emmintrin.h>
-                             int main() {_mm_pause(); return 0;}" HAVE_SSE_INTRINSICS)
+option(ALSOFT_CPUEXT_SSE3 "Enable SSE3 support" ON)
+option(ALSOFT_REQUIRE_SSE3 "Require SSE3 support" OFF)
+if(ALSOFT_CPUEXT_SSE3 AND HAVE_SSE2 AND HAVE_PMMINTRIN_H)
+    set(HAVE_SSE3 1)
+endif()
+if(ALSOFT_REQUIRE_SSE3 AND NOT HAVE_SSE3)
+    message(FATAL_ERROR "Failed to enable required SSE3 CPU extensions")
+endif()
 
-    SET(CMAKE_REQUIRED_FLAGS ${OLD_REQUIRED_FLAGS})
-ENDIF()
+option(ALSOFT_CPUEXT_SSE4_1 "Enable SSE4.1 support" ON)
+option(ALSOFT_REQUIRE_SSE4_1 "Require SSE4.1 support" OFF)
+if(ALSOFT_CPUEXT_SSE4_1 AND HAVE_SSE3 AND HAVE_SMMINTRIN_H)
+    set(HAVE_SSE4_1 1)
+endif()
+if(ALSOFT_REQUIRE_SSE4_1 AND NOT HAVE_SSE4_1)
+    message(FATAL_ERROR "Failed to enable required SSE4.1 CPU extensions")
+endif()
 
+# Check for ARM Neon support
+option(ALSOFT_CPUEXT_NEON "Enable ARM NEON support" ON)
+option(ALSOFT_REQUIRE_NEON "Require ARM NEON support" OFF)
+if(ALSOFT_CPUEXT_NEON AND HAVE_ARM_NEON_H)
+    check_c_source_compiles("#include <arm_neon.h>
+        int main()
+        {
+            int32x4_t ret4 = vdupq_n_s32(0);
+            return vgetq_lane_s32(ret4, 0);
+        }" HAVE_NEON_INTRINSICS)
+    if(HAVE_NEON_INTRINSICS)
+        set(HAVE_NEON 1)
+    endif()
+endif()
+if(ALSOFT_REQUIRE_NEON AND NOT HAVE_NEON)
+    message(FATAL_ERROR "Failed to enabled required ARM NEON CPU extensions")
+endif()
 
-CHECK_C_SOURCE_COMPILES("int foo(const char *str, ...) __attribute__((format(printf, 1, 2)));
-                         int main() {return 0;}" HAVE_GCC_FORMAT)
 
-CHECK_INCLUDE_FILE(malloc.h HAVE_MALLOC_H)
-CHECK_INCLUDE_FILE(dirent.h HAVE_DIRENT_H)
-CHECK_INCLUDE_FILE(cpuid.h HAVE_CPUID_H)
-CHECK_INCLUDE_FILE(intrin.h HAVE_INTRIN_H)
-CHECK_INCLUDE_FILE(sys/sysconf.h HAVE_SYS_SYSCONF_H)
-CHECK_INCLUDE_FILE(guiddef.h HAVE_GUIDDEF_H)
-IF(NOT HAVE_GUIDDEF_H)
-    CHECK_INCLUDE_FILE(initguid.h HAVE_INITGUID_H)
-ENDIF()
+set(SSE_FLAGS )
+set(FPMATH_SET "0")
+if(CMAKE_SIZEOF_VOID_P MATCHES "4" AND HAVE_SSE2)
+    option(ALSOFT_ENABLE_SSE2_CODEGEN "Enable SSE2 code generation instead of x87 for 32-bit targets." TRUE)
+    if(ALSOFT_ENABLE_SSE2_CODEGEN)
+        if(MSVC)
+            check_c_compiler_flag("/arch:SSE2" HAVE_ARCH_SSE2)
+            if(HAVE_ARCH_SSE2)
+                set(SSE_FLAGS ${SSE_FLAGS} "/arch:SSE2")
+                set(C_FLAGS ${C_FLAGS} ${SSE_FLAGS})
+                set(FPMATH_SET 2)
+            endif()
+        elseif(SSE2_SWITCH)
+            check_c_compiler_flag("${SSE2_SWITCH} -mfpmath=sse" HAVE_MFPMATH_SSE_2)
+            if(HAVE_MFPMATH_SSE_2)
+                set(SSE_FLAGS ${SSE_FLAGS} ${SSE2_SWITCH} -mfpmath=sse)
+                set(C_FLAGS ${C_FLAGS} ${SSE_FLAGS})
+                set(FPMATH_SET 2)
+            endif()
+            # SSE depends on a 16-byte aligned stack, and by default, GCC
+            # assumes the stack is suitably aligned. Older Linux code or other
+            # OSs don't guarantee this on 32-bit, so externally-callable
+            # functions need to ensure an aligned stack.
+            set(EXPORT_DECL "${EXPORT_DECL}__attribute__((force_align_arg_pointer))")
+        endif()
+    endif()
+endif()
+
+if(HAVE_SSE2)
+    set(OLD_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+    foreach(flag_var ${SSE_FLAGS})
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag_var}")
+    endforeach()
+
+    check_c_source_compiles("#include <emmintrin.h>
+        int main() {_mm_pause(); return 0;}" HAVE_SSE_INTRINSICS)
+
+    set(CMAKE_REQUIRED_FLAGS ${OLD_REQUIRED_FLAGS})
+endif()
+
+
+check_include_file(malloc.h HAVE_MALLOC_H)
+check_include_file(cpuid.h HAVE_CPUID_H)
+check_include_file(intrin.h HAVE_INTRIN_H)
+check_include_file(guiddef.h HAVE_GUIDDEF_H)
+if(NOT HAVE_GUIDDEF_H)
+    check_include_file(initguid.h HAVE_INITGUID_H)
+endif()
 
 # Some systems need libm for some math functions to work
-SET(MATH_LIB )
-CHECK_LIBRARY_EXISTS(m pow "" HAVE_LIBM)
-IF(HAVE_LIBM)
-    SET(MATH_LIB ${MATH_LIB} m)
-    SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} m)
-ENDIF()
+set(MATH_LIB )
+check_library_exists(m pow "" HAVE_LIBM)
+if(HAVE_LIBM)
+    set(MATH_LIB ${MATH_LIB} m)
+    set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} m)
+endif()
 
 # Some systems need to link with -lrt for clock_gettime as used by the common
 # eaxmple functions.
-SET(RT_LIB )
-CHECK_LIBRARY_EXISTS(rt clock_gettime "" HAVE_LIBRT)
-IF(HAVE_LIBRT)
-    SET(RT_LIB rt)
-ENDIF()
+set(RT_LIB )
+check_library_exists(rt clock_gettime "" HAVE_LIBRT)
+if(HAVE_LIBRT)
+    set(RT_LIB rt)
+endif()
 
 # Check for the dlopen API (for dynamicly loading backend libs)
-IF(ALSOFT_DLOPEN)
-    CHECK_INCLUDE_FILE(dlfcn.h HAVE_DLFCN_H)
-    CHECK_LIBRARY_EXISTS(dl dlopen "" HAVE_LIBDL)
-    IF(HAVE_LIBDL)
-        SET(EXTRA_LIBS dl ${EXTRA_LIBS})
-        SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} dl)
-    ENDIF()
-ENDIF()
+if(ALSOFT_DLOPEN)
+    check_include_file(dlfcn.h HAVE_DLFCN_H)
+    check_library_exists(dl dlopen "" HAVE_LIBDL)
+    if(HAVE_LIBDL)
+        set(EXTRA_LIBS dl ${EXTRA_LIBS})
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} dl)
+    endif()
+endif()
 
 # Check for a cpuid intrinsic
-IF(HAVE_CPUID_H)
-    CHECK_C_SOURCE_COMPILES("#include <cpuid.h>
+if(HAVE_CPUID_H)
+    check_c_source_compiles("#include <cpuid.h>
         int main()
         {
             unsigned int eax, ebx, ecx, edx;
             return __get_cpuid(0, &eax, &ebx, &ecx, &edx);
         }" HAVE_GCC_GET_CPUID)
-ENDIF()
-IF(HAVE_INTRIN_H)
-    CHECK_C_SOURCE_COMPILES("#include <intrin.h>
+endif()
+if(HAVE_INTRIN_H)
+    check_c_source_compiles("#include <intrin.h>
         int main()
         {
             int regs[4];
             __cpuid(regs, 0);
             return regs[0];
         }" HAVE_CPUID_INTRINSIC)
-    CHECK_C_SOURCE_COMPILES("#include <intrin.h>
-        int main()
-        {
-            unsigned long idx = 0;
-            _BitScanForward64(&idx, 1);
-            return idx;
-        }" HAVE_BITSCANFORWARD64_INTRINSIC)
-    CHECK_C_SOURCE_COMPILES("#include <intrin.h>
-        int main()
-        {
-            unsigned long idx = 0;
-            _BitScanForward(&idx, 1);
-            return idx;
-        }" HAVE_BITSCANFORWARD_INTRINSIC)
-ENDIF()
-
-CHECK_SYMBOL_EXISTS(posix_memalign   stdlib.h HAVE_POSIX_MEMALIGN)
-CHECK_SYMBOL_EXISTS(_aligned_malloc  malloc.h HAVE__ALIGNED_MALLOC)
-CHECK_SYMBOL_EXISTS(proc_pidpath     libproc.h HAVE_PROC_PIDPATH)
+endif()
 
-CHECK_FUNCTION_EXISTS(stat HAVE_STAT)
+check_symbol_exists(posix_memalign   stdlib.h HAVE_POSIX_MEMALIGN)
+check_symbol_exists(_aligned_malloc  malloc.h HAVE__ALIGNED_MALLOC)
+check_symbol_exists(proc_pidpath     libproc.h HAVE_PROC_PIDPATH)
 
-IF(NOT WIN32)
+if(NOT WIN32)
     # We need pthreads outside of Windows, for semaphores. It's also used to
     # set the priority and name of threads, when possible.
-    CHECK_INCLUDE_FILE(pthread.h HAVE_PTHREAD_H)
-    IF(NOT HAVE_PTHREAD_H)
-        MESSAGE(FATAL_ERROR "PThreads is required for non-Windows builds!")
-    ENDIF()
+    check_include_file(pthread.h HAVE_PTHREAD_H)
+    if(NOT HAVE_PTHREAD_H)
+        message(FATAL_ERROR "PThreads is required for non-Windows builds!")
+    endif()
 
     CHECK_C_COMPILER_FLAG(-pthread HAVE_PTHREAD)
     IF(NOT HAVE_ANDROID_H)
@@ -472,105 +575,201 @@ IF(NOT WIN32)
         CHECK_LIBRARY_EXISTS(c pthread_create "" HAVE_LIBPTHREAD)
     ENDIF()
 
-    CHECK_SYMBOL_EXISTS(pthread_setschedparam pthread.h HAVE_PTHREAD_SETSCHEDPARAM)
+    check_symbol_exists(pthread_setschedparam pthread.h HAVE_PTHREAD_SETSCHEDPARAM)
 
     # Some systems need pthread_np.h to get pthread_setname_np
-    CHECK_INCLUDE_FILES("pthread.h;pthread_np.h" HAVE_PTHREAD_NP_H)
-    IF(HAVE_PTHREAD_NP_H)
-        CHECK_SYMBOL_EXISTS(pthread_setname_np "pthread.h;pthread_np.h" HAVE_PTHREAD_SETNAME_NP)
-        IF(NOT HAVE_PTHREAD_SETNAME_NP)
-            CHECK_SYMBOL_EXISTS(pthread_set_name_np "pthread.h;pthread_np.h" HAVE_PTHREAD_SET_NAME_NP)
-        ELSE()
-            CHECK_C_SOURCE_COMPILES("
-#include <pthread.h>
-#include <pthread_np.h>
-int main()
-{
-    pthread_setname_np(\"testname\");
-    return 0;
-}"
-                PTHREAD_SETNAME_NP_ONE_PARAM
-            )
-            CHECK_C_SOURCE_COMPILES("
-#include <pthread.h>
-#include <pthread_np.h>
-int main()
-{
-    pthread_setname_np(pthread_self(), \"%s\", \"testname\");
-    return 0;
-}"
-                PTHREAD_SETNAME_NP_THREE_PARAMS
-            )
-        ENDIF()
-    ELSE()
-        CHECK_SYMBOL_EXISTS(pthread_setname_np pthread.h HAVE_PTHREAD_SETNAME_NP)
-        IF(NOT HAVE_PTHREAD_SETNAME_NP)
-            CHECK_SYMBOL_EXISTS(pthread_set_name_np pthread.h HAVE_PTHREAD_SET_NAME_NP)
-        ELSE()
-            CHECK_C_SOURCE_COMPILES("
-#include <pthread.h>
-int main()
-{
-    pthread_setname_np(\"testname\");
-    return 0;
-}"
-                PTHREAD_SETNAME_NP_ONE_PARAM
-            )
-            CHECK_C_SOURCE_COMPILES("
-#include <pthread.h>
-int main()
-{
-    pthread_setname_np(pthread_self(), \"%s\", \"testname\");
-    return 0;
-}"
-                PTHREAD_SETNAME_NP_THREE_PARAMS
-            )
-        ENDIF()
-    ENDIF()
-ENDIF()
+    check_include_files("pthread.h;pthread_np.h" HAVE_PTHREAD_NP_H)
+    if(HAVE_PTHREAD_NP_H)
+        check_symbol_exists(pthread_setname_np "pthread.h;pthread_np.h" HAVE_PTHREAD_SETNAME_NP)
+        if(NOT HAVE_PTHREAD_SETNAME_NP)
+            check_symbol_exists(pthread_set_name_np "pthread.h;pthread_np.h" HAVE_PTHREAD_SET_NAME_NP)
+        endif()
+    else()
+        check_symbol_exists(pthread_setname_np pthread.h HAVE_PTHREAD_SETNAME_NP)
+        if(NOT HAVE_PTHREAD_SETNAME_NP)
+            check_symbol_exists(pthread_set_name_np pthread.h HAVE_PTHREAD_SET_NAME_NP)
+        endif()
+    endif()
+endif()
 
-CHECK_SYMBOL_EXISTS(getopt unistd.h HAVE_GETOPT)
+check_symbol_exists(getopt unistd.h HAVE_GETOPT)
 
 
-# Common sources used by both the OpenAL implementation library and potentially
-# the OpenAL router.
-SET(COMMON_OBJS
+# Common sources used by both the OpenAL implementation library, the OpenAL
+# router, and certain tools and examples.
+set(COMMON_OBJS
+    common/albit.h
     common/albyte.h
     common/alcomplex.cpp
     common/alcomplex.h
-    common/alexcpt.cpp
-    common/alexcpt.h
+    common/aldeque.h
     common/alfstream.cpp
     common/alfstream.h
     common/almalloc.cpp
     common/almalloc.h
+    common/alnumbers.h
     common/alnumeric.h
     common/aloptional.h
     common/alspan.h
     common/alstring.cpp
     common/alstring.h
+    common/altraits.h
     common/atomic.h
+    common/comptr.h
     common/dynload.cpp
     common/dynload.h
-    common/endiantest.h
     common/intrusive_ptr.h
-    common/math_defs.h
     common/opthelpers.h
+    common/phase_shifter.h
+    common/polyphase_resampler.cpp
+    common/polyphase_resampler.h
     common/pragmadefs.h
+    common/ringbuffer.cpp
+    common/ringbuffer.h
     common/strutils.cpp
     common/strutils.h
     common/threads.cpp
     common/threads.h
     common/vecmat.h
-    common/vector.h
-)
-SET(OPENAL_OBJS
+    common/vector.h)
+
+# Core library routines
+set(CORE_OBJS
+    core/ambdec.cpp
+    core/ambdec.h
+    core/ambidefs.cpp
+    core/ambidefs.h
+    core/async_event.h
+    core/bformatdec.cpp
+    core/bformatdec.h
+    core/bs2b.cpp
+    core/bs2b.h
+    core/bsinc_defs.h
+    core/bsinc_tables.cpp
+    core/bsinc_tables.h
+    core/bufferline.h
+    core/buffer_storage.cpp
+    core/buffer_storage.h
+    core/context.cpp
+    core/context.h
+    core/converter.cpp
+    core/converter.h
+    core/cpu_caps.cpp
+    core/cpu_caps.h
+    core/cubic_defs.h
+    core/cubic_tables.cpp
+    core/cubic_tables.h
+    core/devformat.cpp
+    core/devformat.h
+    core/device.cpp
+    core/device.h
+    core/effects/base.h
+    core/effectslot.cpp
+    core/effectslot.h
+    core/except.cpp
+    core/except.h
+    core/filters/biquad.h
+    core/filters/biquad.cpp
+    core/filters/nfc.cpp
+    core/filters/nfc.h
+    core/filters/splitter.cpp
+    core/filters/splitter.h
+    core/fmt_traits.cpp
+    core/fmt_traits.h
+    core/fpu_ctrl.cpp
+    core/fpu_ctrl.h
+    core/front_stablizer.h
+    core/helpers.cpp
+    core/helpers.h
+    core/hrtf.cpp
+    core/hrtf.h
+    core/logging.cpp
+    core/logging.h
+    core/mastering.cpp
+    core/mastering.h
+    core/mixer.cpp
+    core/mixer.h
+    core/resampler_limits.h
+    core/uhjfilter.cpp
+    core/uhjfilter.h
+    core/uiddefs.cpp
+    core/voice.cpp
+    core/voice.h
+    core/voice_change.h)
+
+set(HAVE_RTKIT 0)
+if(NOT WIN32)
+    option(ALSOFT_RTKIT "Enable RTKit support" ON)
+    option(ALSOFT_REQUIRE_RTKIT "Require RTKit/D-Bus support" FALSE)
+    if(ALSOFT_RTKIT)
+        find_package(DBus1 QUIET)
+        if(NOT DBus1_FOUND AND PkgConfig_FOUND)
+            pkg_check_modules(DBUS dbus-1)
+        endif()
+        if(DBus1_FOUND OR DBUS_FOUND)
+            set(HAVE_RTKIT 1)
+            set(CORE_OBJS ${CORE_OBJS} core/dbus_wrap.cpp core/dbus_wrap.h
+                core/rtkit.cpp core/rtkit.h)
+            if(NOT DBus1_FOUND)
+                set(INC_PATHS ${INC_PATHS} ${DBUS_INCLUDE_DIRS})
+                set(CPP_DEFS ${CPP_DEFS} ${DBUS_CFLAGS_OTHER})
+                if(NOT HAVE_DLFCN_H)
+                    set(EXTRA_LIBS ${EXTRA_LIBS} ${DBUS_LINK_LIBRARIES})
+                endif()
+            elseif(HAVE_DLFCN_H)
+                set(INC_PATHS ${INC_PATHS} ${DBus1_INCLUDE_DIRS})
+                set(CPP_DEFS ${CPP_DEFS} ${DBus1_DEFINITIONS})
+            else()
+                set(EXTRA_LIBS ${EXTRA_LIBS} ${DBus1_LIBRARIES})
+            endif()
+        endif()
+    else()
+        set(MISSING_VARS "")
+        if(NOT DBus1_INCLUDE_DIRS)
+            set(MISSING_VARS "${MISSING_VARS} DBus1_INCLUDE_DIRS")
+        endif()
+        if(NOT DBus1_LIBRARIES)
+            set(MISSING_VARS "${MISSING_VARS} DBus1_LIBRARIES")
+        endif()
+        message(STATUS "Could NOT find DBus1 (missing:${MISSING_VARS})")
+        unset(MISSING_VARS)
+    endif()
+endif()
+if(ALSOFT_REQUIRE_RTKIT AND NOT HAVE_RTKIT)
+    message(FATAL_ERROR "Failed to enabled required RTKit support")
+endif()
+
+# Default mixers, always available
+set(CORE_OBJS ${CORE_OBJS}
+    core/mixer/defs.h
+    core/mixer/hrtfbase.h
+    core/mixer/hrtfdefs.h
+    core/mixer/mixer_c.cpp)
+
+# AL and related routines
+set(OPENAL_OBJS
     al/auxeffectslot.cpp
     al/auxeffectslot.h
     al/buffer.cpp
     al/buffer.h
     al/effect.cpp
     al/effect.h
+    al/effects/autowah.cpp
+    al/effects/chorus.cpp
+    al/effects/compressor.cpp
+    al/effects/convolution.cpp
+    al/effects/dedicated.cpp
+    al/effects/distortion.cpp
+    al/effects/echo.cpp
+    al/effects/effects.cpp
+    al/effects/effects.h
+    al/effects/equalizer.cpp
+    al/effects/fshifter.cpp
+    al/effects/modulator.cpp
+    al/effects/null.cpp
+    al/effects/pshifter.cpp
+    al/effects/reverb.cpp
+    al/effects/vmorpher.cpp
     al/error.cpp
     al/event.cpp
     al/event.h
@@ -581,32 +780,24 @@ SET(OPENAL_OBJS
     al/listener.h
     al/source.cpp
     al/source.h
-    al/state.cpp
-)
-SET(ALC_OBJS
+    al/state.cpp)
+
+# ALC and related routines
+set(ALC_OBJS
     alc/alc.cpp
-    alc/alcmain.h
     alc/alu.cpp
     alc/alu.h
     alc/alconfig.cpp
     alc/alconfig.h
-    alc/alcontext.h
-    alc/ambdec.cpp
-    alc/ambdec.h
-    alc/ambidefs.h
-    alc/bformatdec.cpp
-    alc/bformatdec.h
-    alc/bs2b.cpp
-    alc/bs2b.h
-    alc/compat.h
-    alc/converter.cpp
-    alc/converter.h
-    alc/cpu_caps.h
-    alc/devformat.h
+    alc/context.cpp
+    alc/context.h
+    alc/device.cpp
+    alc/device.h
     alc/effects/base.h
     alc/effects/autowah.cpp
     alc/effects/chorus.cpp
     alc/effects/compressor.cpp
+    alc/effects/convolution.cpp
     alc/effects/dedicated.cpp
     alc/effects/distortion.cpp
     alc/effects/echo.cpp
@@ -617,146 +808,84 @@ SET(ALC_OBJS
     alc/effects/pshifter.cpp
     alc/effects/reverb.cpp
     alc/effects/vmorpher.cpp
-    alc/filters/biquad.h
-    alc/filters/biquad.cpp
-    alc/filters/nfc.cpp
-    alc/filters/nfc.h
-    alc/filters/splitter.cpp
-    alc/filters/splitter.h
-    alc/fpu_modes.h
-    alc/helpers.cpp
-    alc/hrtf.cpp
-    alc/hrtf.h
     alc/inprogext.h
-    alc/logging.h
-    alc/mastering.cpp
-    alc/mastering.h
-    alc/panning.cpp
-    alc/ringbuffer.cpp
-    alc/ringbuffer.h
-    alc/uhjfilter.cpp
-    alc/uhjfilter.h
-    alc/uiddefs.cpp
-    alc/voice.cpp
-    alc/voice.h
-    alc/mixer/defs.h
-    alc/mixer/hrtfbase.h
-    alc/mixer/mixer_c.cpp
-)
+    alc/panning.cpp)
+
+if(ALSOFT_EAX)
+    set(OPENAL_OBJS
+        ${OPENAL_OBJS}
+        al/eax/api.cpp
+        al/eax/api.h
+        al/eax/call.cpp
+        al/eax/call.h
+        al/eax/effect.h
+        al/eax/exception.cpp
+        al/eax/exception.h
+        al/eax/fx_slot_index.cpp
+        al/eax/fx_slot_index.h
+        al/eax/fx_slots.cpp
+        al/eax/fx_slots.h
+        al/eax/globals.cpp
+        al/eax/globals.h
+        al/eax/utils.cpp
+        al/eax/utils.h
+        al/eax/x_ram.h
+    )
+endif()
 
+# Include SIMD mixers
+set(CPU_EXTS "Default")
+if(HAVE_SSE)
+    set(CORE_OBJS  ${CORE_OBJS} core/mixer/mixer_sse.cpp)
+    set(CPU_EXTS "${CPU_EXTS}, SSE")
+endif()
+if(HAVE_SSE2)
+    set(CORE_OBJS  ${CORE_OBJS} core/mixer/mixer_sse2.cpp)
+    set(CPU_EXTS "${CPU_EXTS}, SSE2")
+endif()
+if(HAVE_SSE3)
+    set(CORE_OBJS  ${CORE_OBJS} core/mixer/mixer_sse3.cpp)
+    set(CPU_EXTS "${CPU_EXTS}, SSE3")
+endif()
+if(HAVE_SSE4_1)
+    set(CORE_OBJS  ${CORE_OBJS} core/mixer/mixer_sse41.cpp)
+    set(CPU_EXTS "${CPU_EXTS}, SSE4.1")
+endif()
+if(HAVE_NEON)
+    set(CORE_OBJS  ${CORE_OBJS} core/mixer/mixer_neon.cpp)
+    set(CPU_EXTS "${CPU_EXTS}, Neon")
+endif()
 
-SET(CPU_EXTS "Default")
-SET(HAVE_SSE        0)
-SET(HAVE_SSE2       0)
-SET(HAVE_SSE3       0)
-SET(HAVE_SSE4_1     0)
-SET(HAVE_NEON       0)
-
-# Check for SSE+SSE2 support
-OPTION(ALSOFT_REQUIRE_SSE "Require SSE support" OFF)
-OPTION(ALSOFT_REQUIRE_SSE2 "Require SSE2 support" OFF)
-IF(HAVE_XMMINTRIN_H AND HAVE_EMMINTRIN_H)
-    OPTION(ALSOFT_CPUEXT_SSE "Enable SSE support" ON)
-    OPTION(ALSOFT_CPUEXT_SSE2 "Enable SSE2 support" ON)
-    IF(ALSOFT_CPUEXT_SSE AND ALSOFT_CPUEXT_SSE2)
-        SET(HAVE_SSE 1)
-        SET(HAVE_SSE2 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/mixer/mixer_sse.cpp alc/mixer/mixer_sse2.cpp)
-        IF(SSE2_SWITCH)
-            SET_SOURCE_FILES_PROPERTIES(alc/mixer/mixer_sse.cpp alc/mixer/mixer_sse2.cpp
-                PROPERTIES COMPILE_FLAGS "${SSE2_SWITCH}")
-        ENDIF()
-        SET(CPU_EXTS "${CPU_EXTS}, SSE, SSE2")
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SSE AND NOT HAVE_SSE)
-    MESSAGE(FATAL_ERROR "Failed to enabled required SSE CPU extensions")
-ENDIF()
-IF(ALSOFT_REQUIRE_SSE2 AND NOT HAVE_SSE2)
-    MESSAGE(FATAL_ERROR "Failed to enable required SSE2 CPU extensions")
-ENDIF()
-
-OPTION(ALSOFT_REQUIRE_SSE3 "Require SSE3 support" OFF)
-IF(HAVE_EMMINTRIN_H)
-    OPTION(ALSOFT_CPUEXT_SSE3 "Enable SSE3 support" ON)
-    IF(HAVE_SSE2 AND ALSOFT_CPUEXT_SSE3)
-        SET(HAVE_SSE3 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/mixer/mixer_sse3.cpp)
-        IF(SSE2_SWITCH)
-            SET_SOURCE_FILES_PROPERTIES(alc/mixer/mixer_sse3.cpp PROPERTIES
-                                        COMPILE_FLAGS "${SSE3_SWITCH}")
-        ENDIF()
-        SET(CPU_EXTS "${CPU_EXTS}, SSE3")
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SSE3 AND NOT HAVE_SSE3)
-    MESSAGE(FATAL_ERROR "Failed to enable required SSE3 CPU extensions")
-ENDIF()
-
-OPTION(ALSOFT_REQUIRE_SSE4_1 "Require SSE4.1 support" OFF)
-IF(HAVE_SMMINTRIN_H)
-    OPTION(ALSOFT_CPUEXT_SSE4_1 "Enable SSE4.1 support" ON)
-    IF(HAVE_SSE3 AND ALSOFT_CPUEXT_SSE4_1)
-        SET(HAVE_SSE4_1 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/mixer/mixer_sse41.cpp)
-        IF(SSE4_1_SWITCH)
-            SET_SOURCE_FILES_PROPERTIES(alc/mixer/mixer_sse41.cpp PROPERTIES
-                                        COMPILE_FLAGS "${SSE4_1_SWITCH}")
-        ENDIF()
-        SET(CPU_EXTS "${CPU_EXTS}, SSE4.1")
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SSE4_1 AND NOT HAVE_SSE4_1)
-    MESSAGE(FATAL_ERROR "Failed to enable required SSE4.1 CPU extensions")
-ENDIF()
 
-# Check for ARM Neon support
-OPTION(ALSOFT_REQUIRE_NEON "Require ARM Neon support" OFF)
-IF(HAVE_ARM_NEON_H)
-    OPTION(ALSOFT_CPUEXT_NEON "Enable ARM Neon support" ON)
-    IF(ALSOFT_CPUEXT_NEON)
-        SET(HAVE_NEON 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/mixer/mixer_neon.cpp)
-        IF(FPU_NEON_SWITCH)
-            SET_SOURCE_FILES_PROPERTIES(alc/mixer/mixer_neon.cpp PROPERTIES
-                                        COMPILE_FLAGS "${FPU_NEON_SWITCH}")
-        ENDIF()
-        SET(CPU_EXTS "${CPU_EXTS}, Neon")
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_NEON AND NOT HAVE_NEON)
-    MESSAGE(FATAL_ERROR "Failed to enabled required ARM Neon CPU extensions")
-ENDIF()
-
-
-SET(HAVE_ALSA       0)
-SET(HAVE_OSS        0)
-SET(HAVE_SOLARIS    0)
-SET(HAVE_SNDIO      0)
-SET(HAVE_QSA        0)
-SET(HAVE_DSOUND     0)
-SET(HAVE_WASAPI     0)
-SET(HAVE_WINMM      0)
-SET(HAVE_PORTAUDIO  0)
-SET(HAVE_PULSEAUDIO 0)
-SET(HAVE_COREAUDIO  0)
-SET(HAVE_OPENSL     0)
-SET(HAVE_WAVE       0)
-SET(HAVE_SDL2       0)
-
-IF(WIN32 OR HAVE_DLFCN_H)
-    SET(IS_LINKED "")
-    MACRO(ADD_BACKEND_LIBS _LIBS)
-    ENDMACRO()
-ELSE()
-    SET(IS_LINKED " (linked)")
-    MACRO(ADD_BACKEND_LIBS _LIBS)
-        SET(EXTRA_LIBS ${_LIBS} ${EXTRA_LIBS})
-    ENDMACRO()
-ENDIF()
-
-SET(BACKENDS "")
-SET(ALC_OBJS  ${ALC_OBJS}
+set(HAVE_ALSA       0)
+set(HAVE_OSS        0)
+set(HAVE_PIPEWIRE   0)
+set(HAVE_SOLARIS    0)
+set(HAVE_SNDIO      0)
+set(HAVE_DSOUND     0)
+set(HAVE_WASAPI     0)
+set(HAVE_WINMM      0)
+set(HAVE_PORTAUDIO  0)
+set(HAVE_PULSEAUDIO 0)
+set(HAVE_COREAUDIO  0)
+set(HAVE_OPENSL     0)
+set(HAVE_OBOE       0)
+set(HAVE_WAVE       0)
+set(HAVE_SDL2       0)
+
+if(WIN32 OR HAVE_DLFCN_H)
+    set(IS_LINKED "")
+    macro(ADD_BACKEND_LIBS _LIBS)
+    endmacro()
+else()
+    set(IS_LINKED " (linked)")
+    macro(ADD_BACKEND_LIBS _LIBS)
+        set(EXTRA_LIBS ${_LIBS} ${EXTRA_LIBS})
+    endmacro()
+endif()
+
+set(BACKENDS "")
+set(ALC_OBJS  ${ALC_OBJS}
     alc/backends/base.cpp
     alc/backends/base.h
     # Default backends, always available
@@ -766,643 +895,727 @@ SET(ALC_OBJS  ${ALC_OBJS}
     alc/backends/null.h
 )
 
-# Check ALSA backend
-OPTION(ALSOFT_REQUIRE_ALSA "Require ALSA backend" OFF)
-FIND_PACKAGE(ALSA)
-IF(ALSA_FOUND)
-    OPTION(ALSOFT_BACKEND_ALSA "Enable ALSA backend" ON)
-    IF(ALSOFT_BACKEND_ALSA)
-        SET(HAVE_ALSA 1)
-        SET(BACKENDS  "${BACKENDS} ALSA${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/alsa.cpp alc/backends/alsa.h)
-        ADD_BACKEND_LIBS(${ALSA_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${ALSA_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_ALSA AND NOT HAVE_ALSA)
-    MESSAGE(FATAL_ERROR "Failed to enabled required ALSA backend")
-ENDIF()
-
-# Check OSS backend
-OPTION(ALSOFT_REQUIRE_OSS "Require OSS backend" OFF)
-FIND_PACKAGE(OSS)
-IF(OSS_FOUND)
-    OPTION(ALSOFT_BACKEND_OSS "Enable OSS backend" ON)
-    IF(ALSOFT_BACKEND_OSS)
-        SET(HAVE_OSS 1)
-        SET(BACKENDS  "${BACKENDS} OSS,")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/oss.cpp alc/backends/oss.h)
-        IF(OSS_LIBRARIES)
-            SET(EXTRA_LIBS ${OSS_LIBRARIES} ${EXTRA_LIBS})
-        ENDIF()
-        SET(INC_PATHS ${INC_PATHS} ${OSS_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_OSS AND NOT HAVE_OSS)
-    MESSAGE(FATAL_ERROR "Failed to enabled required OSS backend")
-ENDIF()
-
-# Check Solaris backend
-OPTION(ALSOFT_REQUIRE_SOLARIS "Require Solaris backend" OFF)
-FIND_PACKAGE(AudioIO)
-IF(AUDIOIO_FOUND)
-    OPTION(ALSOFT_BACKEND_SOLARIS "Enable Solaris backend" ON)
-    IF(ALSOFT_BACKEND_SOLARIS)
-        SET(HAVE_SOLARIS 1)
-        SET(BACKENDS  "${BACKENDS} Solaris,")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/solaris.cpp alc/backends/solaris.h)
-        SET(INC_PATHS ${INC_PATHS} ${AUDIOIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SOLARIS AND NOT HAVE_SOLARIS)
-    MESSAGE(FATAL_ERROR "Failed to enabled required Solaris backend")
-ENDIF()
-
-# Check SndIO backend
-OPTION(ALSOFT_REQUIRE_SNDIO "Require SndIO backend" OFF)
-FIND_PACKAGE(SoundIO)
-IF(SOUNDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_SNDIO "Enable SndIO backend" ON)
-    IF(ALSOFT_BACKEND_SNDIO)
-        SET(HAVE_SNDIO 1)
-        SET(BACKENDS  "${BACKENDS} SndIO (linked),")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/sndio.cpp alc/backends/sndio.h)
-        SET(EXTRA_LIBS ${SOUNDIO_LIBRARIES} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${SOUNDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SNDIO AND NOT HAVE_SNDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required SndIO backend")
-ENDIF()
-
-# Check QSA backend
-OPTION(ALSOFT_REQUIRE_QSA "Require QSA backend" OFF)
-FIND_PACKAGE(QSA)
-IF(QSA_FOUND)
-    OPTION(ALSOFT_BACKEND_QSA "Enable QSA backend" ON)
-    IF(ALSOFT_BACKEND_QSA)
-        SET(HAVE_QSA 1)
-        SET(BACKENDS  "${BACKENDS} QSA (linked),")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/qsa.cpp alc/backends/qsa.h)
-        SET(EXTRA_LIBS ${QSA_LIBRARIES} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${QSA_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_QSA AND NOT HAVE_QSA)
-    MESSAGE(FATAL_ERROR "Failed to enabled required QSA backend")
-ENDIF()
+# Check PipeWire backend
+option(ALSOFT_BACKEND_PIPEWIRE "Enable PipeWire backend" ON)
+option(ALSOFT_REQUIRE_PIPEWIRE "Require PipeWire backend" OFF)
+if(ALSOFT_BACKEND_PIPEWIRE AND PkgConfig_FOUND)
+    pkg_check_modules(PIPEWIRE libpipewire-0.3>=0.3.23)
+    if(PIPEWIRE_FOUND)
+        set(HAVE_PIPEWIRE 1)
+        set(BACKENDS  "${BACKENDS} PipeWire${IS_LINKED},")
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/pipewire.cpp alc/backends/pipewire.h)
+        add_backend_libs(${PIPEWIRE_LIBRARIES})
+        set(INC_PATHS ${INC_PATHS} ${PIPEWIRE_INCLUDE_DIRS})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_PIPEWIRE AND NOT HAVE_PIPEWIRE)
+    message(FATAL_ERROR "Failed to enabled required PipeWire backend")
+endif()
 
-# Check Windows-only backends
-OPTION(ALSOFT_REQUIRE_WINMM "Require Windows Multimedia backend" OFF)
-OPTION(ALSOFT_REQUIRE_DSOUND "Require DirectSound backend" OFF)
-OPTION(ALSOFT_REQUIRE_WASAPI "Require WASAPI backend" OFF)
-IF(WIN32)
-    SET(WINSDK_LIB_DIRS )
-    SET(WINSDK_INCLUDE_DIRS )
-    FIND_PACKAGE(WindowsSDK)
-    IF(WINDOWSSDK_FOUND)
-        get_windowssdk_library_dirs(${WINDOWSSDK_PREFERRED_DIR} WINSDK_LIB_DIRS)
-        get_windowssdk_include_dirs(${WINDOWSSDK_PREFERRED_DIR} WINSDK_INCLUDE_DIRS)
-    ENDIF()
+# Check PulseAudio backend
+option(ALSOFT_BACKEND_PULSEAUDIO "Enable PulseAudio backend" ON)
+option(ALSOFT_REQUIRE_PULSEAUDIO "Require PulseAudio backend" OFF)
+if(ALSOFT_BACKEND_PULSEAUDIO)
+    find_package(PulseAudio)
+    if(PULSEAUDIO_FOUND)
+        set(HAVE_PULSEAUDIO 1)
+        set(BACKENDS  "${BACKENDS} PulseAudio${IS_LINKED},")
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/pulseaudio.cpp alc/backends/pulseaudio.h)
+        add_backend_libs(${PULSEAUDIO_LIBRARY})
+        set(INC_PATHS ${INC_PATHS} ${PULSEAUDIO_INCLUDE_DIR})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_PULSEAUDIO AND NOT HAVE_PULSEAUDIO)
+    message(FATAL_ERROR "Failed to enabled required PulseAudio backend")
+endif()
 
-    SET(OLD_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
-    SET(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_WIN32_WINNT=0x0502)
+if(NOT WIN32)
+    # Check ALSA backend
+    option(ALSOFT_BACKEND_ALSA "Enable ALSA backend" ON)
+    option(ALSOFT_REQUIRE_ALSA "Require ALSA backend" OFF)
+    if(ALSOFT_BACKEND_ALSA)
+        find_package(ALSA)
+        if(ALSA_FOUND)
+            set(HAVE_ALSA 1)
+            set(BACKENDS  "${BACKENDS} ALSA${IS_LINKED},")
+            set(ALC_OBJS  ${ALC_OBJS} alc/backends/alsa.cpp alc/backends/alsa.h)
+            add_backend_libs(${ALSA_LIBRARIES})
+            set(INC_PATHS ${INC_PATHS} ${ALSA_INCLUDE_DIRS})
+        endif()
+    endif()
 
-    # Check MMSystem backend
-    CHECK_INCLUDE_FILES("windows.h;mmsystem.h" HAVE_MMSYSTEM_H)
-    FIND_LIBRARY(WINMM_LIBRARY NAMES winmm
-        PATHS ${WINSDK_LIB_DIRS}
-        PATH_SUFFIXES lib lib/x86 lib/x64)
-    IF(HAVE_MMSYSTEM_H AND WINMM_LIBRARY)
-        OPTION(ALSOFT_BACKEND_WINMM "Enable Windows Multimedia backend" ON)
-        IF(ALSOFT_BACKEND_WINMM)
-            SET(HAVE_WINMM 1)
-            SET(BACKENDS  "${BACKENDS} WinMM,")
-            SET(ALC_OBJS  ${ALC_OBJS} alc/backends/winmm.cpp alc/backends/winmm.h)
-            SET(EXTRA_LIBS ${WINMM_LIBRARY} ${EXTRA_LIBS})
-        ENDIF()
-    ENDIF()
+    # Check OSS backend
+    option(ALSOFT_BACKEND_OSS "Enable OSS backend" ON)
+    option(ALSOFT_REQUIRE_OSS "Require OSS backend" OFF)
+    if(ALSOFT_BACKEND_OSS)
+        find_package(OSS)
+        if(OSS_FOUND)
+            set(HAVE_OSS 1)
+            set(BACKENDS  "${BACKENDS} OSS,")
+            set(ALC_OBJS  ${ALC_OBJS} alc/backends/oss.cpp alc/backends/oss.h)
+            if(OSS_LIBRARIES)
+                set(EXTRA_LIBS ${OSS_LIBRARIES} ${EXTRA_LIBS})
+            endif()
+            set(INC_PATHS ${INC_PATHS} ${OSS_INCLUDE_DIRS})
+        endif()
+    endif()
 
-    # Check DSound backend
-    FIND_PACKAGE(DSound)
-    IF(DSOUND_FOUND)
-        OPTION(ALSOFT_BACKEND_DSOUND "Enable DirectSound backend" ON)
-        IF(ALSOFT_BACKEND_DSOUND)
-            SET(HAVE_DSOUND 1)
-            SET(BACKENDS  "${BACKENDS} DirectSound${IS_LINKED},")
-            SET(ALC_OBJS  ${ALC_OBJS} alc/backends/dsound.cpp alc/backends/dsound.h)
-            ADD_BACKEND_LIBS(${DSOUND_LIBRARIES})
-            SET(INC_PATHS ${INC_PATHS} ${DSOUND_INCLUDE_DIRS})
-        ENDIF()
-    ENDIF()
+    # Check Solaris backend
+    option(ALSOFT_BACKEND_SOLARIS "Enable Solaris backend" ON)
+    option(ALSOFT_REQUIRE_SOLARIS "Require Solaris backend" OFF)
+    if(ALSOFT_BACKEND_SOLARIS)
+        find_package(AudioIO)
+        if(AUDIOIO_FOUND)
+            set(HAVE_SOLARIS 1)
+            set(BACKENDS  "${BACKENDS} Solaris,")
+            set(ALC_OBJS  ${ALC_OBJS} alc/backends/solaris.cpp alc/backends/solaris.h)
+            set(INC_PATHS ${INC_PATHS} ${AUDIOIO_INCLUDE_DIRS})
+        endif()
+    endif()
 
-    # Check for WASAPI backend
-    CHECK_INCLUDE_FILE(mmdeviceapi.h HAVE_MMDEVICEAPI_H)
-    IF(HAVE_MMDEVICEAPI_H)
-        OPTION(ALSOFT_BACKEND_WASAPI "Enable WASAPI backend" ON)
-        IF(ALSOFT_BACKEND_WASAPI)
-            SET(HAVE_WASAPI 1)
-            SET(BACKENDS  "${BACKENDS} WASAPI,")
-            SET(ALC_OBJS  ${ALC_OBJS} alc/backends/wasapi.cpp alc/backends/wasapi.h)
-        ENDIF()
-    ENDIF()
+    # Check SndIO backend
+    option(ALSOFT_BACKEND_SNDIO "Enable SndIO backend" ON)
+    option(ALSOFT_REQUIRE_SNDIO "Require SndIO backend" OFF)
+    if(ALSOFT_BACKEND_SNDIO)
+        find_package(SoundIO)
+        if(SOUNDIO_FOUND)
+            set(HAVE_SNDIO 1)
+            set(BACKENDS  "${BACKENDS} SndIO (linked),")
+            set(ALC_OBJS  ${ALC_OBJS} alc/backends/sndio.cpp alc/backends/sndio.h)
+            set(EXTRA_LIBS ${SOUNDIO_LIBRARIES} ${EXTRA_LIBS})
+            set(INC_PATHS ${INC_PATHS} ${SOUNDIO_INCLUDE_DIRS})
+        endif()
+    endif()
+endif()
+if(ALSOFT_REQUIRE_ALSA AND NOT HAVE_ALSA)
+    message(FATAL_ERROR "Failed to enabled required ALSA backend")
+endif()
+if(ALSOFT_REQUIRE_OSS AND NOT HAVE_OSS)
+    message(FATAL_ERROR "Failed to enabled required OSS backend")
+endif()
+if(ALSOFT_REQUIRE_SOLARIS AND NOT HAVE_SOLARIS)
+    message(FATAL_ERROR "Failed to enabled required Solaris backend")
+endif()
+if(ALSOFT_REQUIRE_SNDIO AND NOT HAVE_SNDIO)
+    message(FATAL_ERROR "Failed to enabled required SndIO backend")
+endif()
 
-    SET(CMAKE_REQUIRED_DEFINITIONS ${OLD_REQUIRED_DEFINITIONS})
-    UNSET(OLD_REQUIRED_DEFINITIONS)
-ENDIF()
-IF(ALSOFT_REQUIRE_WINMM AND NOT HAVE_WINMM)
-    MESSAGE(FATAL_ERROR "Failed to enabled required WinMM backend")
-ENDIF()
-IF(ALSOFT_REQUIRE_DSOUND AND NOT HAVE_DSOUND)
-    MESSAGE(FATAL_ERROR "Failed to enabled required DSound backend")
-ENDIF()
-IF(ALSOFT_REQUIRE_WASAPI AND NOT HAVE_WASAPI)
-    MESSAGE(FATAL_ERROR "Failed to enabled required WASAPI backend")
-ENDIF()
+# Check Windows-only backends
+if(WIN32)
+    # Check MMSystem backend
+    option(ALSOFT_BACKEND_WINMM "Enable Windows Multimedia backend" ON)
+    option(ALSOFT_REQUIRE_WINMM "Require Windows Multimedia backend" OFF)
+    if(ALSOFT_BACKEND_WINMM)
+        set(HAVE_WINMM 1)
+        set(BACKENDS "${BACKENDS} WinMM,")
+        set(ALC_OBJS ${ALC_OBJS} alc/backends/winmm.cpp alc/backends/winmm.h)
+        # There doesn't seem to be good way to search for winmm.lib for MSVC.
+        # find_library doesn't find it without being told to look in a specific
+        # place in the WindowsSDK, but it links anyway. If there ends up being
+        # Windows targets without this, another means to detect it is needed.
+        set(EXTRA_LIBS winmm ${EXTRA_LIBS})
+    endif()
 
-# Check PortAudio backend
-OPTION(ALSOFT_REQUIRE_PORTAUDIO "Require PortAudio backend" OFF)
-FIND_PACKAGE(PortAudio)
-IF(PORTAUDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_PORTAUDIO "Enable PortAudio backend" ON)
-    IF(ALSOFT_BACKEND_PORTAUDIO)
-        SET(HAVE_PORTAUDIO 1)
-        SET(BACKENDS  "${BACKENDS} PortAudio${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/portaudio.cpp alc/backends/portaudio.h)
-        ADD_BACKEND_LIBS(${PORTAUDIO_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${PORTAUDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_PORTAUDIO AND NOT HAVE_PORTAUDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required PortAudio backend")
-ENDIF()
+    # Check DSound backend
+    option(ALSOFT_BACKEND_DSOUND "Enable DirectSound backend" ON)
+    option(ALSOFT_REQUIRE_DSOUND "Require DirectSound backend" OFF)
+    if(ALSOFT_BACKEND_DSOUND)
+        check_include_file(dsound.h HAVE_DSOUND_H)
+        if(DXSDK_DIR)
+            find_path(DSOUND_INCLUDE_DIR NAMES "dsound.h"
+                PATHS "${DXSDK_DIR}" PATH_SUFFIXES include
+                DOC "The DirectSound include directory")
+        endif()
+        if(HAVE_DSOUND_H OR DSOUND_INCLUDE_DIR)
+            set(HAVE_DSOUND 1)
+            set(BACKENDS "${BACKENDS} DirectSound,")
+            set(ALC_OBJS ${ALC_OBJS} alc/backends/dsound.cpp alc/backends/dsound.h)
 
-# Check PulseAudio backend
-OPTION(ALSOFT_REQUIRE_PULSEAUDIO "Require PulseAudio backend" OFF)
-FIND_PACKAGE(PulseAudio)
-IF(PULSEAUDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_PULSEAUDIO "Enable PulseAudio backend" ON)
-    IF(ALSOFT_BACKEND_PULSEAUDIO)
-        SET(HAVE_PULSEAUDIO 1)
-        SET(BACKENDS  "${BACKENDS} PulseAudio${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/pulseaudio.cpp alc/backends/pulseaudio.h)
-        ADD_BACKEND_LIBS(${PULSEAUDIO_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${PULSEAUDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_PULSEAUDIO AND NOT HAVE_PULSEAUDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required PulseAudio backend")
-ENDIF()
+            if(NOT HAVE_DSOUND_H)
+                set(INC_PATHS ${INC_PATHS} ${DSOUND_INCLUDE_DIR})
+            endif()
+        endif()
+    endif()
+
+    # Check for WASAPI backend
+    option(ALSOFT_BACKEND_WASAPI "Enable WASAPI backend" ON)
+    option(ALSOFT_REQUIRE_WASAPI "Require WASAPI backend" OFF)
+    if(ALSOFT_BACKEND_WASAPI)
+        check_include_file(mmdeviceapi.h HAVE_MMDEVICEAPI_H)
+        if(HAVE_MMDEVICEAPI_H)
+            set(HAVE_WASAPI 1)
+            set(BACKENDS  "${BACKENDS} WASAPI,")
+            set(ALC_OBJS  ${ALC_OBJS} alc/backends/wasapi.cpp alc/backends/wasapi.h)
+        endif()
+    endif()
+endif()
+if(ALSOFT_REQUIRE_WINMM AND NOT HAVE_WINMM)
+    message(FATAL_ERROR "Failed to enabled required WinMM backend")
+endif()
+if(ALSOFT_REQUIRE_DSOUND AND NOT HAVE_DSOUND)
+    message(FATAL_ERROR "Failed to enabled required DSound backend")
+endif()
+if(ALSOFT_REQUIRE_WASAPI AND NOT HAVE_WASAPI)
+    message(FATAL_ERROR "Failed to enabled required WASAPI backend")
+endif()
 
 # Check JACK backend
-OPTION(ALSOFT_REQUIRE_JACK "Require JACK backend" OFF)
-FIND_PACKAGE(JACK)
-IF(JACK_FOUND)
-    OPTION(ALSOFT_BACKEND_JACK "Enable JACK backend" ON)
-    IF(ALSOFT_BACKEND_JACK)
-        SET(HAVE_JACK 1)
-        SET(BACKENDS  "${BACKENDS} JACK${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/jack.cpp alc/backends/jack.h)
-        ADD_BACKEND_LIBS(${JACK_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${JACK_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_JACK AND NOT HAVE_JACK)
-    MESSAGE(FATAL_ERROR "Failed to enabled required JACK backend")
-ENDIF()
+option(ALSOFT_BACKEND_JACK "Enable JACK backend" ON)
+option(ALSOFT_REQUIRE_JACK "Require JACK backend" OFF)
+if(ALSOFT_BACKEND_JACK)
+    find_package(JACK)
+    if(JACK_FOUND)
+        set(HAVE_JACK 1)
+        set(BACKENDS  "${BACKENDS} JACK${IS_LINKED},")
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/jack.cpp alc/backends/jack.h)
+        add_backend_libs(${JACK_LIBRARIES})
+        set(INC_PATHS ${INC_PATHS} ${JACK_INCLUDE_DIRS})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_JACK AND NOT HAVE_JACK)
+    message(FATAL_ERROR "Failed to enabled required JACK backend")
+endif()
 
 # Check CoreAudio backend
-OPTION(ALSOFT_REQUIRE_COREAUDIO "Require CoreAudio backend" OFF)
-FIND_LIBRARY(COREAUDIO_FRAMEWORK
-    NAMES CoreAudio
-    PATHS /System/Library/Frameworks
-)
-IF(COREAUDIO_FRAMEWORK)
-    OPTION(ALSOFT_BACKEND_COREAUDIO "Enable CoreAudio backend" ON)
-    IF(ALSOFT_BACKEND_COREAUDIO)
-        SET(HAVE_COREAUDIO 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/coreaudio.cpp alc/backends/coreaudio.h)
-        SET(BACKENDS  "${BACKENDS} CoreAudio,")
-        SET(EXTRA_LIBS ${COREAUDIO_FRAMEWORK} ${EXTRA_LIBS})
-        SET(EXTRA_LIBS /System/Library/Frameworks/AudioUnit.framework ${EXTRA_LIBS})
-        SET(EXTRA_LIBS /System/Library/Frameworks/ApplicationServices.framework ${EXTRA_LIBS})
+option(ALSOFT_BACKEND_COREAUDIO "Enable CoreAudio backend" ON)
+option(ALSOFT_REQUIRE_COREAUDIO "Require CoreAudio backend" OFF)
+if(ALSOFT_BACKEND_COREAUDIO)
+    find_library(COREAUDIO_FRAMEWORK NAMES CoreAudio)
+    find_path(AUDIOUNIT_INCLUDE_DIR NAMES AudioUnit/AudioUnit.h)
+    if(COREAUDIO_FRAMEWORK AND AUDIOUNIT_INCLUDE_DIR)
+        set(HAVE_COREAUDIO 1)
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/coreaudio.cpp alc/backends/coreaudio.h)
+        set(BACKENDS  "${BACKENDS} CoreAudio,")
+
+        set(EXTRA_LIBS -Wl,-framework,CoreAudio ${EXTRA_LIBS})
+        if(CMAKE_SYSTEM_NAME MATCHES "^(iOS|tvOS)$")
+            find_library(COREFOUNDATION_FRAMEWORK NAMES CoreFoundation)
+            if(COREFOUNDATION_FRAMEWORK)
+                set(EXTRA_LIBS -Wl,-framework,CoreFoundation ${EXTRA_LIBS})
+            endif()
+        else()
+            set(EXTRA_LIBS -Wl,-framework,AudioUnit,-framework,ApplicationServices ${EXTRA_LIBS})
+        endif()
 
         # Some versions of OSX may need the AudioToolbox framework. Add it if
         # it's found.
-        FIND_LIBRARY(AUDIOTOOLBOX_LIBRARY
-            NAMES AudioToolbox
-            PATHS
-                ~/Library/Frameworks
-                /Library/Frameworks
-                /System/Library/Frameworks
-        )
-        IF(AUDIOTOOLBOX_LIBRARY)
-            SET(EXTRA_LIBS ${AUDIOTOOLBOX_LIBRARY} ${EXTRA_LIBS})
-        ENDIF()
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_COREAUDIO AND NOT HAVE_COREAUDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required CoreAudio backend")
-ENDIF()
+        find_library(AUDIOTOOLBOX_LIBRARY NAMES AudioToolbox)
+        if(AUDIOTOOLBOX_LIBRARY)
+            set(EXTRA_LIBS -Wl,-framework,AudioToolbox ${EXTRA_LIBS})
+        endif()
+
+        set(INC_PATHS ${INC_PATHS} ${AUDIOUNIT_INCLUDE_DIR})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_COREAUDIO AND NOT HAVE_COREAUDIO)
+    message(FATAL_ERROR "Failed to enabled required CoreAudio backend")
+endif()
+
+# Check for Oboe (Android) backend
+option(ALSOFT_BACKEND_OBOE "Enable Oboe backend" ON)
+option(ALSOFT_REQUIRE_OBOE "Require Oboe backend" OFF)
+if(ALSOFT_BACKEND_OBOE)
+    set(OBOE_TARGET )
+    if(ANDROID)
+        set(OBOE_SOURCE "" CACHE STRING "Source directory for Oboe.")
+        if(OBOE_SOURCE)
+            add_subdirectory(${OBOE_SOURCE} ./oboe)
+            set(OBOE_TARGET oboe)
+        else()
+            find_package(oboe CONFIG)
+            if(NOT TARGET oboe::oboe)
+                find_package(Oboe)
+            endif()
+            if(TARGET oboe::oboe)
+                set(OBOE_TARGET "oboe::oboe")
+            endif()
+        endif()
+    endif()
+
+    if(OBOE_TARGET)
+        set(HAVE_OBOE 1)
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/oboe.cpp alc/backends/oboe.h)
+        set(BACKENDS  "${BACKENDS} Oboe,")
+        set(EXTRA_LIBS ${OBOE_TARGET} ${EXTRA_LIBS})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_OBOE AND NOT HAVE_OBOE)
+    message(FATAL_ERROR "Failed to enabled required Oboe backend")
+endif()
 
 # Check for OpenSL (Android) backend
-OPTION(ALSOFT_REQUIRE_OPENSL "Require OpenSL backend" OFF)
-FIND_PACKAGE(OpenSL)
-IF(OPENSL_FOUND)
-    OPTION(ALSOFT_BACKEND_OPENSL "Enable OpenSL backend" ON)
-    IF(ALSOFT_BACKEND_OPENSL)
-        SET(HAVE_OPENSL 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/opensl.cpp alc/backends/opensl.h)
-        SET(BACKENDS  "${BACKENDS} OpenSL,")
-        SET(EXTRA_LIBS ${OPENSL_LIBRARIES} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${OPENSL_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_OPENSL AND NOT HAVE_OPENSL)
-    MESSAGE(FATAL_ERROR "Failed to enabled required OpenSL backend")
-ENDIF()
+option(ALSOFT_BACKEND_OPENSL "Enable OpenSL backend" ON)
+option(ALSOFT_REQUIRE_OPENSL "Require OpenSL backend" OFF)
+if(ALSOFT_BACKEND_OPENSL)
+    find_package(OpenSL)
+    if(OPENSL_FOUND)
+        set(HAVE_OPENSL 1)
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/opensl.cpp alc/backends/opensl.h)
+        set(BACKENDS  "${BACKENDS} OpenSL,")
+        set(EXTRA_LIBS "OpenSL::OpenSLES" ${EXTRA_LIBS})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_OPENSL AND NOT HAVE_OPENSL)
+    message(FATAL_ERROR "Failed to enabled required OpenSL backend")
+endif()
+
+# Check PortAudio backend
+option(ALSOFT_BACKEND_PORTAUDIO "Enable PortAudio backend" ON)
+option(ALSOFT_REQUIRE_PORTAUDIO "Require PortAudio backend" OFF)
+if(ALSOFT_BACKEND_PORTAUDIO)
+    find_package(PortAudio)
+    if(PORTAUDIO_FOUND)
+        set(HAVE_PORTAUDIO 1)
+        set(BACKENDS  "${BACKENDS} PortAudio${IS_LINKED},")
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/portaudio.cpp alc/backends/portaudio.h)
+        add_backend_libs(${PORTAUDIO_LIBRARIES})
+        set(INC_PATHS ${INC_PATHS} ${PORTAUDIO_INCLUDE_DIRS})
+    endif()
+endif()
+if(ALSOFT_REQUIRE_PORTAUDIO AND NOT HAVE_PORTAUDIO)
+    message(FATAL_ERROR "Failed to enabled required PortAudio backend")
+endif()
 
 # Check for SDL2 backend
-OPTION(ALSOFT_REQUIRE_SDL2 "Require SDL2 backend" OFF)
-FIND_PACKAGE(SDL2)
-IF(SDL2_FOUND)
-    # Off by default, since it adds a runtime dependency
-    OPTION(ALSOFT_BACKEND_SDL2 "Enable SDL2 backend" OFF)
-    IF(ALSOFT_BACKEND_SDL2)
-        SET(HAVE_SDL2 1)
-        SET(ALC_OBJS  ${ALC_OBJS} alc/backends/sdl2.cpp alc/backends/sdl2.h)
-        SET(BACKENDS  "${BACKENDS} SDL2,")
-        SET(EXTRA_LIBS ${SDL2_LIBRARY} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${SDL2_INCLUDE_DIR})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SDL2 AND NOT SDL2_FOUND)
-    MESSAGE(FATAL_ERROR "Failed to enabled required SDL2 backend")
-ENDIF()
+# Off by default, since it adds a runtime dependency
+option(ALSOFT_BACKEND_SDL2 "Enable SDL2 backend" OFF)
+option(ALSOFT_REQUIRE_SDL2 "Require SDL2 backend" OFF)
+if(ALSOFT_BACKEND_SDL2)
+    if(SDL2_FOUND)
+        set(HAVE_SDL2 1)
+        set(ALC_OBJS  ${ALC_OBJS} alc/backends/sdl2.cpp alc/backends/sdl2.h)
+        set(BACKENDS  "${BACKENDS} SDL2,")
+        set(EXTRA_LIBS ${EXTRA_LIBS} SDL2::SDL2)
+    else()
+        message(STATUS "Could NOT find SDL2")
+    endif()
+endif()
+if(ALSOFT_REQUIRE_SDL2 AND NOT SDL2_FOUND)
+    message(FATAL_ERROR "Failed to enabled required SDL2 backend")
+endif()
 
 # Optionally enable the Wave Writer backend
-OPTION(ALSOFT_BACKEND_WAVE "Enable Wave Writer backend" ON)
-IF(ALSOFT_BACKEND_WAVE)
-    SET(HAVE_WAVE 1)
-    SET(ALC_OBJS  ${ALC_OBJS} alc/backends/wave.cpp alc/backends/wave.h)
-    SET(BACKENDS  "${BACKENDS} WaveFile,")
-ENDIF()
+option(ALSOFT_BACKEND_WAVE "Enable Wave Writer backend" ON)
+if(ALSOFT_BACKEND_WAVE)
+    set(HAVE_WAVE 1)
+    set(ALC_OBJS  ${ALC_OBJS} alc/backends/wave.cpp alc/backends/wave.h)
+    set(BACKENDS  "${BACKENDS} WaveFile,")
+endif()
 
 # This is always available
-SET(BACKENDS  "${BACKENDS} Null")
+set(BACKENDS  "${BACKENDS} Null")
+
 
+find_package(Git)
+if(ALSOFT_UPDATE_BUILD_VERSION AND GIT_FOUND AND EXISTS "${OpenAL_SOURCE_DIR}/.git")
+    set(GIT_DIR "${OpenAL_SOURCE_DIR}/.git")
+
+    # Check if this is a submodule, if it is then find the .git directory
+    if(NOT IS_DIRECTORY "${OpenAL_SOURCE_DIR}/.git")
+        file(READ ${GIT_DIR} submodule)
+        string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE ${submodule})
+        string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+        get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+        get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
+    endif()
 
-FIND_PACKAGE(Git)
-IF(GIT_FOUND AND EXISTS "${OpenAL_SOURCE_DIR}/.git")
     # Get the current working branch and its latest abbreviated commit hash
-    ADD_CUSTOM_TARGET(build_version
-        ${CMAKE_COMMAND} -D GIT_EXECUTABLE=${GIT_EXECUTABLE} -D LIB_VERSION=${LIB_VERSION}
+    add_custom_command(OUTPUT "${OpenAL_BINARY_DIR}/version_witness.txt"
+        BYPRODUCTS "${OpenAL_BINARY_DIR}/version.h"
+        COMMAND ${CMAKE_COMMAND} -D GIT_EXECUTABLE=${GIT_EXECUTABLE} -D LIB_VERSION=${LIB_VERSION}
             -D LIB_VERSION_NUM=${LIB_VERSION_NUM} -D SRC=${OpenAL_SOURCE_DIR}/version.h.in
             -D DST=${OpenAL_BINARY_DIR}/version.h -P ${OpenAL_SOURCE_DIR}/version.cmake
+        COMMAND ${CMAKE_COMMAND} -E touch "${OpenAL_BINARY_DIR}/version_witness.txt"
         WORKING_DIRECTORY "${OpenAL_SOURCE_DIR}"
+        MAIN_DEPENDENCY "${OpenAL_SOURCE_DIR}/version.h.in"
+        DEPENDS "${GIT_DIR}/index" "${OpenAL_SOURCE_DIR}/version.cmake"
         VERBATIM
     )
-ELSE()
-    SET(GIT_BRANCH "UNKNOWN")
-    SET(GIT_COMMIT_HASH "unknown")
-    CONFIGURE_FILE(
+
+    add_custom_target(build_version DEPENDS "${OpenAL_BINARY_DIR}/version_witness.txt")
+else()
+    set(GIT_BRANCH "UNKNOWN")
+    set(GIT_COMMIT_HASH "unknown")
+    configure_file(
         "${OpenAL_SOURCE_DIR}/version.h.in"
         "${OpenAL_BINARY_DIR}/version.h")
-ENDIF()
+endif()
 
 IF(NOT CMAKE_CROSSCOMPILING)
 
-SET(NATIVE_SRC_DIR  "${OpenAL_SOURCE_DIR}/native-tools")
-
-SET(ALSOFT_NATIVE_TOOLS_PATH "" CACHE STRING "Path to prebuilt native tools (leave blank to auto-build)")
-IF(ALSOFT_NATIVE_TOOLS_PATH)
-    find_program(BIN2H_NATIVE_COMMAND NAMES bin2h
-        PATHS "${ALSOFT_NATIVE_TOOLS_PATH}"
-        NO_DEFAULT_PATH)
-    find_program(BSINCGEN_NATIVE_COMMAND NAMES bsincgen
-        PATHS "${ALSOFT_NATIVE_TOOLS_PATH}"
-        NO_DEFAULT_PATH)
-    if(NOT BIN2H_NATIVE_COMMAND OR NOT BSINCGEN_NATIVE_COMMAND)
-        message(FATAL_ERROR "Failed to find native tools in ${ALSOFT_NATIVE_TOOLS_PATH}.
-bin2h: ${BIN2H_NATIVE_COMMAND}
-bsincgen: ${BSINCGEN_NATIVE_COMMAND}")
-    endif()
-    SET(BIN2H_COMMAND  ${BIN2H_NATIVE_COMMAND})
-    SET(BSINCGEN_COMMAND  ${BSINCGEN_NATIVE_COMMAND})
-ELSE()
-    SET(NATIVE_BIN_DIR  "${OpenAL_BINARY_DIR}/native-tools")
-    FILE(MAKE_DIRECTORY "${NATIVE_BIN_DIR}")
-
-    SET(BIN2H_COMMAND  "${NATIVE_BIN_DIR}/bin2h")
-    SET(BSINCGEN_COMMAND  "${NATIVE_BIN_DIR}/bsincgen")
-    ADD_CUSTOM_COMMAND(OUTPUT "${BIN2H_COMMAND}" "${BSINCGEN_COMMAND}"
-        COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" "${NATIVE_SRC_DIR}"
-        COMMAND ${CMAKE_COMMAND} -E remove "${BIN2H_COMMAND}" "${BSINCGEN_COMMAND}"
-        COMMAND ${CMAKE_COMMAND} --build . --config "Release"
-        WORKING_DIRECTORY "${NATIVE_BIN_DIR}"
-        DEPENDS "${NATIVE_SRC_DIR}/CMakeLists.txt"
-        IMPLICIT_DEPENDS
-            C "${NATIVE_SRC_DIR}/bin2h.c"
-            C "${NATIVE_SRC_DIR}/bsincgen.c"
-        VERBATIM
-    )
-ENDIF()
-ADD_CUSTOM_TARGET(native-tools
-    DEPENDS "${BIN2H_COMMAND}" "${BSINCGEN_COMMAND}"
-    VERBATIM
-)
-
 option(ALSOFT_EMBED_HRTF_DATA "Embed the HRTF data files (increases library footprint)" ON)
 if(ALSOFT_EMBED_HRTF_DATA)
-    MACRO(make_hrtf_header FILENAME VARNAME)
-        SET(infile  "${OpenAL_SOURCE_DIR}/hrtf/${FILENAME}")
-        SET(outfile  "${OpenAL_BINARY_DIR}/${FILENAME}.h")
-
-        ADD_CUSTOM_COMMAND(OUTPUT "${outfile}"
-            COMMAND "${BIN2H_COMMAND}" "${infile}" "${outfile}" ${VARNAME}
-            DEPENDS native-tools "${infile}"
+    macro(make_hrtf_header FILENAME VARNAME)
+        set(infile  "${OpenAL_SOURCE_DIR}/hrtf/${FILENAME}")
+        set(outfile  "${OpenAL_BINARY_DIR}/${VARNAME}.txt")
+
+        add_custom_command(OUTPUT "${outfile}"
+            COMMAND ${CMAKE_COMMAND} -D "INPUT_FILE=${infile}" -D "OUTPUT_FILE=${outfile}"
+                -P "${CMAKE_MODULE_PATH}/bin2h.script.cmake"
+            WORKING_DIRECTORY "${OpenAL_SOURCE_DIR}"
+            DEPENDS "${infile}" "${CMAKE_MODULE_PATH}/bin2h.script.cmake"
             VERBATIM
         )
-        SET(ALC_OBJS  ${ALC_OBJS} "${outfile}")
-    ENDMACRO()
+        set(ALC_OBJS  ${ALC_OBJS} "${outfile}")
+    endmacro()
 
-    make_hrtf_header(default-44100.mhr "hrtf_default_44100")
-    make_hrtf_header(default-48000.mhr "hrtf_default_48000")
+    make_hrtf_header("Default HRTF.mhr" "default_hrtf")
 endif()
 
-ADD_CUSTOM_COMMAND(OUTPUT "${OpenAL_BINARY_DIR}/bsinc_inc.h"
-    COMMAND "${BSINCGEN_COMMAND}" "${OpenAL_BINARY_DIR}/bsinc_inc.h"
-    DEPENDS native-tools "${NATIVE_SRC_DIR}/bsincgen.c"
-    VERBATIM
-)
-SET(ALC_OBJS  ${ALC_OBJS} "${OpenAL_BINARY_DIR}/bsinc_inc.h")
-
-
-IF(ALSOFT_UTILS AND NOT ALSOFT_NO_CONFIG_UTIL)
-    add_subdirectory(utils/alsoft-config)
-ENDIF()
-IF(ALSOFT_EXAMPLES)
-    IF(NOT SDL2_FOUND)
-        FIND_PACKAGE(SDL2)
-    ENDIF()
-    IF(SDL2_FOUND)
-        FIND_PACKAGE(SDL_sound)
-        FIND_PACKAGE(FFmpeg COMPONENTS AVFORMAT AVCODEC AVUTIL SWSCALE SWRESAMPLE)
-    ENDIF()
-ENDIF()
-
-# For crosscompiling, caller must provide the bsinc_inc.h file
-# SET(ALC_OBJS  ${ALC_OBJS} "${OpenAL_BINARY_DIR}/bsinc_inc.h")
 
-ENDIF(NOT CMAKE_CROSSCOMPILING)
+if(ALSOFT_UTILS)
+    find_package(MySOFA)
+    if(NOT ALSOFT_NO_CONFIG_UTIL)
+        find_package(Qt5Widgets QUIET)
+        if(NOT Qt5Widgets_FOUND)
+            message(STATUS "Could NOT find Qt5Widgets")
+        endif()
+    endif()
+endif()
+if(ALSOFT_UTILS OR ALSOFT_EXAMPLES)
+    find_package(SndFile)
+    if(SDL2_FOUND)
+        find_package(FFmpeg COMPONENTS AVFORMAT AVCODEC AVUTIL SWSCALE SWRESAMPLE)
+    endif()
+endif()
 
-IF(NOT WIN32)
-    SET(LIBNAME "openal")
-ELSE()
-    SET(LIBNAME "OpenAL32")
-ENDIF()
+if(NOT WIN32)
+    set(LIBNAME "openal")
+else()
+    set(LIBNAME "OpenAL32")
+endif()
 
 # Needed for openal.pc.in
-SET(prefix ${CMAKE_INSTALL_PREFIX})
-SET(exec_prefix "\${prefix}")
-SET(libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-SET(bindir "\${exec_prefix}/${CMAKE_INSTALL_BINDIR}")
-SET(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-SET(PACKAGE_VERSION "${LIB_VERSION}")
-SET(PKG_CONFIG_CFLAGS )
-SET(PKG_CONFIG_PRIVATE_LIBS )
-IF(LIBTYPE STREQUAL "STATIC")
-    SET(PKG_CONFIG_CFLAGS -DAL_LIBTYPE_STATIC)
-    FOREACH(FLAG  ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix "\${prefix}")
+set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
+set(bindir "${CMAKE_INSTALL_FULL_BINDIR}")
+set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
+set(PACKAGE_VERSION "${LIB_VERSION}")
+set(PKG_CONFIG_CFLAGS )
+set(PKG_CONFIG_PRIVATE_LIBS )
+if(LIBTYPE STREQUAL "STATIC")
+    set(PKG_CONFIG_CFLAGS -DAL_LIBTYPE_STATIC)
+    foreach(FLAG  ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
         # If this is already a linker flag, or is a full path+file, add it
-        # as-is. Otherwise, it's a name intended to be dressed as -lname.
-        IF(FLAG MATCHES "^-.*" OR EXISTS "${FLAG}")
-            SET(PKG_CONFIG_PRIVATE_LIBS "${PKG_CONFIG_PRIVATE_LIBS} ${FLAG}")
-        ELSE()
-            SET(PKG_CONFIG_PRIVATE_LIBS "${PKG_CONFIG_PRIVATE_LIBS} -l${FLAG}")
-        ENDIF()
-    ENDFOREACH()
-ENDIF()
+        # as-is. If it's an SDL2 target, add the link flag for it. Otherwise,
+        # it's a name intended to be dressed as -lname.
+        if(FLAG MATCHES "^-.*" OR EXISTS "${FLAG}")
+            set(PKG_CONFIG_PRIVATE_LIBS "${PKG_CONFIG_PRIVATE_LIBS} ${FLAG}")
+        elseif(FLAG MATCHES "^SDL2::SDL2")
+            set(PKG_CONFIG_PRIVATE_LIBS "${PKG_CONFIG_PRIVATE_LIBS} -lSDL2")
+        else()
+            set(PKG_CONFIG_PRIVATE_LIBS "${PKG_CONFIG_PRIVATE_LIBS} -l${FLAG}")
+        endif()
+    endforeach()
+endif()
 
 # End configuration
-CONFIGURE_FILE(
+configure_file(
     "${OpenAL_SOURCE_DIR}/config.h.in"
     "${OpenAL_BINARY_DIR}/config.h")
-CONFIGURE_FILE(
+configure_file(
     "${OpenAL_SOURCE_DIR}/openal.pc.in"
     "${OpenAL_BINARY_DIR}/openal.pc"
     @ONLY)
 
 
-ADD_LIBRARY(common STATIC EXCLUDE_FROM_ALL ${COMMON_OBJS})
-TARGET_INCLUDE_DIRECTORIES(common PRIVATE ${OpenAL_BINARY_DIR} ${OpenAL_SOURCE_DIR}/include)
-TARGET_COMPILE_DEFINITIONS(common PRIVATE ${CPP_DEFS})
-TARGET_COMPILE_OPTIONS(common PRIVATE ${C_FLAGS})
-SET_TARGET_PROPERTIES(common PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+add_library(common STATIC EXCLUDE_FROM_ALL ${COMMON_OBJS})
+target_include_directories(common PRIVATE ${OpenAL_BINARY_DIR} ${OpenAL_SOURCE_DIR}/include)
+target_compile_definitions(common PRIVATE ${CPP_DEFS})
+target_compile_options(common PRIVATE ${C_FLAGS})
+set_target_properties(common PROPERTIES ${DEFAULT_TARGET_PROPS} POSITION_INDEPENDENT_CODE TRUE)
 
 
-UNSET(HAS_ROUTER)
-SET(IMPL_TARGET OpenAL) # Either OpenAL or soft_oal.
-SET(SUBSYS_FLAG )
+unset(HAS_ROUTER)
+set(IMPL_TARGET OpenAL) # Either OpenAL or soft_oal.
 
 # Build main library
-IF(LIBTYPE STREQUAL "STATIC")
-    SET(CPP_DEFS ${CPP_DEFS} AL_LIBTYPE_STATIC)
-    IF(WIN32 AND ALSOFT_NO_UID_DEFS)
-        SET(CPP_DEFS ${CPP_DEFS} AL_NO_UID_DEFS)
-    ENDIF()
-    ADD_LIBRARY(${IMPL_TARGET} STATIC ${COMMON_OBJS} ${OPENAL_OBJS} ${ALC_OBJS})
-    TARGET_LINK_LIBRARIES(${IMPL_TARGET} PRIVATE ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
-ELSE()
-    IF(WIN32)
-        IF(MSVC)
-            SET(SUBSYS_FLAG ${SUBSYS_FLAG} "/SUBSYSTEM:WINDOWS")
-        ELSEIF(CMAKE_COMPILER_IS_GNUCC)
-            SET(SUBSYS_FLAG ${SUBSYS_FLAG} "-mwindows")
-        ENDIF()
-    ENDIF()
+if(LIBTYPE STREQUAL "STATIC")
+    add_library(${IMPL_TARGET} STATIC ${COMMON_OBJS} ${OPENAL_OBJS} ${ALC_OBJS} ${CORE_OBJS})
+    target_compile_definitions(${IMPL_TARGET} PUBLIC AL_LIBTYPE_STATIC)
+    target_link_libraries(${IMPL_TARGET} PRIVATE ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
 
-    SET(RC_CONFIG resources/openal32.rc)
-    IF(WIN32 AND ALSOFT_BUILD_ROUTER)
-        ADD_LIBRARY(OpenAL SHARED
+    if(WIN32)
+        # This option is for static linking OpenAL Soft into another project
+        # that already defines the IDs. It is up to that project to ensure all
+        # required IDs are defined.
+        option(ALSOFT_NO_UID_DEFS "Do not define GUIDs, IIDs, CLSIDs, or PropertyKeys" OFF)
+        if(ALSOFT_NO_UID_DEFS)
+            target_compile_definitions(${IMPL_TARGET} PRIVATE AL_NO_UID_DEFS)
+        endif()
+    endif()
+else()
+    set(RC_CONFIG resources/openal32.rc)
+    if(WIN32 AND ALSOFT_BUILD_ROUTER)
+        add_library(OpenAL SHARED
             resources/router.rc
             router/router.cpp
             router/router.h
             router/alc.cpp
             router/al.cpp
         )
-        TARGET_COMPILE_DEFINITIONS(OpenAL
-            PRIVATE AL_BUILD_LIBRARY AL_ALEXT_PROTOTYPES ${CPP_DEFS})
-        TARGET_COMPILE_OPTIONS(OpenAL PRIVATE ${C_FLAGS})
-        TARGET_LINK_LIBRARIES(OpenAL PRIVATE common ${LINKER_FLAGS})
-        TARGET_INCLUDE_DIRECTORIES(OpenAL
+        target_compile_definitions(OpenAL
+            PRIVATE AL_BUILD_LIBRARY AL_ALEXT_PROTOTYPES "ALC_API=${EXPORT_DECL}"
+            "AL_API=${EXPORT_DECL}" ${CPP_DEFS})
+        target_compile_options(OpenAL PRIVATE ${C_FLAGS})
+        target_link_libraries(OpenAL PRIVATE common ${LINKER_FLAGS})
+        target_include_directories(OpenAL
           PUBLIC
             $<BUILD_INTERFACE:${OpenAL_SOURCE_DIR}/include>
-            $<INSTALL_INTERFACE:include>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
           PRIVATE
             ${OpenAL_SOURCE_DIR}/common
             ${OpenAL_BINARY_DIR}
         )
-        SET_TARGET_PROPERTIES(OpenAL PROPERTIES PREFIX "")
-        SET_TARGET_PROPERTIES(OpenAL PROPERTIES OUTPUT_NAME ${LIBNAME})
-        IF(TARGET build_version)
-            ADD_DEPENDENCIES(OpenAL build_version)
-        ENDIF()
-        SET(HAS_ROUTER 1)
+        set_target_properties(OpenAL PROPERTIES ${DEFAULT_TARGET_PROPS} PREFIX ""
+            OUTPUT_NAME ${LIBNAME})
+        if(TARGET build_version)
+            add_dependencies(OpenAL build_version)
+        endif()
+        set(HAS_ROUTER 1)
 
-        SET(LIBNAME "soft_oal")
-        SET(IMPL_TARGET soft_oal)
-        SET(RC_CONFIG resources/soft_oal.rc)
-    ENDIF()
+        set(LIBNAME "soft_oal")
+        set(IMPL_TARGET soft_oal)
+        set(RC_CONFIG resources/soft_oal.rc)
+    endif()
 
-    ADD_LIBRARY(${IMPL_TARGET} SHARED ${OPENAL_OBJS} ${ALC_OBJS} ${RC_CONFIG})
-    IF(WIN32)
-        SET_TARGET_PROPERTIES(${IMPL_TARGET} PROPERTIES PREFIX "")
-    ENDIF()
-    TARGET_LINK_LIBRARIES(${IMPL_TARGET} PRIVATE common ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
-ENDIF()
+    # !important: for osx framework public header works, the headers must be in
+    # the project
+    set(TARGET_PUBLIC_HEADERS include/AL/al.h include/AL/alc.h include/AL/alext.h include/AL/efx.h
+        include/AL/efx-presets.h)
 
-TARGET_INCLUDE_DIRECTORIES(${IMPL_TARGET}
+    add_library(${IMPL_TARGET} SHARED ${OPENAL_OBJS} ${ALC_OBJS} ${CORE_OBJS} ${RC_CONFIG}
+        ${TARGET_PUBLIC_HEADERS})
+    if(WIN32)
+        set_target_properties(${IMPL_TARGET} PROPERTIES PREFIX "")
+    endif()
+    target_link_libraries(${IMPL_TARGET} PRIVATE common ${LINKER_FLAGS} ${EXTRA_LIBS} ${MATH_LIB})
+
+    if(NOT WIN32 AND NOT APPLE)
+        # FIXME: This doesn't put a dependency on the version script. Changing
+        # the version script will not cause a relink as it should.
+        set_property(TARGET ${IMPL_TARGET} APPEND_STRING PROPERTY
+            LINK_FLAGS " -Wl,--version-script=${OpenAL_SOURCE_DIR}/libopenal.version")
+    endif()
+
+    if(APPLE AND ALSOFT_OSX_FRAMEWORK)
+        # Sets framework name to soft_oal to avoid ambiguity with the system OpenAL.framework
+        set(LIBNAME "soft_oal")
+        if(GIT_FOUND)
+            execute_process(COMMAND ${GIT_EXECUTABLE} rev-list --count HEAD
+                TIMEOUT 5
+                OUTPUT_VARIABLE BUNDLE_VERSION
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+        else()
+            set(BUNDLE_VERSION 1)
+        endif()
+
+        # Build: Fix rpath in iOS shared libraries
+        # If this flag is not set, the final dylib binary ld path will be
+        # /User/xxx/*/soft_oal.framework/soft_oal, which can't be loaded by iOS devices.
+        # See also: https://github.com/libjpeg-turbo/libjpeg-turbo/commit/c80ddef7a4ce21ace9e3ca0fd190d320cc8cdaeb
+        if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
+            set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
+        endif()
+
+        set_target_properties(${IMPL_TARGET} PROPERTIES
+            FRAMEWORK TRUE
+            FRAMEWORK_VERSION C
+            MACOSX_FRAMEWORK_NAME "${IMPL_TARGET}"
+            MACOSX_FRAMEWORK_IDENTIFIER "org.openal-soft.openal"
+            MACOSX_FRAMEWORK_SHORT_VERSION_STRING "${LIB_VERSION}"
+            MACOSX_FRAMEWORK_BUNDLE_VERSION "${BUNDLE_VERSION}"
+            XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ""
+            XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO"
+            XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO"
+            PUBLIC_HEADER "${TARGET_PUBLIC_HEADERS}"
+            MACOSX_RPATH TRUE)
+    endif()
+endif()
+
+target_include_directories(${IMPL_TARGET}
   PUBLIC
     $<BUILD_INTERFACE:${OpenAL_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include>
+  INTERFACE
+    $<BUILD_INTERFACE:${OpenAL_SOURCE_DIR}/include/AL>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/AL>
   PRIVATE
     ${INC_PATHS}
     ${OpenAL_BINARY_DIR}
     ${OpenAL_SOURCE_DIR}
-    ${OpenAL_SOURCE_DIR}/alc
     ${OpenAL_SOURCE_DIR}/common
 )
 
-SET_TARGET_PROPERTIES(${IMPL_TARGET} PROPERTIES OUTPUT_NAME ${LIBNAME}
+set_target_properties(${IMPL_TARGET} PROPERTIES ${DEFAULT_TARGET_PROPS}
+    OUTPUT_NAME ${LIBNAME}
     VERSION ${LIB_VERSION}
     SOVERSION ${LIB_MAJOR_VERSION}
 )
-TARGET_COMPILE_DEFINITIONS(${IMPL_TARGET}
-    PRIVATE AL_BUILD_LIBRARY AL_ALEXT_PROTOTYPES ${CPP_DEFS})
-TARGET_COMPILE_OPTIONS(${IMPL_TARGET} PRIVATE ${C_FLAGS})
-
-IF(TARGET build_version)
-    ADD_DEPENDENCIES(${IMPL_TARGET} build_version)
-ENDIF()
-
-IF(WIN32 AND MINGW AND ALSOFT_BUILD_IMPORT_LIB AND NOT LIBTYPE STREQUAL "STATIC")
-    FIND_PROGRAM(SED_EXECUTABLE NAMES sed DOC "sed executable")
-    FIND_PROGRAM(DLLTOOL_EXECUTABLE NAMES "${DLLTOOL}" DOC "dlltool executable")
-    IF(NOT SED_EXECUTABLE OR NOT DLLTOOL_EXECUTABLE)
-        MESSAGE(STATUS "")
-        IF(NOT SED_EXECUTABLE)
-            MESSAGE(STATUS "WARNING: Cannot find sed, disabling .def/.lib generation")
-        ENDIF()
-        IF(NOT DLLTOOL_EXECUTABLE)
-            MESSAGE(STATUS "WARNING: Cannot find dlltool, disabling .def/.lib generation")
-        ENDIF()
-    ELSE()
-        SET_PROPERTY(TARGET OpenAL APPEND_STRING PROPERTY
+target_compile_definitions(${IMPL_TARGET}
+    PRIVATE AL_BUILD_LIBRARY AL_ALEXT_PROTOTYPES "ALC_API=${EXPORT_DECL}" "AL_API=${EXPORT_DECL}"
+    ${CPP_DEFS})
+target_compile_options(${IMPL_TARGET} PRIVATE ${C_FLAGS})
+
+if(TARGET build_version)
+    add_dependencies(${IMPL_TARGET} build_version)
+endif()
+
+if(WIN32 AND MINGW AND ALSOFT_BUILD_IMPORT_LIB AND NOT LIBTYPE STREQUAL "STATIC")
+    find_program(SED_EXECUTABLE NAMES sed DOC "sed executable")
+    if(NOT SED_EXECUTABLE OR NOT CMAKE_DLLTOOL)
+        message(STATUS "")
+        if(NOT SED_EXECUTABLE)
+            message(STATUS "WARNING: Cannot find sed, disabling .def/.lib generation")
+        endif()
+        if(NOT CMAKE_DLLTOOL)
+            message(STATUS "WARNING: Cannot find dlltool, disabling .def/.lib generation")
+        endif()
+    else()
+        set_property(TARGET OpenAL APPEND_STRING PROPERTY
             LINK_FLAGS " -Wl,--output-def,OpenAL32.def")
-        ADD_CUSTOM_COMMAND(TARGET OpenAL POST_BUILD
+        add_custom_command(TARGET OpenAL POST_BUILD
             COMMAND "${SED_EXECUTABLE}" -i -e "s/ @[^ ]*//" OpenAL32.def
-            COMMAND "${DLLTOOL_EXECUTABLE}" -d OpenAL32.def -l OpenAL32.lib -D OpenAL32.dll
+            COMMAND "${CMAKE_DLLTOOL}" -d OpenAL32.def -l OpenAL32.lib -D OpenAL32.dll
+            # Technically OpenAL32.def was created by the build, but cmake
+            # doesn't recognize it due to -Wl,--output-def,OpenAL32.def being
+            # manually specified. But declaring the file here allows it to be
+            # properly cleaned, e.g. during make clean.
+            BYPRODUCTS OpenAL32.def OpenAL32.lib
             COMMENT "Stripping ordinals from OpenAL32.def and generating OpenAL32.lib..."
             VERBATIM
         )
-    ENDIF()
-ENDIF()
+    endif()
+endif()
+
+if(HAS_ROUTER)
+    message(STATUS "")
+    message(STATUS "Building DLL router")
+endif()
+
+message(STATUS "")
+message(STATUS "Building OpenAL with support for the following backends:")
+message(STATUS "   ${BACKENDS}")
+message(STATUS "")
+message(STATUS "Building with support for CPU extensions:")
+message(STATUS "    ${CPU_EXTS}")
+message(STATUS "")
+if(FPMATH_SET)
+    message(STATUS "Building with SSE${FPMATH_SET} codegen")
+    message(STATUS "")
+endif()
+
+if(ALSOFT_EAX)
+    message(STATUS "Building with legacy EAX extension support")
+    message(STATUS "")
+endif()
+
+if(ALSOFT_EMBED_HRTF_DATA)
+    message(STATUS "Embedding HRTF datasets")
+    message(STATUS "")
+endif()
+
+# An alias for sub-project builds
+add_library(OpenAL::OpenAL ALIAS OpenAL)
 
-IF(ALSOFT_INSTALL)
-    INSTALL(TARGETS OpenAL EXPORT OpenAL
+# Install main library
+if(ALSOFT_INSTALL)
+    configure_package_config_file(OpenALConfig.cmake.in OpenALConfig.cmake
+        INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/OpenAL)
+    install(TARGETS OpenAL EXPORT OpenAL
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR}
         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/AL)
-    EXPORT(TARGETS OpenAL
+    export(TARGETS OpenAL
         NAMESPACE OpenAL::
-        FILE OpenALConfig.cmake)
-    INSTALL(EXPORT OpenAL
+        FILE OpenALTargets.cmake)
+    install(EXPORT OpenAL
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/OpenAL
         NAMESPACE OpenAL::
-        FILE OpenALConfig.cmake)
-    INSTALL(FILES
-        include/AL/al.h
-        include/AL/alc.h
-        include/AL/alext.h
-        include/AL/efx.h
-        include/AL/efx-creative.h
-        include/AL/efx-presets.h
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/AL)
-    INSTALL(FILES "${OpenAL_BINARY_DIR}/openal.pc"
+        FILE OpenALTargets.cmake)
+    install(DIRECTORY include/AL
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    install(FILES "${OpenAL_BINARY_DIR}/openal.pc"
         DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-    IF(TARGET soft_oal)
-        INSTALL(TARGETS soft_oal
+    install(FILES "${OpenAL_BINARY_DIR}/OpenALConfig.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/OpenAL")
+    if(TARGET soft_oal)
+        install(TARGETS soft_oal
             RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    ENDIF()
-ENDIF()
+    endif()
+    message(STATUS "Installing library and headers")
+else()
+    message(STATUS "NOT installing library and headers")
+endif()
 
+if(ALSOFT_INSTALL_CONFIG)
+    install(FILES alsoftrc.sample
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal)
+    message(STATUS "Installing sample configuration")
+endif()
 
-if(HAS_ROUTER)
-    message(STATUS "")
-    message(STATUS "Building DLL router")
+if(ALSOFT_INSTALL_HRTF_DATA)
+    install(DIRECTORY hrtf
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal)
+    message(STATUS "Installing HRTF data files")
 endif()
 
-MESSAGE(STATUS "")
-MESSAGE(STATUS "Building OpenAL with support for the following backends:")
-MESSAGE(STATUS "    ${BACKENDS}")
-MESSAGE(STATUS "")
-MESSAGE(STATUS "Building with support for CPU extensions:")
-MESSAGE(STATUS "    ${CPU_EXTS}")
-MESSAGE(STATUS "")
-IF(FPMATH_SET)
-    MESSAGE(STATUS "Building with SSE${FPMATH_SET} codegen")
-    MESSAGE(STATUS "")
-ENDIF()
+if(ALSOFT_INSTALL_AMBDEC_PRESETS)
+    install(DIRECTORY presets
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal)
+    message(STATUS "Installing AmbDec presets")
+endif()
+message(STATUS "")
 
-if(ALSOFT_EMBED_HRTF_DATA)
-    message(STATUS "Embedding HRTF datasets")
-    message(STATUS "")
+set(UNICODE_FLAG )
+if(MINGW)
+    set(UNICODE_FLAG ${UNICODE_FLAG} -municode)
 endif()
+set(EXTRA_INSTALLS )
+if(ALSOFT_UTILS)
+    add_executable(openal-info utils/openal-info.c)
+    target_include_directories(openal-info PRIVATE ${OpenAL_SOURCE_DIR}/common)
+    target_compile_options(openal-info PRIVATE ${C_FLAGS})
+    target_link_libraries(openal-info PRIVATE ${LINKER_FLAGS} OpenAL ${UNICODE_FLAG})
+    set_target_properties(openal-info PROPERTIES ${DEFAULT_TARGET_PROPS})
+    if(ALSOFT_INSTALL_EXAMPLES)
+        set(EXTRA_INSTALLS ${EXTRA_INSTALLS} openal-info)
+    endif()
 
-# Install alsoft.conf configuration file
-IF(ALSOFT_CONFIG)
-    INSTALL(FILES alsoftrc.sample
-        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal)
-    MESSAGE(STATUS "Installing sample configuration")
-    MESSAGE(STATUS "")
-ENDIF()
-
-# Install HRTF definitions
-IF(ALSOFT_HRTF_DEFS)
-    INSTALL(FILES hrtf/default-44100.mhr hrtf/default-48000.mhr
-        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal/hrtf)
-    MESSAGE(STATUS "Installing HRTF definitions")
-    MESSAGE(STATUS "")
-ENDIF()
-
-# Install AmbDec presets
-IF(ALSOFT_AMBDEC_PRESETS)
-    INSTALL(FILES
-        presets/3D7.1.ambdec
-        presets/hexagon.ambdec
-        presets/itu5.1.ambdec
-        presets/itu5.1-nocenter.ambdec
-        presets/rectangle.ambdec
-        presets/square.ambdec
-        presets/presets.txt
-        DESTINATION ${CMAKE_INSTALL_DATADIR}/openal/presets)
-    MESSAGE(STATUS "Installing AmbDec presets")
-    MESSAGE(STATUS "")
-ENDIF()
-
-IF(ALSOFT_UTILS)
-    set(UTIL_TARGETS )
-
-    ADD_EXECUTABLE(openal-info utils/openal-info.c)
-    TARGET_INCLUDE_DIRECTORIES(openal-info PRIVATE ${OpenAL_SOURCE_DIR}/common)
-    TARGET_COMPILE_OPTIONS(openal-info PRIVATE ${C_FLAGS})
-    TARGET_LINK_LIBRARIES(openal-info PRIVATE ${LINKER_FLAGS} OpenAL)
-    set(UTIL_TARGETS ${UTIL_TARGETS} openal-info)
+    if(SNDFILE_FOUND)
+        add_executable(uhjdecoder utils/uhjdecoder.cpp)
+        target_compile_definitions(uhjdecoder PRIVATE ${CPP_DEFS})
+        target_include_directories(uhjdecoder
+            PRIVATE ${OpenAL_BINARY_DIR} ${OpenAL_SOURCE_DIR}/common)
+        target_compile_options(uhjdecoder PRIVATE ${C_FLAGS})
+        target_link_libraries(uhjdecoder PUBLIC common
+            PRIVATE ${LINKER_FLAGS} SndFile::SndFile ${UNICODE_FLAG})
+        set_target_properties(uhjdecoder PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(uhjencoder utils/uhjencoder.cpp)
+        target_compile_definitions(uhjencoder PRIVATE ${CPP_DEFS})
+        target_include_directories(uhjencoder
+            PRIVATE ${OpenAL_BINARY_DIR} ${OpenAL_SOURCE_DIR}/common)
+        target_compile_options(uhjencoder PRIVATE ${C_FLAGS})
+        target_link_libraries(uhjencoder PUBLIC common
+            PRIVATE ${LINKER_FLAGS} SndFile::SndFile ${UNICODE_FLAG})
+        set_target_properties(uhjencoder PROPERTIES ${DEFAULT_TARGET_PROPS})
+    endif()
 
-    find_package(MySOFA)
     if(MYSOFA_FOUND)
+        set(SOFA_SUPPORT_SRCS
+            utils/sofa-support.cpp
+            utils/sofa-support.h)
+        add_library(sofa-support STATIC EXCLUDE_FROM_ALL ${SOFA_SUPPORT_SRCS})
+        target_compile_definitions(sofa-support PRIVATE ${CPP_DEFS})
+        target_include_directories(sofa-support PUBLIC ${OpenAL_SOURCE_DIR}/common)
+        target_compile_options(sofa-support PRIVATE ${C_FLAGS})
+        target_link_libraries(sofa-support PUBLIC common MySOFA::MySOFA PRIVATE ${LINKER_FLAGS})
+        set_target_properties(sofa-support PROPERTIES ${DEFAULT_TARGET_PROPS})
+
         set(MAKEMHR_SRCS
             utils/makemhr/loaddef.cpp
             utils/makemhr/loaddef.h
@@ -1416,168 +1629,161 @@ IF(ALSOFT_UTILS)
         add_executable(makemhr ${MAKEMHR_SRCS})
         target_compile_definitions(makemhr PRIVATE ${CPP_DEFS})
         target_include_directories(makemhr
-            PRIVATE ${OpenAL_SOURCE_DIR}/common ${OpenAL_BINARY_DIR})
+            PRIVATE ${OpenAL_BINARY_DIR} ${OpenAL_SOURCE_DIR}/utils)
         target_compile_options(makemhr PRIVATE ${C_FLAGS})
-        target_link_libraries(makemhr PRIVATE common ${LINKER_FLAGS} MySOFA::MySOFA)
-        set(UTIL_TARGETS ${UTIL_TARGETS} makemhr)
+        target_link_libraries(makemhr PRIVATE ${LINKER_FLAGS} sofa-support ${UNICODE_FLAG})
+        set_target_properties(makemhr PROPERTIES ${DEFAULT_TARGET_PROPS})
+        if(ALSOFT_INSTALL_EXAMPLES)
+            set(EXTRA_INSTALLS ${EXTRA_INSTALLS} makemhr)
+        endif()
 
         set(SOFAINFO_SRCS  utils/sofa-info.cpp)
         add_executable(sofa-info ${SOFAINFO_SRCS})
         target_compile_definitions(sofa-info PRIVATE ${CPP_DEFS})
-        target_include_directories(sofa-info PRIVATE ${OpenAL_SOURCE_DIR}/common)
+        target_include_directories(sofa-info PRIVATE ${OpenAL_SOURCE_DIR}/utils)
         target_compile_options(sofa-info PRIVATE ${C_FLAGS})
-        target_link_libraries(sofa-info PRIVATE ${LINKER_FLAGS} MySOFA::MySOFA)
+        target_link_libraries(sofa-info PRIVATE ${LINKER_FLAGS} sofa-support ${UNICODE_FLAG})
+        set_target_properties(sofa-info PROPERTIES ${DEFAULT_TARGET_PROPS})
     endif()
+    message(STATUS "Building utility programs")
 
-    IF(ALSOFT_INSTALL)
-        INSTALL(TARGETS ${UTIL_TARGETS}
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    ENDIF()
-
-    MESSAGE(STATUS "Building utility programs")
-    IF(TARGET alsoft-config)
-        MESSAGE(STATUS "Building configuration program")
-    ENDIF()
-    MESSAGE(STATUS "")
-ENDIF()
+    if(NOT ALSOFT_NO_CONFIG_UTIL)
+        add_subdirectory(utils/alsoft-config)
+    endif()
+    message(STATUS "")
+endif()
 
 
 # Add a static library with common functions used by multiple example targets
-ADD_LIBRARY(ex-common STATIC EXCLUDE_FROM_ALL
+add_library(ex-common STATIC EXCLUDE_FROM_ALL
     examples/common/alhelpers.c
     examples/common/alhelpers.h)
-TARGET_COMPILE_DEFINITIONS(ex-common PUBLIC ${CPP_DEFS})
-TARGET_INCLUDE_DIRECTORIES(ex-common PUBLIC ${OpenAL_SOURCE_DIR}/common)
-TARGET_COMPILE_OPTIONS(ex-common PUBLIC ${C_FLAGS})
-TARGET_LINK_LIBRARIES(ex-common PUBLIC OpenAL PRIVATE ${RT_LIB})
-
-IF(ALSOFT_TESTS)
-    ADD_EXECUTABLE(altonegen examples/altonegen.c)
-    TARGET_COMPILE_DEFINITIONS(altonegen PRIVATE ${CPP_DEFS})
-    TARGET_INCLUDE_DIRECTORIES(altonegen PRIVATE ${OpenAL_SOURCE_DIR}/common)
-    TARGET_COMPILE_OPTIONS(altonegen PRIVATE ${C_FLAGS})
-    TARGET_LINK_LIBRARIES(altonegen PRIVATE ${LINKER_FLAGS} ${MATH_LIB} ex-common)
-
-    IF(ALSOFT_INSTALL)
-        INSTALL(TARGETS altonegen
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    ENDIF()
+target_compile_definitions(ex-common PUBLIC ${CPP_DEFS})
+target_include_directories(ex-common PUBLIC ${OpenAL_SOURCE_DIR}/common)
+target_compile_options(ex-common PUBLIC ${C_FLAGS})
+target_link_libraries(ex-common PUBLIC OpenAL PRIVATE ${RT_LIB})
+set_target_properties(ex-common PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+if(ALSOFT_EXAMPLES)
+    add_executable(altonegen examples/altonegen.c)
+    target_link_libraries(altonegen PRIVATE ${LINKER_FLAGS} ${MATH_LIB} ex-common ${UNICODE_FLAG})
+    set_target_properties(altonegen PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+    add_executable(alrecord examples/alrecord.c)
+    target_link_libraries(alrecord PRIVATE ${LINKER_FLAGS} ex-common ${UNICODE_FLAG})
+    set_target_properties(alrecord PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+    if(ALSOFT_INSTALL_EXAMPLES)
+        set(EXTRA_INSTALLS ${EXTRA_INSTALLS} altonegen alrecord)
+    endif()
 
-    MESSAGE(STATUS "Building test programs")
-    MESSAGE(STATUS "")
-ENDIF()
+    message(STATUS "Building example programs")
+
+    if(SNDFILE_FOUND)
+        add_executable(alplay examples/alplay.c)
+        target_link_libraries(alplay PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(alplay PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(alstream examples/alstream.c)
+        target_link_libraries(alstream PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(alstream PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(alreverb examples/alreverb.c)
+        target_link_libraries(alreverb PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(alreverb PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(almultireverb examples/almultireverb.c)
+        target_link_libraries(almultireverb
+            PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common ${MATH_LIB} ${UNICODE_FLAG})
+        set_target_properties(almultireverb PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(allatency examples/allatency.c)
+        target_link_libraries(allatency PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(allatency PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(alhrtf examples/alhrtf.c)
+        target_link_libraries(alhrtf
+            PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common ${MATH_LIB} ${UNICODE_FLAG})
+        set_target_properties(alhrtf PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(alstreamcb examples/alstreamcb.cpp)
+        target_link_libraries(alstreamcb PRIVATE ${LINKER_FLAGS} SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(alstreamcb PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        add_executable(alconvolve examples/alconvolve.c)
+        target_link_libraries(alconvolve PRIVATE ${LINKER_FLAGS} common SndFile::SndFile ex-common
+            ${UNICODE_FLAG})
+        set_target_properties(alconvolve PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+        if(ALSOFT_INSTALL_EXAMPLES)
+            set(EXTRA_INSTALLS ${EXTRA_INSTALLS} alplay alstream alreverb almultireverb allatency
+                alhrtf)
+        endif()
 
-IF(ALSOFT_EXAMPLES)
-    ADD_EXECUTABLE(alrecord examples/alrecord.c)
-    TARGET_LINK_LIBRARIES(alrecord PRIVATE ${LINKER_FLAGS} ex-common)
+        message(STATUS "Building SndFile example programs")
+    endif()
 
-    IF(ALSOFT_INSTALL)
-        INSTALL(TARGETS alrecord
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    ENDIF()
+    if(SDL2_FOUND)
+        add_executable(alloopback examples/alloopback.c)
+        target_link_libraries(alloopback
+            PRIVATE ${LINKER_FLAGS} SDL2::SDL2 ex-common ${MATH_LIB})
+        set_target_properties(alloopback PROPERTIES ${DEFAULT_TARGET_PROPS})
 
-    MESSAGE(STATUS "Building example programs")
-
-    IF(SDL2_FOUND)
-        IF(SDL_SOUND_FOUND)
-            ADD_EXECUTABLE(alplay examples/alplay.c)
-            TARGET_INCLUDE_DIRECTORIES(alplay
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(alplay
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common)
-
-            ADD_EXECUTABLE(alstream examples/alstream.c)
-            TARGET_INCLUDE_DIRECTORIES(alstream
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(alstream
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common)
-
-            ADD_EXECUTABLE(alreverb examples/alreverb.c)
-            TARGET_INCLUDE_DIRECTORIES(alreverb
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(alreverb
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common)
-
-            ADD_EXECUTABLE(almultireverb examples/almultireverb.c)
-            TARGET_INCLUDE_DIRECTORIES(almultireverb
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(almultireverb
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common
-                ${MATH_LIB})
-
-            ADD_EXECUTABLE(allatency examples/allatency.c)
-            TARGET_INCLUDE_DIRECTORIES(allatency
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(allatency
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common)
-
-            ADD_EXECUTABLE(alloopback examples/alloopback.c)
-            TARGET_INCLUDE_DIRECTORIES(alloopback
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(alloopback
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common ${MATH_LIB})
-
-            ADD_EXECUTABLE(alhrtf examples/alhrtf.c)
-            TARGET_INCLUDE_DIRECTORIES(alhrtf
-                PRIVATE ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-            TARGET_LINK_LIBRARIES(alhrtf
-                PRIVATE ${LINKER_FLAGS} ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY} ex-common ${MATH_LIB})
-
-            IF(ALSOFT_INSTALL)
-                INSTALL(TARGETS alplay alstream alreverb almultireverb allatency alloopback alhrtf
-                    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-            ENDIF()
-
-            MESSAGE(STATUS "Building SDL_sound example programs")
-        ENDIF()
+        if(ALSOFT_INSTALL_EXAMPLES)
+            set(EXTRA_INSTALLS ${EXTRA_INSTALLS} alloopback)
+        endif()
 
-        SET(FFVER_OK FALSE)
-        IF(FFMPEG_FOUND)
-            SET(FFVER_OK TRUE)
-            IF(AVFORMAT_VERSION VERSION_LESS "57.56.101")
-                MESSAGE(STATUS "libavformat is too old! (${AVFORMAT_VERSION}, wanted 57.56.101)")
-                SET(FFVER_OK FALSE)
-            ENDIF()
-            IF(AVCODEC_VERSION VERSION_LESS "57.64.101")
-                MESSAGE(STATUS "libavcodec is too old! (${AVCODEC_VERSION}, wanted 57.64.101)")
-                SET(FFVER_OK FALSE)
-            ENDIF()
-            IF(AVUTIL_VERSION VERSION_LESS "55.34.101")
-                MESSAGE(STATUS "libavutil is too old! (${AVUTIL_VERSION}, wanted 55.34.101)")
-                SET(FFVER_OK FALSE)
-            ENDIF()
-            IF(SWSCALE_VERSION VERSION_LESS "4.2.100")
-                MESSAGE(STATUS "libswscale is too old! (${SWSCALE_VERSION}, wanted 4.2.100)")
-                SET(FFVER_OK FALSE)
-            ENDIF()
-            IF(SWRESAMPLE_VERSION VERSION_LESS "2.3.100")
-                MESSAGE(STATUS "libswresample is too old! (${SWRESAMPLE_VERSION}, wanted 2.3.100)")
-                SET(FFVER_OK FALSE)
-            ENDIF()
-        ENDIF()
-        IF(FFVER_OK)
-            ADD_EXECUTABLE(alffplay examples/alffplay.cpp)
-            TARGET_INCLUDE_DIRECTORIES(alffplay
-                PRIVATE ${SDL2_INCLUDE_DIR} ${FFMPEG_INCLUDE_DIRS})
-            TARGET_LINK_LIBRARIES(alffplay
-                PRIVATE ${LINKER_FLAGS} ${SDL2_LIBRARY} ${FFMPEG_LIBRARIES} ex-common)
-
-            IF(ALSOFT_INSTALL)
-                INSTALL(TARGETS alffplay
-                    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-            ENDIF()
-            MESSAGE(STATUS "Building SDL+FFmpeg example programs")
-        ENDIF()
-        MESSAGE(STATUS "")
-    ENDIF()
-ENDIF()
+        message(STATUS "Building SDL example programs")
+
+        set(FFVER_OK FALSE)
+        if(FFMPEG_FOUND)
+            set(FFVER_OK TRUE)
+            if(AVFORMAT_VERSION VERSION_LESS "59.27.100")
+                message(STATUS "libavformat is too old! (${AVFORMAT_VERSION}, wanted 59.27.100)")
+                set(FFVER_OK FALSE)
+            endif()
+            if(AVCODEC_VERSION VERSION_LESS "59.37.100")
+                message(STATUS "libavcodec is too old! (${AVCODEC_VERSION}, wanted 59.37.100)")
+                set(FFVER_OK FALSE)
+            endif()
+            if(AVUTIL_VERSION VERSION_LESS "57.28.100")
+                message(STATUS "libavutil is too old! (${AVUTIL_VERSION}, wanted 57.28.100)")
+                set(FFVER_OK FALSE)
+            endif()
+            if(SWSCALE_VERSION VERSION_LESS "6.7.100")
+                message(STATUS "libswscale is too old! (${SWSCALE_VERSION}, wanted 6.7.100)")
+                set(FFVER_OK FALSE)
+            endif()
+            if(SWRESAMPLE_VERSION VERSION_LESS "4.7.100")
+                message(STATUS "libswresample is too old! (${SWRESAMPLE_VERSION}, wanted 4.7.100)")
+                set(FFVER_OK FALSE)
+            endif()
+        endif()
+        if(FFVER_OK)
+            add_executable(alffplay examples/alffplay.cpp)
+            target_include_directories(alffplay PRIVATE ${FFMPEG_INCLUDE_DIRS})
+            target_link_libraries(alffplay
+                PRIVATE ${LINKER_FLAGS} SDL2::SDL2 ${FFMPEG_LIBRARIES} ex-common)
+            set_target_properties(alffplay PROPERTIES ${DEFAULT_TARGET_PROPS})
+
+            if(ALSOFT_INSTALL_EXAMPLES)
+                set(EXTRA_INSTALLS ${EXTRA_INSTALLS} alffplay)
+            endif()
+            message(STATUS "Building SDL+FFmpeg example programs")
+        endif()
+    endif()
+    message(STATUS "")
+endif()
+
+if(EXTRA_INSTALLS)
+    install(TARGETS ${EXTRA_INSTALLS}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        BUNDLE  DESTINATION ${CMAKE_INSTALL_BINDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
diff --git a/ChangeLog b/ChangeLog
index db9ebd92..e4236f85 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,306 @@
+openal-soft-1.23.1:
+
+    Implemented the AL_SOFT_UHJ_ex extension.
+
+    Implemented the AL_SOFT_buffer_length_query extension.
+
+    Implemented the AL_SOFT_source_start_delay extension.
+
+    Implemented the AL_EXT_STATIC_BUFFER extension.
+
+    Fixed compiling with certain older versions of GCC.
+
+    Fixed compiling as a submodule.
+
+    Fixed compiling with newer versions of Oboe.
+
+    Improved EAX effect version switching.
+
+    Improved the quality of the reverb modulator.
+
+    Improved performance of the cubic resampler.
+
+    Added a compatibility option to restore AL_SOFT_buffer_sub_data. The option
+    disables AL_EXT_SOURCE_RADIUS due to incompatibility.
+
+    Reduced CPU usage when EAX is initialized and FXSlot0 or FXSlot1 are not
+    used.
+
+    Reduced memory usage for ADPCM buffer formats. They're no longer converted
+    to 16-bit samples on load.
+
+openal-soft-1.23.0:
+
+    Fixed CoreAudio capture support.
+
+    Fixed handling per-version EAX properties.
+
+    Fixed interpolating changes to the Super Stereo width source property.
+
+    Fixed detection of the update and buffer size from PipeWire.
+
+    Fixed resuming playback devices with OpenSL.
+
+    Fixed support for certain OpenAL implementations with the router.
+
+    Improved reverb environment transitions.
+
+    Improved performance of convolution reverb.
+
+    Improved quality and performance of the pitch shifter effect slightly.
+
+    Improved sub-sample precision for resampled sources.
+
+    Improved blending spatialized multi-channel sources that use the source
+    radius property.
+
+    Improved mixing 2D ambisonic sources for higher-order 3D ambisonic mixing.
+
+    Improved quadraphonic and 7.1 surround sound output slightly.
+
+    Added config options for UHJ encoding/decoding quality. Including Super
+    Stereo processing.
+
+    Added a config option for specifying the speaker distance.
+
+    Added a compatibility config option for specifying the NFC distance
+    scaling.
+
+    Added a config option for mixing on PipeWire's non-real-time thread.
+
+    Added support for virtual source nodes with PipeWire capture.
+
+    Added the ability for the WASAPI backend to use different playback rates.
+
+    Added support for SOFA files that define per-response delays in makemhr.
+
+    Changed the default fallback playback sample rate to 48khz. This doesn't
+    affect most backends, which can detect a default rate from the system.
+
+    Changed the default resampler to cubic.
+
+    Changed the default HRTF size from 32 to 64 points.
+
+openal-soft-1.22.2:
+
+    Fixed PipeWire version check.
+
+    Fixed building with PipeWire versions before 0.3.33.
+
+openal-soft-1.22.1:
+
+    Fixed CoreAudio capture.
+
+    Fixed air absorption strength.
+
+    Fixed handling 5.1 devices on Windows that use Rear channels instead of
+    Side channels.
+
+    Fixed some compilation issues on MinGW.
+
+    Fixed ALSA not being used on some systems without PipeWire and PulseAudio.
+
+    Fixed OpenSL capturing noise.
+
+    Fixed Oboe capture failing with some buffer sizes.
+
+    Added checks for the runtime PipeWire version. The same or newer version
+    than is used for building will be needed at runtime for the backend to
+    work.
+
+    Separated 3D7.1 into its own speaker configuration.
+
+openal-soft-1.22.0:
+
+    Implemented the ALC_SOFT_reopen_device extension. This allows for moving
+    devices to different outputs without losing object state.
+
+    Implemented the ALC_SOFT_output_mode extension.
+
+    Implemented the AL_SOFT_callback_buffer extension.
+
+    Implemented the AL_SOFT_UHJ extension. This supports native UHJ buffer
+    formats and Super Stereo processing.
+
+    Implemented the legacy EAX extensions. Enabled by default only on Windows.
+
+    Improved sound positioning stability when a source is near the listener.
+
+    Improved the default 5.1 output decoder.
+
+    Improved the high frequency response for the HRTF second-order ambisonic
+    decoder.
+
+    Improved SoundIO capture behavior.
+
+    Fixed UHJ output on NEON-capable CPUs.
+
+    Fixed redundant effect updates when setting an effect property to the
+    current value.
+
+    Fixed WASAPI capture using really low sample rates, and sources with very
+    high pitch shifts when using a bsinc resampler.
+
+    Added a PipeWire backend.
+
+    Added enumeration for the JACK and CoreAudio backends.
+
+    Added optional support for RTKit to get real-time priority. Only used as a
+    backup when pthread_setschedparam fails.
+
+    Added an option for JACK playback to render directly in the real-time
+    processing callback. For lower playback latency, on by default.
+
+    Added an option for custom JACK devices.
+
+    Added utilities to encode and decode UHJ audio files. Files are decoded to
+    the .amb format, and are encoded from libsndfile-compatible formats.
+
+    Added an in-progress extension to hold sources in a playing state when a
+    device disconnects. Allows devices to be reset or reopened and have sources
+    resume from where they left off.
+
+    Lowered the priority of the JACK backend. To avoid it getting picked when
+    PipeWire is providing JACK compatibility, since the JACK backend is less
+    robust with auto-configuration.
+
+openal-soft-1.21.1:
+
+    Improved alext.h's detection of standard types.
+
+    Improved slightly the local source position when the listener and source
+    are near each other.
+
+    Improved click/pop prevention for sounds that stop prematurely.
+
+    Fixed compilation for Windows ARM targets with MSVC.
+
+    Fixed ARM NEON detection on Windows.
+
+    Fixed CoreAudio capture when the requested sample rate doesn't match the
+    system configuration.
+
+    Fixed OpenSL capture desyncing from the internal capture buffer.
+
+    Fixed sources missing a batch update when applied after quickly restarting
+    the source.
+
+    Fixed missing source stop events when stopping a paused source.
+
+    Added capture support to the experimental Oboe backend.
+
+openal-soft-1.21.0:
+
+    Updated library codebase to C++14.
+
+    Implemented the AL_SOFT_effect_target extension.
+
+    Implemented the AL_SOFT_events extension.
+
+    Implemented the ALC_SOFT_loopback_bformat extension.
+
+    Improved memory use for mixing voices.
+
+    Improved detection of NEON capabilities.
+
+    Improved handling of PulseAudio devices that lack manual start control.
+
+    Improved mixing performance with PulseAudio.
+
+    Improved high-frequency scaling quality for the HRTF B-Format decoder.
+
+    Improved makemhr's HRIR delay calculation.
+
+    Improved WASAPI capture of mono formats with multichannel input.
+
+    Reimplemented the modulation stage for reverb.
+
+    Enabled real-time mixing priority by default, for backends that use the
+    setting. It can still be disabled in the config file.
+
+    Enabled dual-band processing for the built-in quad and 7.1 output decoders.
+
+    Fixed a potential crash when deleting an effect slot immediately after the
+    last source using it stops.
+
+    Fixed building with the static runtime on MSVC.
+
+    Fixed using source stereo angles outside of -pi...+pi.
+
+    Fixed the buffer processed event count for sources that start with empty
+    buffers.
+
+    Fixed trying to open an unopenable WASAPI device causing all devices to
+    stop working.
+
+    Fixed stale devices when re-enumerating WASAPI devices.
+
+    Fixed using unicode paths with the log file on Windows.
+
+    Fixed DirectSound capture reporting bad sample counts or erroring when
+    reading samples.
+
+    Added an in-progress extension for a callback-driven buffer type.
+
+    Added an in-progress extension for higher-order B-Format buffers.
+
+    Added an in-progress extension for convolution reverb.
+
+    Added an experimental Oboe backend for Android playback. This requires the
+    Oboe sources at build time, so that it's built as a static library included
+    in libopenal.
+
+    Added an option for auto-connecting JACK ports.
+
+    Added greater-than-stereo support to the SoundIO backend.
+
+    Modified the mixer to be fully asynchronous with the external API, and
+    should now be real-time safe. Although alcRenderSamplesSOFT is not due to
+    locking to check the device handle validity.
+
+    Modified the UHJ encoder to use an all-pass FIR filter that's less harmful
+    to non-filtered signal phase.
+
+    Converted examples from SDL_sound to libsndfile. To avoid issues when
+    combining SDL2 and SDL_sound.
+
+    Worked around a 32-bit GCC/MinGW bug with TLS destructors. See:
+    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83562
+
+    Reduced the maximum number of source sends from 16 to 6.
+
+    Removed the QSA backend. It's been broken for who knows how long.
+
+    Got rid of the compile-time native-tools targets, using cmake and global
+    initialization instead. This should make cross-compiling less troublesome.
+
+openal-soft-1.20.1:
+
+    Implemented the AL_SOFT_direct_channels_remix extension. This extends
+    AL_DIRECT_CHANNELS_SOFT to optionally remix input channels that don't have
+    a matching output channel.
+
+    Implemented the AL_SOFT_bformat_ex extension. This extends B-Format buffer
+    support for N3D or SN3D scaling, or ACN channel ordering.
+
+    Fixed a potential voice leak when a source is started and stopped or
+    restarted in quick succession.
+
+    Fixed a potential device reset failure with JACK.
+
+    Improved handling of unsupported channel configurations with WASAPI. Such
+    setups will now try to output at least a stereo mix.
+
+    Improved clarity a bit for the HRTF second-order ambisonic decoder.
+
+    Improved detection of compatible layouts for SOFA files in makemhr and
+    sofa-info.
+
+    Added the ability to resample HRTFs on load. MHR files no longer need to
+    match the device sample rate to be usable.
+
+    Added an option to limit the HRTF's filter length.
+
 openal-soft-1.20.0:
 
     Converted the library codebase to C++11. A lot of hacks and custom
diff --git a/OpenALConfig.cmake.in b/OpenALConfig.cmake.in
new file mode 100644
index 00000000..128c1a4e
--- /dev/null
+++ b/OpenALConfig.cmake.in
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/OpenALTargets.cmake")
+
+set(OPENAL_FOUND ON)
+set(OPENAL_INCLUDE_DIR $<TARGET_PROPERTY:OpenAL::OpenAL,INTERFACE_INCLUDE_DIRECTORIES>)
+set(OPENAL_LIBRARY $<LINK_ONLY:OpenAL::OpenAL>)
+set(OPENAL_DEFINITIONS $<TARGET_PROPERTY:OpenAL::OpenAL,INTERFACE_COMPILE_DEFINITIONS>)
+set(OPENAL_VERSION_STRING @PACKAGE_VERSION@)
diff --git a/README.md b/README.md
index 0c9d3027..50b7bfb4 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
-OpenAL soft
+OpenAL Soft
 ===========
 
-`master` branch CI status :  [![Build Status](https://travis-ci.org/kcat/openal-soft.svg?branch=master)](https://travis-ci.org/kcat/openal-soft) [![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/kcat/openal-soft?branch=master&svg=true)](https://ci.appveyor.com/api/projects/status/github/kcat/openal-soft?branch=master&svg=true)
+`master` branch CI status : [![GitHub Actions Status](https://github.com/kcat/openal-soft/actions/workflows/ci.yml/badge.svg)](https://github.com/kcat/openal-soft/actions) [![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/kcat/openal-soft?branch=master&svg=true)](https://ci.appveyor.com/api/projects/status/github/kcat/openal-soft?branch=master&svg=true)
 
 OpenAL Soft is an LGPL-licensed, cross-platform, software implementation of the OpenAL 3D audio API. It's forked from the open-sourced Windows version available originally from openal.org's SVN repository (now defunct).
 OpenAL provides capabilities for playing audio in a virtual 3D environment. Distance attenuation, doppler shift, and directional sound emitters are among the features handled by the API. More advanced effects, including air absorption, occlusion, and environmental reverb, are available through the EFX extension. It also facilitates streaming audio, multi-channel buffers, and audio capture.
 
-More information is available on the [official website](http://openal-soft.org/)
+More information is available on the [official website](http://openal-soft.org/).
 
 Source Install
 -------------
@@ -17,19 +17,36 @@ directory, and run:
 cmake ..
 ```
 
-Assuming configuration went well, you can then build it, typically using GNU
-Make (KDevelop, MSVC, and others are possible depending on your system setup
-and CMake configuration).
+Alternatively, you can use any available CMake front-end, like cmake-gui,
+ccmake, or your preferred IDE's CMake project parser.
+
+Assuming configuration went well, you can then build it. The command
+`cmake --build .` will instruct CMake to build the project with the toolchain
+chosen during configuration (often GNU Make or NMake, although others are
+possible).
 
 Please Note: Double check that the appropriate backends were detected. Often,
 complaints of no sound, crashing, and missing devices can be solved by making
 sure the correct backends are being used. CMake's output will identify which
 backends were enabled.
 
-For most systems, you will likely want to make sure ALSA, OSS, and PulseAudio
-were detected (if your target system uses them). For Windows, make sure
-DirectSound was detected.
+For most systems, you will likely want to make sure PipeWire, PulseAudio, and
+ALSA were detected (if your target system uses them). For Windows, make sure
+WASAPI was detected.
+
+
+Building openal-soft - Using vcpkg
+----------------------------------
+
+You can download and install openal-soft using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install openal-soft
 
+The openal-soft port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
 
 Utilities
 ---------
diff --git a/XCompile-Android.txt b/XCompile-Android.txt
index 3dd88e80..693f0ed9 100644
--- a/XCompile-Android.txt
+++ b/XCompile-Android.txt
@@ -1,39 +1,16 @@
-# Cross-compiling requires CMake 2.6 or newer. Example:
-# cmake .. -DCMAKE_TOOLCHAIN_FILE=../XCompile-Android.txt -DHOST=arm-linux-androideabi
-# Where 'arm-linux-androideabi' is the host prefix for the cross-compiler. If
-# you already have a toolchain file setup, you may use that instead of this
-# file. Make sure to set CMAKE_FIND_ROOT_PATH to where the NDK toolchain was
-# installed (e.g. "$ENV{HOME}/toolchains/arm-linux-androideabi-r10c-21").
+# Cross-compiling for Android is handled by the NDK's own provided toolchain,
+# which as of this writing, should be in
+# ${ndk_root}/build/cmake/android.toolchain.cmake
+#
+# Certain older NDK versions may also need to explicitly pick the libc++
+# runtime. So for example:
+# cmake .. -DANDROID_STL=c++_shared \
+#     -DCMAKE_TOOLCHAIN_FILE=${ndk_root}/build/cmake/android.toolchain.cmake
+#
+# Certain NDK versions may also need to use the lld linker to avoid errors
+# about missing liblog.so and libOpenSLES.so. That can be done by:
+# cmake .. -DANDROID_LD=lld \
+#     -DCMAKE_TOOLCHAIN_FILE=${ndk_root}/build/cmake/android.toolchain.cmake
+#
 
-# the name of the target operating system
-SET(CMAKE_SYSTEM_NAME Linux)
-
-# which compilers to use for C and C++
-SET(CMAKE_C_COMPILER "${HOST}-gcc")
-SET(CMAKE_CXX_COMPILER "${HOST}-g++")
-SET(CMAKE_RC_COMPILER "${HOST}-windres")
-
-# here is the target environment located
-SET(CMAKE_FIND_ROOT_PATH "SET THIS TO THE NDK TOOLCHAIN'S INSTALL PATH")
-
-# here is where stuff gets installed to
-SET(CMAKE_INSTALL_PREFIX "${CMAKE_FIND_ROOT_PATH}" CACHE STRING "Install path prefix, prepended onto install directories." FORCE)
-
-# adjust the default behaviour of the FIND_XXX() commands:
-# search headers and libraries in the target environment, search 
-# programs in the host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-
-# set env vars so that pkg-config will look in the appropriate directory for
-# .pc files (as there seems to be no way to force using ${HOST}-pkg-config)
-set(ENV{PKG_CONFIG_LIBDIR} "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig")
-set(ENV{PKG_CONFIG_PATH} "")
-
-# Qt4 tools
-SET(QT_QMAKE_EXECUTABLE ${HOST}-qmake)
-SET(QT_MOC_EXECUTABLE ${HOST}-moc)
-SET(QT_RCC_EXECUTABLE ${HOST}-rcc)
-SET(QT_UIC_EXECUTABLE ${HOST}-uic)
-SET(QT_LRELEASE_EXECUTABLE ${HOST}-lrelease)
+MESSAGE(FATAL_ERROR "Use the toolchain provided by the Android NDK")
diff --git a/al/auxeffectslot.cpp b/al/auxeffectslot.cpp
index 3c312c66..285da1d4 100644
--- a/al/auxeffectslot.cpp
+++ b/al/auxeffectslot.cpp
@@ -23,6 +23,7 @@
 #include "auxeffectslot.h"
 
 #include <algorithm>
+#include <cassert>
 #include <cstdint>
 #include <iterator>
 #include <memory>
@@ -34,31 +35,65 @@
 #include "AL/alc.h"
 #include "AL/efx.h"
 
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "albit.h"
+#include "alc/alu.h"
+#include "alc/context.h"
+#include "alc/device.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "alspan.h"
-#include "alu.h"
+#include "buffer.h"
+#include "core/except.h"
+#include "core/fpu_ctrl.h"
+#include "core/logging.h"
 #include "effect.h"
-#include "fpu_modes.h"
-#include "inprogext.h"
-#include "logging.h"
 #include "opthelpers.h"
 
-
 namespace {
 
+struct FactoryItem {
+    EffectSlotType Type;
+    EffectStateFactory* (&GetFactory)(void);
+};
+constexpr FactoryItem FactoryList[] = {
+    { EffectSlotType::None, NullStateFactory_getFactory },
+    { EffectSlotType::EAXReverb, ReverbStateFactory_getFactory },
+    { EffectSlotType::Reverb, StdReverbStateFactory_getFactory },
+    { EffectSlotType::Autowah, AutowahStateFactory_getFactory },
+    { EffectSlotType::Chorus, ChorusStateFactory_getFactory },
+    { EffectSlotType::Compressor, CompressorStateFactory_getFactory },
+    { EffectSlotType::Distortion, DistortionStateFactory_getFactory },
+    { EffectSlotType::Echo, EchoStateFactory_getFactory },
+    { EffectSlotType::Equalizer, EqualizerStateFactory_getFactory },
+    { EffectSlotType::Flanger, FlangerStateFactory_getFactory },
+    { EffectSlotType::FrequencyShifter, FshifterStateFactory_getFactory },
+    { EffectSlotType::RingModulator, ModulatorStateFactory_getFactory },
+    { EffectSlotType::PitchShifter, PshifterStateFactory_getFactory },
+    { EffectSlotType::VocalMorpher, VmorpherStateFactory_getFactory },
+    { EffectSlotType::DedicatedDialog, DedicatedStateFactory_getFactory },
+    { EffectSlotType::DedicatedLFE, DedicatedStateFactory_getFactory },
+    { EffectSlotType::Convolution, ConvolutionStateFactory_getFactory },
+};
+
+EffectStateFactory *getFactoryByType(EffectSlotType type)
+{
+    auto iter = std::find_if(std::begin(FactoryList), std::end(FactoryList),
+        [type](const FactoryItem &item) noexcept -> bool
+        { return item.Type == type; });
+    return (iter != std::end(FactoryList)) ? iter->GetFactory() : nullptr;
+}
+
+
 inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id) noexcept
 {
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= context->mEffectSlotList.size())
+    if(lidx >= context->mEffectSlotList.size()) UNLIKELY
         return nullptr;
     EffectSlotSubList &sublist{context->mEffectSlotList[lidx]};
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.EffectSlots + slidx;
 }
@@ -68,29 +103,40 @@ inline ALeffect *LookupEffect(ALCdevice *device, ALuint id) noexcept
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= device->EffectList.size())
+    if(lidx >= device->EffectList.size()) UNLIKELY
         return nullptr;
     EffectSubList &sublist = device->EffectList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Effects + slidx;
 }
 
+inline ALbuffer *LookupBuffer(ALCdevice *device, ALuint id) noexcept
+{
+    const size_t lidx{(id-1) >> 6};
+    const ALuint slidx{(id-1) & 0x3f};
+
+    if(lidx >= device->BufferList.size()) UNLIKELY
+        return nullptr;
+    BufferSubList &sublist = device->BufferList[lidx];
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
+        return nullptr;
+    return sublist.Buffers + slidx;
+}
+
 
-void AddActiveEffectSlots(const ALuint *slotids, size_t count, ALCcontext *context)
+void AddActiveEffectSlots(const al::span<ALeffectslot*> auxslots, ALCcontext *context)
 {
-    if(count < 1) return;
-    ALeffectslotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
-    size_t newcount{curarray->size() + count};
+    if(auxslots.empty()) return;
+    EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
+    size_t newcount{curarray->size() + auxslots.size()};
 
     /* Insert the new effect slots into the head of the array, followed by the
      * existing ones.
      */
-    ALeffectslotArray *newarray = ALeffectslot::CreatePtrArray(newcount);
-    auto slotiter = std::transform(slotids, slotids+count, newarray->begin(),
-        [context](ALuint id) noexcept -> ALeffectslot*
-        { return LookupEffectSlot(context, id); }
-    );
+    EffectSlotArray *newarray = EffectSlot::CreatePtrArray(newcount);
+    auto slotiter = std::transform(auxslots.begin(), auxslots.end(), newarray->begin(),
+        [](ALeffectslot *auxslot) noexcept { return auxslot->mSlot; });
     std::copy(curarray->begin(), curarray->end(), slotiter);
 
     /* Remove any duplicates (first instance of each will be kept). */
@@ -106,70 +152,99 @@ void AddActiveEffectSlots(const ALuint *slotids, size_t count, ALCcontext *conte
     /* Reallocate newarray if the new size ended up smaller from duplicate
      * removal.
      */
-    if UNLIKELY(newcount < newarray->size())
+    if(newcount < newarray->size()) UNLIKELY
     {
         curarray = newarray;
-        newarray = ALeffectslot::CreatePtrArray(newcount);
+        newarray = EffectSlot::CreatePtrArray(newcount);
         std::copy_n(curarray->begin(), newcount, newarray->begin());
         delete curarray;
         curarray = nullptr;
     }
+    std::uninitialized_fill_n(newarray->end(), newcount, nullptr);
 
     curarray = context->mActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
-    ALCdevice *device{context->mDevice.get()};
-    while((device->MixCount.load(std::memory_order_acquire)&1))
-        std::this_thread::yield();
+    context->mDevice->waitForMix();
+
+    al::destroy_n(curarray->end(), curarray->size());
     delete curarray;
 }
 
-void RemoveActiveEffectSlots(const ALuint *slotids, size_t count, ALCcontext *context)
+void RemoveActiveEffectSlots(const al::span<ALeffectslot*> auxslots, ALCcontext *context)
 {
-    if(count < 1) return;
-    ALeffectslotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
+    if(auxslots.empty()) return;
+    EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_acquire)};
 
     /* Don't shrink the allocated array size since we don't know how many (if
      * any) of the effect slots to remove are in the array.
      */
-    ALeffectslotArray *newarray = ALeffectslot::CreatePtrArray(curarray->size());
+    EffectSlotArray *newarray = EffectSlot::CreatePtrArray(curarray->size());
 
-    /* Copy each element in curarray to newarray whose ID is not in slotids. */
-    const ALuint *slotids_end{slotids + count};
-    auto slotiter = std::copy_if(curarray->begin(), curarray->end(), newarray->begin(),
-        [slotids, slotids_end](const ALeffectslot *slot) -> bool
-        { return std::find(slotids, slotids_end, slot->id) == slotids_end; }
-    );
+    auto new_end = std::copy(curarray->begin(), curarray->end(), newarray->begin());
+    /* Remove elements from newarray that match any ID in slotids. */
+    for(const ALeffectslot *auxslot : auxslots)
+    {
+        auto slot_match = [auxslot](EffectSlot *slot) noexcept -> bool
+        { return (slot == auxslot->mSlot); };
+        new_end = std::remove_if(newarray->begin(), new_end, slot_match);
+    }
 
     /* Reallocate with the new size. */
-    auto newsize = static_cast<size_t>(std::distance(newarray->begin(), slotiter));
-    if LIKELY(newsize != newarray->size())
+    auto newsize = static_cast<size_t>(std::distance(newarray->begin(), new_end));
+    if(newsize != newarray->size()) LIKELY
     {
         curarray = newarray;
-        newarray = ALeffectslot::CreatePtrArray(newsize);
+        newarray = EffectSlot::CreatePtrArray(newsize);
         std::copy_n(curarray->begin(), newsize, newarray->begin());
 
         delete curarray;
         curarray = nullptr;
     }
+    std::uninitialized_fill_n(newarray->end(), newsize, nullptr);
 
     curarray = context->mActiveAuxSlots.exchange(newarray, std::memory_order_acq_rel);
-    ALCdevice *device{context->mDevice.get()};
-    while((device->MixCount.load(std::memory_order_acquire)&1))
-        std::this_thread::yield();
+    context->mDevice->waitForMix();
+
+    al::destroy_n(curarray->end(), curarray->size());
     delete curarray;
 }
 
 
+EffectSlotType EffectSlotTypeFromEnum(ALenum type)
+{
+    switch(type)
+    {
+    case AL_EFFECT_NULL: return EffectSlotType::None;
+    case AL_EFFECT_REVERB: return EffectSlotType::Reverb;
+    case AL_EFFECT_CHORUS: return EffectSlotType::Chorus;
+    case AL_EFFECT_DISTORTION: return EffectSlotType::Distortion;
+    case AL_EFFECT_ECHO: return EffectSlotType::Echo;
+    case AL_EFFECT_FLANGER: return EffectSlotType::Flanger;
+    case AL_EFFECT_FREQUENCY_SHIFTER: return EffectSlotType::FrequencyShifter;
+    case AL_EFFECT_VOCAL_MORPHER: return EffectSlotType::VocalMorpher;
+    case AL_EFFECT_PITCH_SHIFTER: return EffectSlotType::PitchShifter;
+    case AL_EFFECT_RING_MODULATOR: return EffectSlotType::RingModulator;
+    case AL_EFFECT_AUTOWAH: return EffectSlotType::Autowah;
+    case AL_EFFECT_COMPRESSOR: return EffectSlotType::Compressor;
+    case AL_EFFECT_EQUALIZER: return EffectSlotType::Equalizer;
+    case AL_EFFECT_EAXREVERB: return EffectSlotType::EAXReverb;
+    case AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT: return EffectSlotType::DedicatedLFE;
+    case AL_EFFECT_DEDICATED_DIALOGUE: return EffectSlotType::DedicatedDialog;
+    case AL_EFFECT_CONVOLUTION_REVERB_SOFT: return EffectSlotType::Convolution;
+    }
+    ERR("Unhandled effect enum: 0x%04x\n", type);
+    return EffectSlotType::None;
+}
+
 bool EnsureEffectSlots(ALCcontext *context, size_t needed)
 {
     size_t count{std::accumulate(context->mEffectSlotList.cbegin(),
         context->mEffectSlotList.cend(), size_t{0},
         [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(sublist.FreeMask)); }
-    )};
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 
     while(needed > count)
     {
-        if UNLIKELY(context->mEffectSlotList.size() >= 1<<25)
+        if(context->mEffectSlotList.size() >= 1<<25) UNLIKELY
             return false;
 
         context->mEffectSlotList.emplace_back();
@@ -177,7 +252,7 @@ bool EnsureEffectSlots(ALCcontext *context, size_t needed)
         sublist->FreeMask = ~0_u64;
         sublist->EffectSlots = static_cast<ALeffectslot*>(
             al_calloc(alignof(ALeffectslot), sizeof(ALeffectslot)*64));
-        if UNLIKELY(!sublist->EffectSlots)
+        if(!sublist->EffectSlots) UNLIKELY
         {
             context->mEffectSlotList.pop_back();
             return false;
@@ -191,21 +266,15 @@ ALeffectslot *AllocEffectSlot(ALCcontext *context)
 {
     auto sublist = std::find_if(context->mEffectSlotList.begin(), context->mEffectSlotList.end(),
         [](const EffectSlotSubList &entry) noexcept -> bool
-        { return entry.FreeMask != 0; }
-    );
+        { return entry.FreeMask != 0; });
     auto lidx = static_cast<ALuint>(std::distance(context->mEffectSlotList.begin(), sublist));
-    auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+    ASSUME(slidx < 64);
 
-    ALeffectslot *slot{::new (sublist->EffectSlots + slidx) ALeffectslot{}};
-    if(ALenum err{InitEffectSlot(slot)})
-    {
-        al::destroy_at(slot);
-        context->setError(err, "Effect slot object initialization failed");
-        return nullptr;
-    }
-    aluInitEffectPanning(slot, context->mDevice.get());
+    ALeffectslot *slot{al::construct_at(sublist->EffectSlots + slidx, context)};
+    aluInitEffectPanning(slot->mSlot, context);
 
-    /* Add 1 to avoid source ID 0. */
+    /* Add 1 to avoid ID 0. */
     slot->id = ((lidx<<6) | slidx) + 1;
 
     context->mNumEffectSlots += 1;
@@ -227,37 +296,31 @@ void FreeEffectSlot(ALCcontext *context, ALeffectslot *slot)
 }
 
 
-#define DO_UPDATEPROPS() do {                                                 \
-    if(!context->mDeferUpdates.load(std::memory_order_acquire))               \
-        UpdateEffectSlotProps(slot, context.get());                           \
-    else                                                                      \
-        slot->PropsClean.clear(std::memory_order_release);                    \
-} while(0)
-
-} // namespace
-
-ALeffectslotArray *ALeffectslot::CreatePtrArray(size_t count) noexcept
+inline void UpdateProps(ALeffectslot *slot, ALCcontext *context)
 {
-    /* Allocate space for twice as many pointers, so the mixer has scratch
-     * space to store a sorted list during mixing.
-     */
-    void *ptr{al_calloc(alignof(ALeffectslotArray), ALeffectslotArray::Sizeof(count*2))};
-    return new (ptr) ALeffectslotArray{count};
+    if(!context->mDeferUpdates && slot->mState == SlotState::Playing)
+    {
+        slot->updateProps(context);
+        return;
+    }
+    slot->mPropsDirty = true;
 }
 
+} // namespace
+
 
-AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Generating %d effect slots", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    std::unique_lock<std::mutex> slotlock{context->mEffectSlotLock};
-    ALCdevice *device{context->mDevice.get()};
+    std::lock_guard<std::mutex> _{context->mEffectSlotLock};
+    ALCdevice *device{context->mALDevice.get()};
     if(static_cast<ALuint>(n) > device->AuxiliaryEffectSlotMax-context->mNumEffectSlots)
     {
         context->setError(AL_OUT_OF_MEMORY, "Exceeding %u effect slot limit (%u + %d)",
@@ -274,7 +337,6 @@ START_API_FUNC
     if(n == 1)
     {
         ALeffectslot *slot{AllocEffectSlot(context.get())};
-        if(!slot) return;
         effectslots[0] = slot->id;
     }
     else
@@ -284,59 +346,74 @@ START_API_FUNC
         ids.reserve(static_cast<ALuint>(count));
         do {
             ALeffectslot *slot{AllocEffectSlot(context.get())};
-            if(!slot)
-            {
-                slotlock.unlock();
-                alDeleteAuxiliaryEffectSlots(static_cast<ALsizei>(ids.size()), ids.data());
-                return;
-            }
             ids.emplace_back(slot->id);
         } while(--count);
         std::copy(ids.cbegin(), ids.cend(), effectslots);
     }
-
-    AddActiveEffectSlots(effectslots, static_cast<ALuint>(n), context.get());
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
+AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Deleting %d effect slots", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
-    auto validate_slot = [&context](const ALuint id) -> bool
+    if(n == 1)
     {
-        ALeffectslot *slot{LookupEffectSlot(context.get(), id)};
-        if UNLIKELY(!slot)
+        ALeffectslot *slot{LookupEffectSlot(context.get(), effectslots[0])};
+        if(!slot) UNLIKELY
         {
-            context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", id);
-            return false;
+            context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslots[0]);
+            return;
         }
-        if UNLIKELY(ReadRef(slot->ref) != 0)
+        if(ReadRef(slot->ref) != 0) UNLIKELY
         {
-            context->setError(AL_INVALID_OPERATION, "Deleting in-use effect slot %u", id);
-            return false;
+            context->setError(AL_INVALID_OPERATION, "Deleting in-use effect slot %u",
+                effectslots[0]);
+            return;
         }
-        return true;
-    };
-    auto effectslots_end = effectslots + n;
-    auto bad_slot = std::find_if_not(effectslots, effectslots_end, validate_slot);
-    if UNLIKELY(bad_slot != effectslots_end) return;
-
-    // All effectslots are valid, remove and delete them
-    RemoveActiveEffectSlots(effectslots, static_cast<ALuint>(n), context.get());
-    auto delete_slot = [&context](const ALuint sid) -> void
+        RemoveActiveEffectSlots({&slot, 1u}, context.get());
+        FreeEffectSlot(context.get(), slot);
+    }
+    else
     {
-        ALeffectslot *slot{LookupEffectSlot(context.get(), sid)};
-        if(slot) FreeEffectSlot(context.get(), slot);
-    };
-    std::for_each(effectslots, effectslots_end, delete_slot);
+        auto slots = al::vector<ALeffectslot*>(static_cast<ALuint>(n));
+        for(size_t i{0};i < slots.size();++i)
+        {
+            ALeffectslot *slot{LookupEffectSlot(context.get(), effectslots[i])};
+            if(!slot) UNLIKELY
+            {
+                context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslots[i]);
+                return;
+            }
+            if(ReadRef(slot->ref) != 0) UNLIKELY
+            {
+                context->setError(AL_INVALID_OPERATION, "Deleting in-use effect slot %u",
+                    effectslots[i]);
+                return;
+            }
+            slots[i] = slot;
+        }
+        /* Remove any duplicates. */
+        auto slots_end = slots.end();
+        for(auto start=slots.begin()+1;start != slots_end;++start)
+        {
+            slots_end = std::remove(start, slots_end, *(start-1));
+            if(start == slots_end) break;
+        }
+        slots.erase(slots_end, slots.end());
+
+        /* All effectslots are valid, remove and delete them */
+        RemoveActiveEffectSlots(slots, context.get());
+        for(ALeffectslot *slot : slots)
+            FreeEffectSlot(context.get(), slot);
+    }
 }
 END_API_FUNC
 
@@ -344,7 +421,7 @@ AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if LIKELY(context)
+    if(context) LIKELY
     {
         std::lock_guard<std::mutex> _{context->mEffectSlotLock};
         if(LookupEffectSlot(context.get(), effectslot) != nullptr)
@@ -355,17 +432,126 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlaySOFT(ALuint slotid)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    std::lock_guard<std::mutex> _{context->mEffectSlotLock};
+    ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
+    if(!slot) UNLIKELY
+    {
+        context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
+        return;
+    }
+    if(slot->mState == SlotState::Playing)
+        return;
+
+    slot->mPropsDirty = false;
+    slot->updateProps(context.get());
+
+    AddActiveEffectSlots({&slot, 1}, context.get());
+    slot->mState = SlotState::Playing;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlayvSOFT(ALsizei n, const ALuint *slotids)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    if(n < 0) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "Playing %d effect slots", n);
+    if(n <= 0) UNLIKELY return;
+
+    auto slots = al::vector<ALeffectslot*>(static_cast<ALuint>(n));
+    std::lock_guard<std::mutex> _{context->mEffectSlotLock};
+    for(size_t i{0};i < slots.size();++i)
+    {
+        ALeffectslot *slot{LookupEffectSlot(context.get(), slotids[i])};
+        if(!slot) UNLIKELY
+        {
+            context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotids[i]);
+            return;
+        }
+
+        if(slot->mState != SlotState::Playing)
+        {
+            slot->mPropsDirty = false;
+            slot->updateProps(context.get());
+        }
+        slots[i] = slot;
+    };
+
+    AddActiveEffectSlots(slots, context.get());
+    for(auto slot : slots)
+        slot->mState = SlotState::Playing;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopSOFT(ALuint slotid)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    std::lock_guard<std::mutex> _{context->mEffectSlotLock};
+    ALeffectslot *slot{LookupEffectSlot(context.get(), slotid)};
+    if(!slot) UNLIKELY
+    {
+        context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotid);
+        return;
+    }
+
+    RemoveActiveEffectSlots({&slot, 1}, context.get());
+    slot->mState = SlotState::Stopped;
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopvSOFT(ALsizei n, const ALuint *slotids)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
+
+    if(n < 0) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "Stopping %d effect slots", n);
+    if(n <= 0) UNLIKELY return;
+
+    auto slots = al::vector<ALeffectslot*>(static_cast<ALuint>(n));
+    std::lock_guard<std::mutex> _{context->mEffectSlotLock};
+    for(size_t i{0};i < slots.size();++i)
+    {
+        ALeffectslot *slot{LookupEffectSlot(context.get(), slotids[i])};
+        if(!slot) UNLIKELY
+        {
+            context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", slotids[i]);
+            return;
+        }
+
+        slots[i] = slot;
+    };
+
+    RemoveActiveEffectSlots(slots, context.get());
+    for(auto slot : slots)
+        slot->mState = SlotState::Stopped;
+}
+END_API_FUNC
+
+
+AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     ALeffectslot *target{};
     ALCdevice *device{};
@@ -373,39 +559,58 @@ START_API_FUNC
     switch(param)
     {
     case AL_EFFECTSLOT_EFFECT:
-        device = context->mDevice.get();
+        device = context->mALDevice.get();
 
-        { std::lock_guard<std::mutex> ___{device->EffectLock};
+        {
+            std::lock_guard<std::mutex> ___{device->EffectLock};
             ALeffect *effect{value ? LookupEffect(device, static_cast<ALuint>(value)) : nullptr};
-            if(!(value == 0 || effect != nullptr))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid effect ID %u", value);
-            err = InitializeEffect(context.get(), slot, effect);
+            if(effect)
+                err = slot->initEffect(effect->type, effect->Props, context.get());
+            else
+            {
+                if(value != 0)
+                    return context->setError(AL_INVALID_VALUE, "Invalid effect ID %u", value);
+                err = slot->initEffect(AL_EFFECT_NULL, EffectProps{}, context.get());
+            }
         }
-        if(err != AL_NO_ERROR)
+        if(err != AL_NO_ERROR) UNLIKELY
         {
             context->setError(err, "Effect initialization failed");
             return;
         }
+        if(slot->mState == SlotState::Initial) UNLIKELY
+        {
+            slot->mPropsDirty = false;
+            slot->updateProps(context.get());
+
+            AddActiveEffectSlots({&slot, 1}, context.get());
+            slot->mState = SlotState::Playing;
+            return;
+        }
         break;
 
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
         if(!(value == AL_TRUE || value == AL_FALSE))
-            SETERR_RETURN(context, AL_INVALID_VALUE,,
+            return context->setError(AL_INVALID_VALUE,
                 "Effect slot auxiliary send auto out of range");
-        slot->AuxSendAuto = static_cast<ALboolean>(value);
+        if(slot->AuxSendAuto == !!value) UNLIKELY
+            return;
+        slot->AuxSendAuto = !!value;
         break;
 
     case AL_EFFECTSLOT_TARGET_SOFT:
         target = LookupEffectSlot(context.get(), static_cast<ALuint>(value));
         if(value && !target)
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid effect slot target ID");
+            return context->setError(AL_INVALID_VALUE, "Invalid effect slot target ID");
+        if(slot->Target == target) UNLIKELY
+            return;
         if(target)
         {
             ALeffectslot *checker{target};
             while(checker && checker != slot)
                 checker = checker->Target;
             if(checker)
-                SETERR_RETURN(context, AL_INVALID_OPERATION,,
+                return context->setError(AL_INVALID_OPERATION,
                     "Setting target of effect slot ID %u to %u creates circular chain", slot->id,
                     target->id);
         }
@@ -418,7 +623,7 @@ START_API_FUNC
             if(target) IncrementRef(target->ref);
             DecrementRef(oldtarget->ref);
             slot->Target = target;
-            UpdateEffectSlotProps(slot, context.get());
+            slot->updateProps(context.get());
             return;
         }
 
@@ -426,15 +631,57 @@ START_API_FUNC
         slot->Target = target;
         break;
 
+    case AL_BUFFER:
+        device = context->mALDevice.get();
+
+        if(slot->mState == SlotState::Playing)
+            return context->setError(AL_INVALID_OPERATION,
+                "Setting buffer on playing effect slot %u", slot->id);
+
+        if(ALbuffer *buffer{slot->Buffer})
+        {
+            if(buffer->id == static_cast<ALuint>(value)) UNLIKELY
+                return;
+        }
+        else if(value == 0) UNLIKELY
+            return;
+
+        {
+            std::lock_guard<std::mutex> ___{device->BufferLock};
+            ALbuffer *buffer{};
+            if(value)
+            {
+                buffer = LookupBuffer(device, static_cast<ALuint>(value));
+                if(!buffer) return context->setError(AL_INVALID_VALUE, "Invalid buffer ID");
+                if(buffer->mCallback)
+                    return context->setError(AL_INVALID_OPERATION,
+                        "Callback buffer not valid for effects");
+
+                IncrementRef(buffer->ref);
+            }
+
+            if(ALbuffer *oldbuffer{slot->Buffer})
+                DecrementRef(oldbuffer->ref);
+            slot->Buffer = buffer;
+
+            FPUCtl mixer_mode{};
+            auto *state = slot->Effect.State.get();
+            state->deviceUpdate(device, buffer);
+        }
+        break;
+
+    case AL_EFFECTSLOT_STATE_SOFT:
+        return context->setError(AL_INVALID_OPERATION, "AL_EFFECTSLOT_STATE_SOFT is read-only");
+
     default:
-        SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid effect slot integer property 0x%04x",
+        return context->setError(AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x",
             param);
     }
-    DO_UPDATEPROPS();
+    UpdateProps(slot, context.get());
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
 START_API_FUNC
 {
     switch(param)
@@ -442,56 +689,60 @@ START_API_FUNC
     case AL_EFFECTSLOT_EFFECT:
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
     case AL_EFFECTSLOT_TARGET_SOFT:
+    case AL_EFFECTSLOT_STATE_SOFT:
+    case AL_BUFFER:
         alAuxiliaryEffectSloti(effectslot, param, values[0]);
         return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
     default:
-        SETERR_RETURN(context, AL_INVALID_ENUM,,
+        return context->setError(AL_INVALID_ENUM,
             "Invalid effect slot integer-vector property 0x%04x", param);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
     case AL_EFFECTSLOT_GAIN:
         if(!(value >= 0.0f && value <= 1.0f))
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Effect slot gain out of range");
+            return context->setError(AL_INVALID_VALUE, "Effect slot gain out of range");
+        if(slot->Gain == value) UNLIKELY
+            return;
         slot->Gain = value;
         break;
 
     default:
-        SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid effect slot float property 0x%04x",
+        return context->setError(AL_INVALID_ENUM, "Invalid effect slot float property 0x%04x",
             param);
     }
-    DO_UPDATEPROPS();
+    UpdateProps(slot, context.get());
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
 START_API_FUNC
 {
     switch(param)
@@ -502,38 +753,38 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
     default:
-        SETERR_RETURN(context, AL_INVALID_ENUM,,
+        return context->setError(AL_INVALID_ENUM,
             "Invalid effect slot float-vector property 0x%04x", param);
     }
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
-        *value = slot->AuxSendAuto;
+        *value = slot->AuxSendAuto ? AL_TRUE : AL_FALSE;
         break;
 
     case AL_EFFECTSLOT_TARGET_SOFT:
@@ -543,13 +794,24 @@ START_API_FUNC
             *value = 0;
         break;
 
+    case AL_EFFECTSLOT_STATE_SOFT:
+        *value = static_cast<int>(slot->mState);
+        break;
+
+    case AL_BUFFER:
+        if(auto *buffer = slot->Buffer)
+            *value = static_cast<ALint>(buffer->id);
+        else
+            *value = 0;
+        break;
+
     default:
         context->setError(AL_INVALID_ENUM, "Invalid effect slot integer property 0x%04x", param);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
 START_API_FUNC
 {
     switch(param)
@@ -557,17 +819,19 @@ START_API_FUNC
     case AL_EFFECTSLOT_EFFECT:
     case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
     case AL_EFFECTSLOT_TARGET_SOFT:
+    case AL_EFFECTSLOT_STATE_SOFT:
+    case AL_BUFFER:
         alGetAuxiliaryEffectSloti(effectslot, param, values);
         return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
@@ -578,16 +842,16 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
@@ -601,7 +865,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
 START_API_FUNC
 {
     switch(param)
@@ -612,12 +876,12 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
     ALeffectslot *slot = LookupEffectSlot(context.get(), effectslot);
-    if UNLIKELY(!slot)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid effect slot ID %u", effectslot);
+    if(!slot) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid effect slot ID %u", effectslot);
 
     switch(param)
     {
@@ -629,56 +893,73 @@ START_API_FUNC
 END_API_FUNC
 
 
-ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
+ALeffectslot::ALeffectslot(ALCcontext *context)
 {
-    ALenum newtype{effect ? effect->type : AL_EFFECT_NULL};
-    if(newtype != EffectSlot->Effect.Type)
+    EffectStateFactory *factory{getFactoryByType(EffectSlotType::None)};
+    if(!factory) throw std::runtime_error{"Failed to get null effect factory"};
+
+    al::intrusive_ptr<EffectState> state{factory->create()};
+    Effect.State = state;
+
+    mSlot = context->getEffectSlot();
+    mSlot->InUse = true;
+    mSlot->mEffectState = std::move(state);
+}
+
+ALeffectslot::~ALeffectslot()
+{
+    if(Target)
+        DecrementRef(Target->ref);
+    Target = nullptr;
+    if(Buffer)
+        DecrementRef(Buffer->ref);
+    Buffer = nullptr;
+
+    if(EffectSlotProps *props{mSlot->Update.exchange(nullptr)})
+    {
+        TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n",
+            decltype(std::declval<void*>()){props});
+        delete props;
+    }
+
+    mSlot->mEffectState = nullptr;
+    mSlot->InUse = false;
+}
+
+ALenum ALeffectslot::initEffect(ALenum effectType, const EffectProps &effectProps,
+    ALCcontext *context)
+{
+    EffectSlotType newtype{EffectSlotTypeFromEnum(effectType)};
+    if(newtype != Effect.Type)
     {
         EffectStateFactory *factory{getFactoryByType(newtype)};
         if(!factory)
         {
-            ERR("Failed to find factory for effect type 0x%04x\n", newtype);
+            ERR("Failed to find factory for effect slot type %d\n", static_cast<int>(newtype));
             return AL_INVALID_ENUM;
         }
-        EffectState *State{factory->create()};
-        if(!State) return AL_OUT_OF_MEMORY;
-
-        FPUCtl mixer_mode{};
-        ALCdevice *Device{Context->mDevice.get()};
-        std::unique_lock<std::mutex> statelock{Device->StateLock};
-        State->mOutTarget = Device->Dry.Buffer;
-        if(State->deviceUpdate(Device) == AL_FALSE)
-        {
-            statelock.unlock();
-            mixer_mode.leave();
-            State->release();
-            return AL_OUT_OF_MEMORY;
-        }
-        mixer_mode.leave();
+        al::intrusive_ptr<EffectState> state{factory->create()};
 
-        if(!effect)
+        ALCdevice *device{context->mALDevice.get()};
+        std::unique_lock<std::mutex> statelock{device->StateLock};
+        state->mOutTarget = device->Dry.Buffer;
         {
-            EffectSlot->Effect.Type = AL_EFFECT_NULL;
-            EffectSlot->Effect.Props = EffectProps {};
-        }
-        else
-        {
-            EffectSlot->Effect.Type = effect->type;
-            EffectSlot->Effect.Props = effect->Props;
+            FPUCtl mixer_mode{};
+            state->deviceUpdate(device, Buffer);
         }
 
-        EffectSlot->Effect.State->release();
-        EffectSlot->Effect.State = State;
+        Effect.Type = newtype;
+        Effect.Props = effectProps;
+
+        Effect.State = std::move(state);
     }
-    else if(effect)
-        EffectSlot->Effect.Props = effect->Props;
+    else if(newtype != EffectSlotType::None)
+        Effect.Props = effectProps;
 
     /* Remove state references from old effect slot property updates. */
-    ALeffectslotProps *props{Context->mFreeEffectslotProps.load()};
+    EffectSlotProps *props{context->mFreeEffectslotProps.load()};
     while(props)
     {
-        if(props->State)
-            props->State->release();
         props->State = nullptr;
         props = props->next.load(std::memory_order_relaxed);
     }
@@ -686,49 +967,15 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
     return AL_NO_ERROR;
 }
 
-
-ALenum InitEffectSlot(ALeffectslot *slot)
-{
-    EffectStateFactory *factory{getFactoryByType(slot->Effect.Type)};
-    if(!factory) return AL_INVALID_VALUE;
-    slot->Effect.State = factory->create();
-    if(!slot->Effect.State) return AL_OUT_OF_MEMORY;
-
-    slot->Effect.State->add_ref();
-    slot->Params.mEffectState = slot->Effect.State;
-    return AL_NO_ERROR;
-}
-
-ALeffectslot::~ALeffectslot()
-{
-    if(Target)
-        DecrementRef(Target->ref);
-    Target = nullptr;
-
-    ALeffectslotProps *props{Params.Update.load()};
-    if(props)
-    {
-        if(props->State) props->State->release();
-        TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n",
-            decltype(std::declval<void*>()){props});
-        delete props;
-    }
-
-    if(Effect.State)
-        Effect.State->release();
-    if(Params.mEffectState)
-        Params.mEffectState->release();
-}
-
-void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
+void ALeffectslot::updateProps(ALCcontext *context)
 {
     /* Get an unused property container, or allocate a new one as needed. */
-    ALeffectslotProps *props{context->mFreeEffectslotProps.load(std::memory_order_relaxed)};
+    EffectSlotProps *props{context->mFreeEffectslotProps.load(std::memory_order_relaxed)};
     if(!props)
-        props = new ALeffectslotProps{};
+        props = new EffectSlotProps{};
     else
     {
-        ALeffectslotProps *next;
+        EffectSlotProps *next;
         do {
             next = props->next.load(std::memory_order_relaxed);
         } while(context->mFreeEffectslotProps.compare_exchange_weak(props, next,
@@ -736,44 +983,41 @@ void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
     }
 
     /* Copy in current property values. */
-    props->Gain = slot->Gain;
-    props->AuxSendAuto = slot->AuxSendAuto;
-    props->Target = slot->Target;
-
-    props->Type = slot->Effect.Type;
-    props->Props = slot->Effect.Props;
-    /* Swap out any stale effect state object there may be in the container, to
-     * delete it.
-     */
-    EffectState *oldstate{props->State};
-    slot->Effect.State->add_ref();
-    props->State = slot->Effect.State;
+    props->Gain = Gain;
+    props->AuxSendAuto = AuxSendAuto;
+    props->Target = Target ? Target->mSlot : nullptr;
+
+    props->Type = Effect.Type;
+    props->Props = Effect.Props;
+    props->State = Effect.State;
 
     /* Set the new container for updating internal parameters. */
-    props = slot->Params.Update.exchange(props, std::memory_order_acq_rel);
+    props = mSlot->Update.exchange(props, std::memory_order_acq_rel);
     if(props)
     {
         /* If there was an unused update container, put it back in the
          * freelist.
          */
-        if(props->State)
-            props->State->release();
         props->State = nullptr;
         AtomicReplaceHead(context->mFreeEffectslotProps, props);
     }
-
-    if(oldstate)
-        oldstate->release();
 }
 
 void UpdateAllEffectSlotProps(ALCcontext *context)
 {
     std::lock_guard<std::mutex> _{context->mEffectSlotLock};
-    ALeffectslotArray *auxslots{context->mActiveAuxSlots.load(std::memory_order_acquire)};
-    for(ALeffectslot *slot : *auxslots)
+    for(auto &sublist : context->mEffectSlotList)
     {
-        if(!slot->PropsClean.test_and_set(std::memory_order_acq_rel))
-            UpdateEffectSlotProps(slot, context);
+        uint64_t usemask{~sublist.FreeMask};
+        while(usemask)
+        {
+            const int idx{al::countr_zero(usemask)};
+            usemask &= ~(1_u64 << idx);
+            ALeffectslot *slot{sublist.EffectSlots + idx};
+
+            if(slot->mState != SlotState::Stopped && std::exchange(slot->mPropsDirty, false))
+                slot->updateProps(context);
+        }
     }
 }
 
@@ -782,7 +1026,7 @@ EffectSlotSubList::~EffectSlotSubList()
     uint64_t usemask{~FreeMask};
     while(usemask)
     {
-        ALsizei idx{CTZ64(usemask)};
+        const int idx{al::countr_zero(usemask)};
         al::destroy_at(EffectSlots+idx);
         usemask &= ~(1_u64 << idx);
     }
@@ -790,3 +1034,530 @@ EffectSlotSubList::~EffectSlotSubList()
     al_free(EffectSlots);
     EffectSlots = nullptr;
 }
+
+#ifdef ALSOFT_EAX
+void ALeffectslot::eax_initialize(ALCcontext& al_context, EaxFxSlotIndexValue index)
+{
+    if(index >= EAX_MAX_FXSLOTS)
+        eax_fail("Index out of range.");
+
+    eax_al_context_ = &al_context;
+    eax_fx_slot_index_ = index;
+    eax_fx_slot_set_defaults();
+
+    eax_effect_ = std::make_unique<EaxEffect>();
+    if(index == 0) eax_effect_->init<EaxReverbCommitter>();
+    else if(index == 1) eax_effect_->init<EaxChorusCommitter>();
+    else eax_effect_->init<EaxNullCommitter>();
+}
+
+void ALeffectslot::eax_commit()
+{
+    if(eax_df_ != EaxDirtyFlags{})
+    {
+        auto df = EaxDirtyFlags{};
+        switch(eax_version_)
+        {
+        case 1:
+        case 2:
+        case 3:
+            eax5_fx_slot_commit(eax123_, df);
+            break;
+        case 4:
+            eax4_fx_slot_commit(df);
+            break;
+        case 5:
+            eax5_fx_slot_commit(eax5_, df);
+            break;
+        }
+        eax_df_ = EaxDirtyFlags{};
+
+        if((df & eax_volume_dirty_bit) != EaxDirtyFlags{})
+            eax_fx_slot_set_volume();
+        if((df & eax_flags_dirty_bit) != EaxDirtyFlags{})
+            eax_fx_slot_set_flags();
+    }
+
+    if(eax_effect_->commit(eax_version_))
+        eax_set_efx_slot_effect(*eax_effect_);
+}
+
+[[noreturn]] void ALeffectslot::eax_fail(const char* message)
+{
+    throw Exception{message};
+}
+
+[[noreturn]] void ALeffectslot::eax_fail_unknown_effect_id()
+{
+    eax_fail("Unknown effect ID.");
+}
+
+[[noreturn]] void ALeffectslot::eax_fail_unknown_property_id()
+{
+    eax_fail("Unknown property ID.");
+}
+
+[[noreturn]] void ALeffectslot::eax_fail_unknown_version()
+{
+    eax_fail("Unknown version.");
+}
+
+void ALeffectslot::eax4_fx_slot_ensure_unlocked() const
+{
+    if(eax4_fx_slot_is_legacy())
+        eax_fail("Locked legacy slot.");
+}
+
+ALenum ALeffectslot::eax_get_efx_effect_type(const GUID& guid)
+{
+    if(guid == EAX_NULL_GUID)
+        return AL_EFFECT_NULL;
+    if(guid == EAX_AUTOWAH_EFFECT)
+        return AL_EFFECT_AUTOWAH;
+    if(guid == EAX_CHORUS_EFFECT)
+        return AL_EFFECT_CHORUS;
+    if(guid == EAX_AGCCOMPRESSOR_EFFECT)
+        return AL_EFFECT_COMPRESSOR;
+    if(guid == EAX_DISTORTION_EFFECT)
+        return AL_EFFECT_DISTORTION;
+    if(guid == EAX_REVERB_EFFECT)
+        return AL_EFFECT_EAXREVERB;
+    if(guid == EAX_ECHO_EFFECT)
+        return AL_EFFECT_ECHO;
+    if(guid == EAX_EQUALIZER_EFFECT)
+        return AL_EFFECT_EQUALIZER;
+    if(guid == EAX_FLANGER_EFFECT)
+        return AL_EFFECT_FLANGER;
+    if(guid == EAX_FREQUENCYSHIFTER_EFFECT)
+        return AL_EFFECT_FREQUENCY_SHIFTER;
+    if(guid == EAX_PITCHSHIFTER_EFFECT)
+        return AL_EFFECT_PITCH_SHIFTER;
+    if(guid == EAX_RINGMODULATOR_EFFECT)
+        return AL_EFFECT_RING_MODULATOR;
+    if(guid == EAX_VOCALMORPHER_EFFECT)
+        return AL_EFFECT_VOCAL_MORPHER;
+
+    eax_fail_unknown_effect_id();
+}
+
+const GUID& ALeffectslot::eax_get_eax_default_effect_guid() const noexcept
+{
+    switch(eax_fx_slot_index_)
+    {
+    case 0: return EAX_REVERB_EFFECT;
+    case 1: return EAX_CHORUS_EFFECT;
+    default: return EAX_NULL_GUID;
+    }
+}
+
+long ALeffectslot::eax_get_eax_default_lock() const noexcept
+{
+    return eax4_fx_slot_is_legacy() ? EAXFXSLOT_LOCKED : EAXFXSLOT_UNLOCKED;
+}
+
+void ALeffectslot::eax4_fx_slot_set_defaults(Eax4Props& props) noexcept
+{
+    props.guidLoadEffect = eax_get_eax_default_effect_guid();
+    props.lVolume = EAXFXSLOT_DEFAULTVOLUME;
+    props.lLock = eax_get_eax_default_lock();
+    props.ulFlags = EAX40FXSLOT_DEFAULTFLAGS;
+}
+
+void ALeffectslot::eax5_fx_slot_set_defaults(Eax5Props& props) noexcept
+{
+    props.guidLoadEffect = eax_get_eax_default_effect_guid();
+    props.lVolume = EAXFXSLOT_DEFAULTVOLUME;
+    props.lLock = EAXFXSLOT_UNLOCKED;
+    props.ulFlags = EAX50FXSLOT_DEFAULTFLAGS;
+    props.lOcclusion = EAXFXSLOT_DEFAULTOCCLUSION;
+    props.flOcclusionLFRatio = EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO;
+}
+
+void ALeffectslot::eax_fx_slot_set_defaults()
+{
+    eax5_fx_slot_set_defaults(eax123_.i);
+    eax4_fx_slot_set_defaults(eax4_.i);
+    eax5_fx_slot_set_defaults(eax5_.i);
+    eax_ = eax5_.i;
+    eax_df_ = EaxDirtyFlags{};
+}
+
+void ALeffectslot::eax4_fx_slot_get(const EaxCall& call, const Eax4Props& props) const
+{
+    switch(call.get_property_id())
+    {
+    case EAXFXSLOT_ALLPARAMETERS:
+        call.set_value<Exception>(props);
+        break;
+    case EAXFXSLOT_LOADEFFECT:
+        call.set_value<Exception>(props.guidLoadEffect);
+        break;
+    case EAXFXSLOT_VOLUME:
+        call.set_value<Exception>(props.lVolume);
+        break;
+    case EAXFXSLOT_LOCK:
+        call.set_value<Exception>(props.lLock);
+        break;
+    case EAXFXSLOT_FLAGS:
+        call.set_value<Exception>(props.ulFlags);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+}
+
+void ALeffectslot::eax5_fx_slot_get(const EaxCall& call, const Eax5Props& props) const
+{
+    switch(call.get_property_id())
+    {
+    case EAXFXSLOT_ALLPARAMETERS:
+        call.set_value<Exception>(props);
+        break;
+    case EAXFXSLOT_LOADEFFECT:
+        call.set_value<Exception>(props.guidLoadEffect);
+        break;
+    case EAXFXSLOT_VOLUME:
+        call.set_value<Exception>(props.lVolume);
+        break;
+    case EAXFXSLOT_LOCK:
+        call.set_value<Exception>(props.lLock);
+        break;
+    case EAXFXSLOT_FLAGS:
+        call.set_value<Exception>(props.ulFlags);
+        break;
+    case EAXFXSLOT_OCCLUSION:
+        call.set_value<Exception>(props.lOcclusion);
+        break;
+    case EAXFXSLOT_OCCLUSIONLFRATIO:
+        call.set_value<Exception>(props.flOcclusionLFRatio);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+}
+
+void ALeffectslot::eax_fx_slot_get(const EaxCall& call) const
+{
+    switch(call.get_version())
+    {
+    case 4: eax4_fx_slot_get(call, eax4_.i); break;
+    case 5: eax5_fx_slot_get(call, eax5_.i); break;
+    default: eax_fail_unknown_version();
+    }
+}
+
+bool ALeffectslot::eax_get(const EaxCall& call)
+{
+    switch(call.get_property_set_id())
+    {
+    case EaxCallPropertySetId::fx_slot:
+        eax_fx_slot_get(call);
+        break;
+    case EaxCallPropertySetId::fx_slot_effect:
+        eax_effect_->get(call);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+
+    return false;
+}
+
+void ALeffectslot::eax_fx_slot_load_effect(int version, ALenum altype)
+{
+    if(!IsValidEffectType(altype))
+        altype = AL_EFFECT_NULL;
+    eax_effect_->set_defaults(version, altype);
+}
+
+void ALeffectslot::eax_fx_slot_set_volume()
+{
+    const auto volume = clamp(eax_.lVolume, EAXFXSLOT_MINVOLUME, EAXFXSLOT_MAXVOLUME);
+    const auto gain = level_mb_to_gain(static_cast<float>(volume));
+    eax_set_efx_slot_gain(gain);
+}
+
+void ALeffectslot::eax_fx_slot_set_environment_flag()
+{
+    eax_set_efx_slot_send_auto((eax_.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0u);
+}
+
+void ALeffectslot::eax_fx_slot_set_flags()
+{
+    eax_fx_slot_set_environment_flag();
+}
+
+void ALeffectslot::eax4_fx_slot_set_all(const EaxCall& call)
+{
+    eax4_fx_slot_ensure_unlocked();
+    const auto& src = call.get_value<Exception, const EAX40FXSLOTPROPERTIES>();
+    Eax4AllValidator{}(src);
+    auto& dst = eax4_.i;
+    eax_df_ |= eax_load_effect_dirty_bit; // Always reset the effect.
+    eax_df_ |= (dst.lVolume != src.lVolume ? eax_volume_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.lLock != src.lLock ? eax_lock_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.ulFlags != src.ulFlags ? eax_flags_dirty_bit : EaxDirtyFlags{});
+    dst = src;
+}
+
+void ALeffectslot::eax5_fx_slot_set_all(const EaxCall& call)
+{
+    const auto& src = call.get_value<Exception, const EAX50FXSLOTPROPERTIES>();
+    Eax5AllValidator{}(src);
+    auto& dst = eax5_.i;
+    eax_df_ |= eax_load_effect_dirty_bit; // Always reset the effect.
+    eax_df_ |= (dst.lVolume != src.lVolume ? eax_volume_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.lLock != src.lLock ? eax_lock_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.ulFlags != src.ulFlags ? eax_flags_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.lOcclusion != src.lOcclusion ? eax_flags_dirty_bit : EaxDirtyFlags{});
+    eax_df_ |= (dst.flOcclusionLFRatio != src.flOcclusionLFRatio ? eax_flags_dirty_bit : EaxDirtyFlags{});
+    dst = src;
+}
+
+bool ALeffectslot::eax_fx_slot_should_update_sources() const noexcept
+{
+    const auto dirty_bits =
+        eax_occlusion_dirty_bit |
+        eax_occlusion_lf_ratio_dirty_bit |
+        eax_flags_dirty_bit;
+
+    if((eax_df_ & dirty_bits) != EaxDirtyFlags{})
+        return true;
+
+    return false;
+}
+
+// Returns `true` if all sources should be updated, or `false` otherwise.
+bool ALeffectslot::eax4_fx_slot_set(const EaxCall& call)
+{
+    auto& dst = eax4_.i;
+
+    switch(call.get_property_id())
+    {
+    case EAXFXSLOT_NONE:
+        break;
+    case EAXFXSLOT_ALLPARAMETERS:
+        eax4_fx_slot_set_all(call);
+        if((eax_df_ & eax_load_effect_dirty_bit))
+            eax_fx_slot_load_effect(4, eax_get_efx_effect_type(dst.guidLoadEffect));
+        break;
+    case EAXFXSLOT_LOADEFFECT:
+        eax4_fx_slot_ensure_unlocked();
+        eax_fx_slot_set_dirty<Eax4GuidLoadEffectValidator, eax_load_effect_dirty_bit>(call, dst.guidLoadEffect, eax_df_);
+        if((eax_df_ & eax_load_effect_dirty_bit))
+            eax_fx_slot_load_effect(4, eax_get_efx_effect_type(dst.guidLoadEffect));
+        break;
+    case EAXFXSLOT_VOLUME:
+        eax_fx_slot_set<Eax4VolumeValidator, eax_volume_dirty_bit>(call, dst.lVolume, eax_df_);
+        break;
+    case EAXFXSLOT_LOCK:
+        eax4_fx_slot_ensure_unlocked();
+        eax_fx_slot_set<Eax4LockValidator, eax_lock_dirty_bit>(call, dst.lLock, eax_df_);
+        break;
+    case EAXFXSLOT_FLAGS:
+        eax_fx_slot_set<Eax4FlagsValidator, eax_flags_dirty_bit>(call, dst.ulFlags, eax_df_);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+
+    return eax_fx_slot_should_update_sources();
+}
+
+// Returns `true` if all sources should be updated, or `false` otherwise.
+bool ALeffectslot::eax5_fx_slot_set(const EaxCall& call)
+{
+    auto& dst = eax5_.i;
+
+    switch(call.get_property_id())
+    {
+    case EAXFXSLOT_NONE:
+        break;
+    case EAXFXSLOT_ALLPARAMETERS:
+        eax5_fx_slot_set_all(call);
+        if((eax_df_ & eax_load_effect_dirty_bit))
+            eax_fx_slot_load_effect(5, eax_get_efx_effect_type(dst.guidLoadEffect));
+        break;
+    case EAXFXSLOT_LOADEFFECT:
+        eax_fx_slot_set_dirty<Eax4GuidLoadEffectValidator, eax_load_effect_dirty_bit>(call, dst.guidLoadEffect, eax_df_);
+        if((eax_df_ & eax_load_effect_dirty_bit))
+            eax_fx_slot_load_effect(5, eax_get_efx_effect_type(dst.guidLoadEffect));
+        break;
+    case EAXFXSLOT_VOLUME:
+        eax_fx_slot_set<Eax4VolumeValidator, eax_volume_dirty_bit>(call, dst.lVolume, eax_df_);
+        break;
+    case EAXFXSLOT_LOCK:
+        eax_fx_slot_set<Eax4LockValidator, eax_lock_dirty_bit>(call, dst.lLock, eax_df_);
+        break;
+    case EAXFXSLOT_FLAGS:
+        eax_fx_slot_set<Eax5FlagsValidator, eax_flags_dirty_bit>(call, dst.ulFlags, eax_df_);
+        break;
+    case EAXFXSLOT_OCCLUSION:
+        eax_fx_slot_set<Eax5OcclusionValidator, eax_occlusion_dirty_bit>(call, dst.lOcclusion, eax_df_);
+        break;
+    case EAXFXSLOT_OCCLUSIONLFRATIO:
+        eax_fx_slot_set<Eax5OcclusionLfRatioValidator, eax_occlusion_lf_ratio_dirty_bit>(call, dst.flOcclusionLFRatio, eax_df_);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+
+    return eax_fx_slot_should_update_sources();
+}
+
+// Returns `true` if all sources should be updated, or `false` otherwise.
+bool ALeffectslot::eax_fx_slot_set(const EaxCall& call)
+{
+    switch (call.get_version())
+    {
+    case 4: return eax4_fx_slot_set(call);
+    case 5: return eax5_fx_slot_set(call);
+    default: eax_fail_unknown_version();
+    }
+}
+
+// Returns `true` if all sources should be updated, or `false` otherwise.
+bool ALeffectslot::eax_set(const EaxCall& call)
+{
+    bool ret{false};
+
+    switch(call.get_property_set_id())
+    {
+    case EaxCallPropertySetId::fx_slot: ret = eax_fx_slot_set(call); break;
+    case EaxCallPropertySetId::fx_slot_effect: eax_effect_->set(call); break;
+    default: eax_fail_unknown_property_id();
+    }
+
+    const auto version = call.get_version();
+    if(eax_version_ != version)
+        eax_df_ = ~EaxDirtyFlags{};
+    eax_version_ = version;
+
+    return ret;
+}
+
+void ALeffectslot::eax4_fx_slot_commit(EaxDirtyFlags& dst_df)
+{
+    eax_fx_slot_commit_property<eax_load_effect_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::guidLoadEffect);
+    eax_fx_slot_commit_property<eax_volume_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::lVolume);
+    eax_fx_slot_commit_property<eax_lock_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::lLock);
+    eax_fx_slot_commit_property<eax_flags_dirty_bit>(eax4_, dst_df, &EAX40FXSLOTPROPERTIES::ulFlags);
+
+    auto& dst_i = eax_;
+
+    if(dst_i.lOcclusion != EAXFXSLOT_DEFAULTOCCLUSION) {
+        dst_df |= eax_occlusion_dirty_bit;
+        dst_i.lOcclusion = EAXFXSLOT_DEFAULTOCCLUSION;
+    }
+
+    if(dst_i.flOcclusionLFRatio != EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO) {
+        dst_df |= eax_occlusion_lf_ratio_dirty_bit;
+        dst_i.flOcclusionLFRatio = EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO;
+    }
+}
+
+void ALeffectslot::eax5_fx_slot_commit(Eax5State& state, EaxDirtyFlags& dst_df)
+{
+    eax_fx_slot_commit_property<eax_load_effect_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::guidLoadEffect);
+    eax_fx_slot_commit_property<eax_volume_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lVolume);
+    eax_fx_slot_commit_property<eax_lock_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lLock);
+    eax_fx_slot_commit_property<eax_flags_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::ulFlags);
+    eax_fx_slot_commit_property<eax_occlusion_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::lOcclusion);
+    eax_fx_slot_commit_property<eax_occlusion_lf_ratio_dirty_bit>(state, dst_df, &EAX50FXSLOTPROPERTIES::flOcclusionLFRatio);
+}
+
+void ALeffectslot::eax_set_efx_slot_effect(EaxEffect &effect)
+{
+#define EAX_PREFIX "[EAX_SET_EFFECT_SLOT_EFFECT] "
+
+    const auto error = initEffect(effect.al_effect_type_, effect.al_effect_props_, eax_al_context_);
+
+    if(error != AL_NO_ERROR) {
+        ERR(EAX_PREFIX "%s\n", "Failed to initialize an effect.");
+        return;
+    }
+
+    if(mState == SlotState::Initial) {
+        mPropsDirty = false;
+        updateProps(eax_al_context_);
+        auto effect_slot_ptr = this;
+        AddActiveEffectSlots({&effect_slot_ptr, 1}, eax_al_context_);
+        mState = SlotState::Playing;
+        return;
+    }
+
+    mPropsDirty = true;
+
+#undef EAX_PREFIX
+}
+
+void ALeffectslot::eax_set_efx_slot_send_auto(bool is_send_auto)
+{
+    if(AuxSendAuto == is_send_auto)
+        return;
+
+    AuxSendAuto = is_send_auto;
+    mPropsDirty = true;
+}
+
+void ALeffectslot::eax_set_efx_slot_gain(ALfloat gain)
+{
+#define EAX_PREFIX "[EAX_SET_EFFECT_SLOT_GAIN] "
+
+    if(gain == Gain)
+        return;
+    if(gain < 0.0f || gain > 1.0f)
+        ERR(EAX_PREFIX "Gain out of range (%f)\n", gain);
+
+    Gain = clampf(gain, 0.0f, 1.0f);
+    mPropsDirty = true;
+
+#undef EAX_PREFIX
+}
+
+void ALeffectslot::EaxDeleter::operator()(ALeffectslot* effect_slot)
+{
+    assert(effect_slot);
+    eax_delete_al_effect_slot(*effect_slot->eax_al_context_, *effect_slot);
+}
+
+EaxAlEffectSlotUPtr eax_create_al_effect_slot(ALCcontext& context)
+{
+#define EAX_PREFIX "[EAX_MAKE_EFFECT_SLOT] "
+
+    std::unique_lock<std::mutex> effect_slot_lock{context.mEffectSlotLock};
+    auto& device = *context.mALDevice;
+
+    if(context.mNumEffectSlots == device.AuxiliaryEffectSlotMax) {
+        ERR(EAX_PREFIX "%s\n", "Out of memory.");
+        return nullptr;
+    }
+
+    if(!EnsureEffectSlots(&context, 1)) {
+        ERR(EAX_PREFIX "%s\n", "Failed to ensure.");
+        return nullptr;
+    }
+
+    return EaxAlEffectSlotUPtr{AllocEffectSlot(&context)};
+
+#undef EAX_PREFIX
+}
+
+void eax_delete_al_effect_slot(ALCcontext& context, ALeffectslot& effect_slot)
+{
+#define EAX_PREFIX "[EAX_DELETE_EFFECT_SLOT] "
+
+    std::lock_guard<std::mutex> effect_slot_lock{context.mEffectSlotLock};
+
+    if(ReadRef(effect_slot.ref) != 0) {
+        ERR(EAX_PREFIX "Deleting in-use effect slot %u.\n", effect_slot.id);
+        return;
+    }
+
+    auto effect_slot_ptr = &effect_slot;
+    RemoveActiveEffectSlots({&effect_slot_ptr, 1}, &context);
+    FreeEffectSlot(&context, &effect_slot);
+
+#undef EAX_PREFIX
+}
+#endif // ALSOFT_EAX
diff --git a/al/auxeffectslot.h b/al/auxeffectslot.h
index 2471447f..3e9a2a4e 100644
--- a/al/auxeffectslot.h
+++ b/al/auxeffectslot.h
@@ -8,98 +8,361 @@
 #include "AL/alc.h"
 #include "AL/efx.h"
 
-#include "alcmain.h"
+#include "alc/device.h"
+#include "alc/effects/base.h"
 #include "almalloc.h"
 #include "atomic.h"
-#include "effects/base.h"
+#include "core/effectslot.h"
+#include "intrusive_ptr.h"
 #include "vector.h"
 
-struct ALeffect;
-struct ALeffectslot;
-
-
-using ALeffectslotArray = al::FlexArray<ALeffectslot*>;
-
-
-struct ALeffectslotProps {
-    ALfloat   Gain;
-    ALboolean AuxSendAuto;
-    ALeffectslot *Target;
+#ifdef ALSOFT_EAX
+#include <memory>
+#include "eax/call.h"
+#include "eax/effect.h"
+#include "eax/exception.h"
+#include "eax/fx_slot_index.h"
+#include "eax/utils.h"
+#endif // ALSOFT_EAX
 
-    ALenum Type;
-    EffectProps Props;
-
-    EffectState *State;
-
-    std::atomic<ALeffectslotProps*> next;
-
-    DEF_NEWDEL(ALeffectslotProps)
+struct ALbuffer;
+struct ALeffect;
+struct WetBuffer;
+
+#ifdef ALSOFT_EAX
+class EaxFxSlotException : public EaxException {
+public:
+	explicit EaxFxSlotException(const char* message)
+		: EaxException{"EAX_FX_SLOT", message}
+	{}
 };
+#endif // ALSOFT_EAX
 
+enum class SlotState : ALenum {
+    Initial = AL_INITIAL,
+    Playing = AL_PLAYING,
+    Stopped = AL_STOPPED,
+};
 
 struct ALeffectslot {
-    ALfloat   Gain{1.0f};
-    ALboolean AuxSendAuto{AL_TRUE};
+    float Gain{1.0f};
+    bool  AuxSendAuto{true};
     ALeffectslot *Target{nullptr};
+    ALbuffer *Buffer{nullptr};
 
     struct {
-        ALenum Type{AL_EFFECT_NULL};
+        EffectSlotType Type{EffectSlotType::None};
         EffectProps Props{};
 
-        EffectState *State{nullptr};
+        al::intrusive_ptr<EffectState> State;
     } Effect;
 
-    std::atomic_flag PropsClean;
+    bool mPropsDirty{true};
 
-    RefCount ref{0u};
-
-    struct {
-        std::atomic<ALeffectslotProps*> Update{nullptr};
+    SlotState mState{SlotState::Initial};
 
-        ALfloat   Gain{1.0f};
-        ALboolean AuxSendAuto{AL_TRUE};
-        ALeffectslot *Target{nullptr};
-
-        ALenum EffectType{AL_EFFECT_NULL};
-        EffectProps mEffectProps{};
-        EffectState *mEffectState{nullptr};
+    RefCount ref{0u};
 
-        ALfloat RoomRolloff{0.0f}; /* Added to the source's room rolloff, not multiplied. */
-        ALfloat DecayTime{0.0f};
-        ALfloat DecayLFRatio{0.0f};
-        ALfloat DecayHFRatio{0.0f};
-        ALboolean DecayHFLimit{AL_FALSE};
-        ALfloat AirAbsorptionGainHF{1.0f};
-    } Params;
+    EffectSlot *mSlot{nullptr};
 
     /* Self ID */
     ALuint id{};
 
-    /* Mixing buffer used by the Wet mix. */
-    al::vector<FloatBufferLine, 16> MixBuffer;
-
-    /* Wet buffer configuration is ACN channel order with N3D scaling.
-     * Consequently, effects that only want to work with mono input can use
-     * channel 0 by itself. Effects that want multichannel can process the
-     * ambisonics signal and make a B-Format source pan.
-     */
-    MixParams Wet;
-
-    ALeffectslot() { PropsClean.test_and_set(std::memory_order_relaxed); }
+    ALeffectslot(ALCcontext *context);
     ALeffectslot(const ALeffectslot&) = delete;
     ALeffectslot& operator=(const ALeffectslot&) = delete;
     ~ALeffectslot();
 
-    static ALeffectslotArray *CreatePtrArray(size_t count) noexcept;
+    ALenum initEffect(ALenum effectType, const EffectProps &effectProps, ALCcontext *context);
+    void updateProps(ALCcontext *context);
 
+    /* This can be new'd for the context's default effect slot. */
     DEF_NEWDEL(ALeffectslot)
+
+
+#ifdef ALSOFT_EAX
+public:
+    void eax_initialize(ALCcontext& al_context, EaxFxSlotIndexValue index);
+
+    EaxFxSlotIndexValue eax_get_index() const noexcept { return eax_fx_slot_index_; }
+    const EAX50FXSLOTPROPERTIES& eax_get_eax_fx_slot() const noexcept
+    { return eax_; }
+
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax_dispatch(const EaxCall& call)
+    { return call.is_get() ? eax_get(call) : eax_set(call); }
+
+    void eax_commit();
+
+private:
+    static constexpr auto eax_load_effect_dirty_bit = EaxDirtyFlags{1} << 0;
+    static constexpr auto eax_volume_dirty_bit = EaxDirtyFlags{1} << 1;
+    static constexpr auto eax_lock_dirty_bit = EaxDirtyFlags{1} << 2;
+    static constexpr auto eax_flags_dirty_bit = EaxDirtyFlags{1} << 3;
+    static constexpr auto eax_occlusion_dirty_bit = EaxDirtyFlags{1} << 4;
+    static constexpr auto eax_occlusion_lf_ratio_dirty_bit = EaxDirtyFlags{1} << 5;
+
+    using Exception = EaxFxSlotException;
+
+    using Eax4Props = EAX40FXSLOTPROPERTIES;
+
+    struct Eax4State {
+        Eax4Props i; // Immediate.
+    };
+
+    using Eax5Props = EAX50FXSLOTPROPERTIES;
+
+    struct Eax5State {
+        Eax5Props i; // Immediate.
+    };
+
+    struct EaxRangeValidator {
+        template<typename TValue>
+        void operator()(
+            const char* name,
+            const TValue& value,
+            const TValue& min_value,
+            const TValue& max_value) const
+        {
+            eax_validate_range<Exception>(name, value, min_value, max_value);
+        }
+    };
+
+    struct Eax4GuidLoadEffectValidator {
+        void operator()(const GUID& guidLoadEffect) const
+        {
+            if (guidLoadEffect != EAX_NULL_GUID &&
+                guidLoadEffect != EAX_REVERB_EFFECT &&
+                guidLoadEffect != EAX_AGCCOMPRESSOR_EFFECT &&
+                guidLoadEffect != EAX_AUTOWAH_EFFECT &&
+                guidLoadEffect != EAX_CHORUS_EFFECT &&
+                guidLoadEffect != EAX_DISTORTION_EFFECT &&
+                guidLoadEffect != EAX_ECHO_EFFECT &&
+                guidLoadEffect != EAX_EQUALIZER_EFFECT &&
+                guidLoadEffect != EAX_FLANGER_EFFECT &&
+                guidLoadEffect != EAX_FREQUENCYSHIFTER_EFFECT &&
+                guidLoadEffect != EAX_VOCALMORPHER_EFFECT &&
+                guidLoadEffect != EAX_PITCHSHIFTER_EFFECT &&
+                guidLoadEffect != EAX_RINGMODULATOR_EFFECT)
+            {
+                eax_fail_unknown_effect_id();
+            }
+        }
+    };
+
+    struct Eax4VolumeValidator {
+        void operator()(long lVolume) const
+        {
+            EaxRangeValidator{}(
+                "Volume",
+                lVolume,
+                EAXFXSLOT_MINVOLUME,
+                EAXFXSLOT_MAXVOLUME);
+        }
+    };
+
+    struct Eax4LockValidator {
+        void operator()(long lLock) const
+        {
+            EaxRangeValidator{}(
+                "Lock",
+                lLock,
+                EAXFXSLOT_MINLOCK,
+                EAXFXSLOT_MAXLOCK);
+        }
+    };
+
+    struct Eax4FlagsValidator {
+        void operator()(unsigned long ulFlags) const
+        {
+            EaxRangeValidator{}(
+                "Flags",
+                ulFlags,
+                0UL,
+                ~EAX40FXSLOTFLAGS_RESERVED);
+        }
+    };
+
+    struct Eax4AllValidator {
+        void operator()(const EAX40FXSLOTPROPERTIES& all) const
+        {
+            Eax4GuidLoadEffectValidator{}(all.guidLoadEffect);
+            Eax4VolumeValidator{}(all.lVolume);
+            Eax4LockValidator{}(all.lLock);
+            Eax4FlagsValidator{}(all.ulFlags);
+        }
+    };
+
+    struct Eax5OcclusionValidator {
+        void operator()(long lOcclusion) const
+        {
+            EaxRangeValidator{}(
+                "Occlusion",
+                lOcclusion,
+                EAXFXSLOT_MINOCCLUSION,
+                EAXFXSLOT_MAXOCCLUSION);
+        }
+    };
+
+    struct Eax5OcclusionLfRatioValidator {
+        void operator()(float flOcclusionLFRatio) const
+        {
+            EaxRangeValidator{}(
+                "Occlusion LF Ratio",
+                flOcclusionLFRatio,
+                EAXFXSLOT_MINOCCLUSIONLFRATIO,
+                EAXFXSLOT_MAXOCCLUSIONLFRATIO);
+        }
+    };
+
+    struct Eax5FlagsValidator {
+        void operator()(unsigned long ulFlags) const
+        {
+            EaxRangeValidator{}(
+                "Flags",
+                ulFlags,
+                0UL,
+                ~EAX50FXSLOTFLAGS_RESERVED);
+        }
+    };
+
+    struct Eax5AllValidator {
+        void operator()(const EAX50FXSLOTPROPERTIES& all) const
+        {
+            Eax4AllValidator{}(static_cast<const EAX40FXSLOTPROPERTIES&>(all));
+            Eax5OcclusionValidator{}(all.lOcclusion);
+            Eax5OcclusionLfRatioValidator{}(all.flOcclusionLFRatio);
+        }
+    };
+
+    ALCcontext* eax_al_context_{};
+    EaxFxSlotIndexValue eax_fx_slot_index_{};
+    int eax_version_{}; // Current EAX version.
+    EaxDirtyFlags eax_df_{}; // Dirty flags for the current EAX version.
+    EaxEffectUPtr eax_effect_{};
+    Eax5State eax123_{}; // EAX1/EAX2/EAX3 state.
+    Eax4State eax4_{}; // EAX4 state.
+    Eax5State eax5_{}; // EAX5 state.
+    Eax5Props eax_{}; // Current EAX state.
+
+    [[noreturn]] static void eax_fail(const char* message);
+    [[noreturn]] static void eax_fail_unknown_effect_id();
+    [[noreturn]] static void eax_fail_unknown_property_id();
+    [[noreturn]] static void eax_fail_unknown_version();
+
+    // Gets a new value from EAX call,
+    // validates it,
+    // sets a dirty flag only if the new value differs form the old one,
+    // and assigns the new value.
+    template<typename TValidator, EaxDirtyFlags TDirtyBit, typename TProperties>
+    static void eax_fx_slot_set(const EaxCall& call, TProperties& dst, EaxDirtyFlags& dirty_flags)
+    {
+        const auto& src = call.get_value<Exception, const TProperties>();
+        TValidator{}(src);
+        dirty_flags |= (dst != src ? TDirtyBit : EaxDirtyFlags{});
+        dst = src;
+    }
+
+    // Gets a new value from EAX call,
+    // validates it,
+    // sets a dirty flag without comparing the values,
+    // and assigns the new value.
+    template<typename TValidator, EaxDirtyFlags TDirtyBit, typename TProperties>
+    static void eax_fx_slot_set_dirty(const EaxCall& call, TProperties& dst,
+        EaxDirtyFlags& dirty_flags)
+    {
+        const auto& src = call.get_value<Exception, const TProperties>();
+        TValidator{}(src);
+        dirty_flags |= TDirtyBit;
+        dst = src;
+    }
+
+    constexpr bool eax4_fx_slot_is_legacy() const noexcept
+    { return eax_fx_slot_index_ < 2; }
+
+    void eax4_fx_slot_ensure_unlocked() const;
+
+    static ALenum eax_get_efx_effect_type(const GUID& guid);
+    const GUID& eax_get_eax_default_effect_guid() const noexcept;
+    long eax_get_eax_default_lock() const noexcept;
+
+    void eax4_fx_slot_set_defaults(Eax4Props& props) noexcept;
+    void eax5_fx_slot_set_defaults(Eax5Props& props) noexcept;
+    void eax4_fx_slot_set_current_defaults(const Eax4Props& props) noexcept;
+    void eax5_fx_slot_set_current_defaults(const Eax5Props& props) noexcept;
+    void eax_fx_slot_set_current_defaults();
+    void eax_fx_slot_set_defaults();
+
+    void eax4_fx_slot_get(const EaxCall& call, const Eax4Props& props) const;
+    void eax5_fx_slot_get(const EaxCall& call, const Eax5Props& props) const;
+    void eax_fx_slot_get(const EaxCall& call) const;
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax_get(const EaxCall& call);
+
+    void eax_fx_slot_load_effect(int version, ALenum altype);
+    void eax_fx_slot_set_volume();
+    void eax_fx_slot_set_environment_flag();
+    void eax_fx_slot_set_flags();
+
+    void eax4_fx_slot_set_all(const EaxCall& call);
+    void eax5_fx_slot_set_all(const EaxCall& call);
+
+    bool eax_fx_slot_should_update_sources() const noexcept;
+
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax4_fx_slot_set(const EaxCall& call);
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax5_fx_slot_set(const EaxCall& call);
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax_fx_slot_set(const EaxCall& call);
+    // Returns `true` if all sources should be updated, or `false` otherwise.
+    bool eax_set(const EaxCall& call);
+
+    template<
+        EaxDirtyFlags TDirtyBit,
+        typename TMemberResult,
+        typename TProps,
+        typename TState>
+    void eax_fx_slot_commit_property(TState& state, EaxDirtyFlags& dst_df,
+        TMemberResult TProps::*member) noexcept
+    {
+        auto& src_i = state.i;
+        auto& dst_i = eax_;
+
+        if((eax_df_ & TDirtyBit) != EaxDirtyFlags{})
+        {
+            dst_df |= TDirtyBit;
+            dst_i.*member = src_i.*member;
+        }
+    }
+
+    void eax4_fx_slot_commit(EaxDirtyFlags& dst_df);
+    void eax5_fx_slot_commit(Eax5State& state, EaxDirtyFlags& dst_df);
+
+    // `alAuxiliaryEffectSloti(effect_slot, AL_EFFECTSLOT_EFFECT, effect)`
+    void eax_set_efx_slot_effect(EaxEffect &effect);
+
+    // `alAuxiliaryEffectSloti(effect_slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, value)`
+    void eax_set_efx_slot_send_auto(bool is_send_auto);
+
+    // `alAuxiliaryEffectSlotf(effect_slot, AL_EFFECTSLOT_GAIN, gain)`
+    void eax_set_efx_slot_gain(ALfloat gain);
+
+public:
+    class EaxDeleter {
+    public:
+        void operator()(ALeffectslot *effect_slot);
+    };
+#endif // ALSOFT_EAX
 };
 
-ALenum InitEffectSlot(ALeffectslot *slot);
-void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context);
 void UpdateAllEffectSlotProps(ALCcontext *context);
 
+#ifdef ALSOFT_EAX
+using EaxAlEffectSlotUPtr = std::unique_ptr<ALeffectslot, ALeffectslot::EaxDeleter>;
 
-ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
+EaxAlEffectSlotUPtr eax_create_al_effect_slot(ALCcontext& context);
+void eax_delete_al_effect_slot(ALCcontext& context, ALeffectslot& effect_slot);
+#endif // ALSOFT_EAX
 
 #endif
diff --git a/al/buffer.cpp b/al/buffer.cpp
index 8f4228a8..ee506596 100644
--- a/al/buffer.cpp
+++ b/al/buffer.cpp
@@ -35,242 +35,130 @@
 #include <mutex>
 #include <new>
 #include <numeric>
+#include <stdexcept>
 #include <utility>
 
 #include "AL/al.h"
 #include "AL/alc.h"
 #include "AL/alext.h"
 
+#include "albit.h"
 #include "albyte.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "alc/context.h"
+#include "alc/device.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "aloptional.h"
 #include "atomic.h"
-#include "inprogext.h"
+#include "core/except.h"
+#include "core/logging.h"
+#include "core/voice.h"
 #include "opthelpers.h"
 
+#ifdef ALSOFT_EAX
+#include "eax/globals.h"
+#include "eax/x_ram.h"
+#endif // ALSOFT_EAX
+
 
 namespace {
 
-/* IMA ADPCM Stepsize table */
-constexpr int IMAStep_size[89] = {
-       7,    8,    9,   10,   11,   12,   13,   14,   16,   17,   19,
-      21,   23,   25,   28,   31,   34,   37,   41,   45,   50,   55,
-      60,   66,   73,   80,   88,   97,  107,  118,  130,  143,  157,
-     173,  190,  209,  230,  253,  279,  307,  337,  371,  408,  449,
-     494,  544,  598,  658,  724,  796,  876,  963, 1060, 1166, 1282,
-    1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660,
-    4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,
-   11487,12635,13899,15289,16818,18500,20350,22358,24633,27086,29794,
-   32767
-};
-
-/* IMA4 ADPCM Codeword decode table */
-constexpr int IMA4Codeword[16] = {
-    1, 3, 5, 7, 9, 11, 13, 15,
-   -1,-3,-5,-7,-9,-11,-13,-15,
-};
-
-/* IMA4 ADPCM Step index adjust decode table */
-constexpr int IMA4Index_adjust[16] = {
-   -1,-1,-1,-1, 2, 4, 6, 8,
-   -1,-1,-1,-1, 2, 4, 6, 8
-};
-
-
-/* MSADPCM Adaption table */
-constexpr int MSADPCMAdaption[16] = {
-    230, 230, 230, 230, 307, 409, 512, 614,
-    768, 614, 512, 409, 307, 230, 230, 230
-};
-
-/* MSADPCM Adaption Coefficient tables */
-constexpr int MSADPCMAdaptionCoeff[7][2] = {
-    { 256,    0 },
-    { 512, -256 },
-    {   0,    0 },
-    { 192,   64 },
-    { 240,    0 },
-    { 460, -208 },
-    { 392, -232 }
-};
-
-
-void DecodeIMA4Block(ALshort *dst, const al::byte *src, size_t numchans, size_t align)
+al::optional<AmbiLayout> AmbiLayoutFromEnum(ALenum layout)
 {
-    ALint sample[MAX_INPUT_CHANNELS]{};
-    ALint index[MAX_INPUT_CHANNELS]{};
-    ALuint code[MAX_INPUT_CHANNELS]{};
-
-    for(size_t c{0};c < numchans;c++)
+    switch(layout)
     {
-        sample[c] = al::to_integer<int>(src[0]) | (al::to_integer<int>(src[1])<<8);
-        sample[c] = (sample[c]^0x8000) - 32768;
-        src += 2;
-        index[c] = al::to_integer<int>(src[0]) | (al::to_integer<int>(src[1])<<8);
-        index[c] = clampi((index[c]^0x8000) - 32768, 0, 88);
-        src += 2;
-
-        *(dst++) = static_cast<ALshort>(sample[c]);
+    case AL_FUMA_SOFT: return AmbiLayout::FuMa;
+    case AL_ACN_SOFT: return AmbiLayout::ACN;
     }
-
-    for(size_t i{1};i < align;i++)
+    return al::nullopt;
+}
+ALenum EnumFromAmbiLayout(AmbiLayout layout)
+{
+    switch(layout)
     {
-        if((i&7) == 1)
-        {
-            for(size_t c{0};c < numchans;c++)
-            {
-                code[c] = al::to_integer<ALuint>(src[0]) | (al::to_integer<ALuint>(src[1])<< 8) |
-                    (al::to_integer<ALuint>(src[2])<<16) | (al::to_integer<ALuint>(src[3])<<24);
-                src += 4;
-            }
-        }
-
-        for(size_t c{0};c < numchans;c++)
-        {
-            const ALuint nibble{code[c]&0xf};
-            code[c] >>= 4;
-
-            sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
-            sample[c] = clampi(sample[c], -32768, 32767);
-
-            index[c] += IMA4Index_adjust[nibble];
-            index[c] = clampi(index[c], 0, 88);
-
-            *(dst++) = static_cast<ALshort>(sample[c]);
-        }
+    case AmbiLayout::FuMa: return AL_FUMA_SOFT;
+    case AmbiLayout::ACN: return AL_ACN_SOFT;
     }
+    throw std::runtime_error{"Invalid AmbiLayout: "+std::to_string(int(layout))};
 }
 
-void DecodeMSADPCMBlock(ALshort *dst, const al::byte *src, size_t numchans, size_t align)
+al::optional<AmbiScaling> AmbiScalingFromEnum(ALenum scale)
 {
-    ALubyte blockpred[MAX_INPUT_CHANNELS]{};
-    ALint delta[MAX_INPUT_CHANNELS]{};
-    ALshort samples[MAX_INPUT_CHANNELS][2]{};
-
-    for(size_t c{0};c < numchans;c++)
+    switch(scale)
     {
-        blockpred[c] = std::min<ALubyte>(al::to_integer<ALubyte>(src[0]), 6);
-        ++src;
+    case AL_FUMA_SOFT: return AmbiScaling::FuMa;
+    case AL_SN3D_SOFT: return AmbiScaling::SN3D;
+    case AL_N3D_SOFT: return AmbiScaling::N3D;
     }
-    for(size_t c{0};c < numchans;c++)
-    {
-        delta[c] = al::to_integer<int>(src[0]) | (al::to_integer<int>(src[1])<<8);
-        delta[c] = (delta[c]^0x8000) - 32768;
-        src += 2;
-    }
-    for(size_t c{0};c < numchans;c++)
-    {
-        samples[c][0] = static_cast<ALshort>(al::to_integer<int>(src[0]) |
-            (al::to_integer<int>(src[1])<<8));
-        src += 2;
-    }
-    for(size_t c{0};c < numchans;c++)
+    return al::nullopt;
+}
+ALenum EnumFromAmbiScaling(AmbiScaling scale)
+{
+    switch(scale)
     {
-        samples[c][1] = static_cast<ALshort>(al::to_integer<int>(src[0]) |
-            (al::to_integer<int>(src[1])<<8));
-        src += 2;
-    }
-
-    /* Second sample is written first. */
-    for(size_t c{0};c < numchans;c++)
-        *(dst++) = samples[c][1];
-    for(size_t c{0};c < numchans;c++)
-        *(dst++) = samples[c][0];
-
-    int num{0};
-    for(size_t i{2};i < align;i++)
-    {
-        for(size_t c{0};c < numchans;c++)
-        {
-            /* Read the nibble (first is in the upper bits). */
-            al::byte nibble;
-            if(!(num++ & 1))
-                nibble = *src >> 4;
-            else
-                nibble = *(src++) & 0x0f;
-
-            ALint pred{(samples[c][0]*MSADPCMAdaptionCoeff[blockpred[c]][0] +
-                samples[c][1]*MSADPCMAdaptionCoeff[blockpred[c]][1]) / 256};
-            pred += (al::to_integer<int>(nibble^0x08) - 0x08) * delta[c];
-            pred  = clampi(pred, -32768, 32767);
-
-            samples[c][1] = samples[c][0];
-            samples[c][0] = static_cast<ALshort>(pred);
-
-            delta[c] = (MSADPCMAdaption[al::to_integer<ALubyte>(nibble)] * delta[c]) / 256;
-            delta[c] = maxi(16, delta[c]);
-
-            *(dst++) = static_cast<ALshort>(pred);
-        }
+    case AmbiScaling::FuMa: return AL_FUMA_SOFT;
+    case AmbiScaling::SN3D: return AL_SN3D_SOFT;
+    case AmbiScaling::N3D: return AL_N3D_SOFT;
+    case AmbiScaling::UHJ: break;
     }
+    throw std::runtime_error{"Invalid AmbiScaling: "+std::to_string(int(scale))};
 }
 
-void Convert_ALshort_ALima4(ALshort *dst, const al::byte *src, size_t numchans, size_t len,
-    size_t align)
+#ifdef ALSOFT_EAX
+al::optional<EaxStorage> EaxStorageFromEnum(ALenum scale)
 {
-    const size_t byte_align{((align-1)/2 + 4) * numchans};
-
-    len /= align;
-    while(len--)
+    switch(scale)
     {
-        DecodeIMA4Block(dst, src, numchans, align);
-        src += byte_align;
-        dst += align*numchans;
+    case AL_STORAGE_AUTOMATIC: return EaxStorage::Automatic;
+    case AL_STORAGE_ACCESSIBLE: return EaxStorage::Accessible;
+    case AL_STORAGE_HARDWARE: return EaxStorage::Hardware;
     }
+    return al::nullopt;
 }
-
-void Convert_ALshort_ALmsadpcm(ALshort *dst, const al::byte *src, size_t numchans, size_t len,
-    size_t align)
+ALenum EnumFromEaxStorage(EaxStorage storage)
 {
-    const size_t byte_align{((align-2)/2 + 7) * numchans};
-
-    len /= align;
-    while(len--)
+    switch(storage)
     {
-        DecodeMSADPCMBlock(dst, src, numchans, align);
-        src += byte_align;
-        dst += align*numchans;
+    case EaxStorage::Automatic: return AL_STORAGE_AUTOMATIC;
+    case EaxStorage::Accessible: return AL_STORAGE_ACCESSIBLE;
+    case EaxStorage::Hardware: return AL_STORAGE_HARDWARE;
     }
+    throw std::runtime_error{"Invalid EaxStorage: "+std::to_string(int(storage))};
 }
 
 
-ALuint BytesFromUserFmt(UserFmtType type)
+bool eax_x_ram_check_availability(const ALCdevice &device, const ALbuffer &buffer,
+    const ALuint newsize) noexcept
 {
-    switch(type)
-    {
-    case UserFmtUByte: return sizeof(ALubyte);
-    case UserFmtShort: return sizeof(ALshort);
-    case UserFmtFloat: return sizeof(ALfloat);
-    case UserFmtDouble: return sizeof(ALdouble);
-    case UserFmtMulaw: return sizeof(ALubyte);
-    case UserFmtAlaw: return sizeof(ALubyte);
-    case UserFmtIMA4: break; /* not handled here */
-    case UserFmtMSADPCM: break; /* not handled here */
-    }
-    return 0;
+    ALuint freemem{device.eax_x_ram_free_size};
+    /* If the buffer is currently in "hardware", add its memory to the free
+     * pool since it'll be "replaced".
+     */
+    if(buffer.eax_x_ram_is_hardware)
+        freemem += buffer.OriginalSize;
+    return freemem >= newsize;
 }
-ALuint ChannelsFromUserFmt(UserFmtChannels chans)
+
+void eax_x_ram_apply(ALCdevice &device, ALbuffer &buffer) noexcept
 {
-    switch(chans)
+    if(buffer.eax_x_ram_is_hardware)
+        return;
+
+    if(device.eax_x_ram_free_size >= buffer.OriginalSize)
     {
-    case UserFmtMono: return 1;
-    case UserFmtStereo: return 2;
-    case UserFmtRear: return 2;
-    case UserFmtQuad: return 4;
-    case UserFmtX51: return 6;
-    case UserFmtX61: return 7;
-    case UserFmtX71: return 8;
-    case UserFmtBFormat2D: return 3;
-    case UserFmtBFormat3D: return 4;
+        device.eax_x_ram_free_size -= buffer.OriginalSize;
+        buffer.eax_x_ram_is_hardware = true;
     }
-    return 0;
 }
-inline ALuint FrameSizeFromUserFmt(UserFmtChannels chans, UserFmtType type)
-{ return ChannelsFromUserFmt(chans) * BytesFromUserFmt(type); }
+
+void eax_x_ram_clear(ALCdevice& al_device, ALbuffer& al_buffer)
+{
+    if(al_buffer.eax_x_ram_is_hardware)
+        al_device.eax_x_ram_free_size += al_buffer.OriginalSize;
+    al_buffer.eax_x_ram_is_hardware = false;
+}
+#endif // ALSOFT_EAX
 
 
 constexpr ALbitfieldSOFT INVALID_STORAGE_MASK{~unsigned(AL_MAP_READ_BIT_SOFT |
@@ -284,19 +172,18 @@ bool EnsureBuffers(ALCdevice *device, size_t needed)
 {
     size_t count{std::accumulate(device->BufferList.cbegin(), device->BufferList.cend(), size_t{0},
         [](size_t cur, const BufferSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(sublist.FreeMask)); }
-    )};
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 
     while(needed > count)
     {
-        if UNLIKELY(device->BufferList.size() >= 1<<25)
+        if(device->BufferList.size() >= 1<<25) UNLIKELY
             return false;
 
         device->BufferList.emplace_back();
         auto sublist = device->BufferList.end() - 1;
         sublist->FreeMask = ~0_u64;
         sublist->Buffers = static_cast<ALbuffer*>(al_calloc(alignof(ALbuffer), sizeof(ALbuffer)*64));
-        if UNLIKELY(!sublist->Buffers)
+        if(!sublist->Buffers) UNLIKELY
         {
             device->BufferList.pop_back();
             return false;
@@ -310,13 +197,12 @@ ALbuffer *AllocBuffer(ALCdevice *device)
 {
     auto sublist = std::find_if(device->BufferList.begin(), device->BufferList.end(),
         [](const BufferSubList &entry) noexcept -> bool
-        { return entry.FreeMask != 0; }
-    );
-
+        { return entry.FreeMask != 0; });
     auto lidx = static_cast<ALuint>(std::distance(device->BufferList.begin(), sublist));
-    auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+    ASSUME(slidx < 64);
 
-    ALbuffer *buffer{::new (sublist->Buffers + slidx) ALbuffer{}};
+    ALbuffer *buffer{al::construct_at(sublist->Buffers + slidx)};
 
     /* Add 1 to avoid buffer ID 0. */
     buffer->id = ((lidx<<6) | slidx) + 1;
@@ -328,6 +214,10 @@ ALbuffer *AllocBuffer(ALCdevice *device)
 
 void FreeBuffer(ALCdevice *device, ALbuffer *buffer)
 {
+#ifdef ALSOFT_EAX
+    eax_x_ram_clear(*device, *buffer);
+#endif // ALSOFT_EAX
+
     const ALuint id{buffer->id - 1};
     const size_t lidx{id >> 6};
     const ALuint slidx{id & 0x3f};
@@ -342,20 +232,20 @@ inline ALbuffer *LookupBuffer(ALCdevice *device, ALuint id)
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= device->BufferList.size())
+    if(lidx >= device->BufferList.size()) UNLIKELY
         return nullptr;
     BufferSubList &sublist = device->BufferList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Buffers + slidx;
 }
 
 
-ALuint SanitizeAlignment(UserFmtType type, ALuint align)
+ALuint SanitizeAlignment(FmtType type, ALuint align)
 {
     if(align == 0)
     {
-        if(type == UserFmtIMA4)
+        if(type == FmtIMA4)
         {
             /* Here is where things vary:
              * nVidia and Apple use 64+1 sample frames per block -> block_size=36 bytes per channel
@@ -363,18 +253,18 @@ ALuint SanitizeAlignment(UserFmtType type, ALuint align)
              */
             return 65;
         }
-        if(type == UserFmtMSADPCM)
+        if(type == FmtMSADPCM)
             return 64;
         return 1;
     }
 
-    if(type == UserFmtIMA4)
+    if(type == FmtIMA4)
     {
         /* IMA4 block alignment must be a multiple of 8, plus 1. */
         if((align&7) == 1) return static_cast<ALuint>(align);
         return 0;
     }
-    if(type == UserFmtMSADPCM)
+    if(type == FmtMSADPCM)
     {
         /* MSADPCM block alignment must be a multiple of 2. */
         if((align&1) == 0) return static_cast<ALuint>(align);
@@ -385,234 +275,350 @@ ALuint SanitizeAlignment(UserFmtType type, ALuint align)
 }
 
 
-const ALchar *NameFromUserFmtType(UserFmtType type)
-{
-    switch(type)
-    {
-    case UserFmtUByte: return "Unsigned Byte";
-    case UserFmtShort: return "Signed Short";
-    case UserFmtFloat: return "Float32";
-    case UserFmtDouble: return "Float64";
-    case UserFmtMulaw: return "muLaw";
-    case UserFmtAlaw: return "aLaw";
-    case UserFmtIMA4: return "IMA4 ADPCM";
-    case UserFmtMSADPCM: return "MSADPCM";
-    }
-    return "<internal type error>";
-}
-
 /** Loads the specified data into the buffer, using the specified format. */
 void LoadData(ALCcontext *context, ALbuffer *ALBuf, ALsizei freq, ALuint size,
-    UserFmtChannels SrcChannels, UserFmtType SrcType, const al::byte *SrcData,
+    const FmtChannels DstChannels, const FmtType DstType, const al::byte *SrcData,
     ALbitfieldSOFT access)
 {
-    if UNLIKELY(ReadRef(ALBuf->ref) != 0 || ALBuf->MappedAccess != 0)
-        SETERR_RETURN(context, AL_INVALID_OPERATION,, "Modifying storage for in-use buffer %u",
-                      ALBuf->id);
-
-    /* Currently no channel configurations need to be converted. */
-    FmtChannels DstChannels{FmtMono};
-    switch(SrcChannels)
-    {
-    case UserFmtMono: DstChannels = FmtMono; break;
-    case UserFmtStereo: DstChannels = FmtStereo; break;
-    case UserFmtRear: DstChannels = FmtRear; break;
-    case UserFmtQuad: DstChannels = FmtQuad; break;
-    case UserFmtX51: DstChannels = FmtX51; break;
-    case UserFmtX61: DstChannels = FmtX61; break;
-    case UserFmtX71: DstChannels = FmtX71; break;
-    case UserFmtBFormat2D: DstChannels = FmtBFormat2D; break;
-    case UserFmtBFormat3D: DstChannels = FmtBFormat3D; break;
-    }
-    if UNLIKELY(static_cast<long>(SrcChannels) != static_cast<long>(DstChannels))
-        SETERR_RETURN(context, AL_INVALID_ENUM, , "Invalid format");
-
-    /* IMA4 and MSADPCM convert to 16-bit short. */
-    FmtType DstType{FmtUByte};
-    switch(SrcType)
-    {
-    case UserFmtUByte: DstType = FmtUByte; break;
-    case UserFmtShort: DstType = FmtShort; break;
-    case UserFmtFloat: DstType = FmtFloat; break;
-    case UserFmtDouble: DstType = FmtDouble; break;
-    case UserFmtAlaw: DstType = FmtAlaw; break;
-    case UserFmtMulaw: DstType = FmtMulaw; break;
-    case UserFmtIMA4: DstType = FmtShort; break;
-    case UserFmtMSADPCM: DstType = FmtShort; break;
-    }
-
-    /* TODO: Currently we can only map samples when they're not converted. To
-     * allow it would need some kind of double-buffering to hold onto a copy of
-     * the original data.
-     */
-    if((access&MAP_READ_WRITE_FLAGS))
-    {
-        if UNLIKELY(static_cast<long>(SrcType) != static_cast<long>(DstType))
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "%s samples cannot be mapped",
-                NameFromUserFmtType(SrcType));
-    }
+    if(ReadRef(ALBuf->ref) != 0 || ALBuf->MappedAccess != 0) UNLIKELY
+        return context->setError(AL_INVALID_OPERATION, "Modifying storage for in-use buffer %u",
+            ALBuf->id);
 
     const ALuint unpackalign{ALBuf->UnpackAlign};
-    const ALuint align{SanitizeAlignment(SrcType, unpackalign)};
-    if UNLIKELY(align < 1)
-        SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid unpack alignment %u for %s samples",
-            unpackalign, NameFromUserFmtType(SrcType));
+    const ALuint align{SanitizeAlignment(DstType, unpackalign)};
+    if(align < 1) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid unpack alignment %u for %s samples",
+            unpackalign, NameFromFormat(DstType));
+
+    const ALuint ambiorder{IsBFormat(DstChannels) ? ALBuf->UnpackAmbiOrder :
+        (IsUHJ(DstChannels) ? 1 : 0)};
 
     if((access&AL_PRESERVE_DATA_BIT_SOFT))
     {
         /* Can only preserve data with the same format and alignment. */
-        if UNLIKELY(ALBuf->mFmtChannels != DstChannels || ALBuf->OriginalType != SrcType)
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Preserving data of mismatched format");
-        if UNLIKELY(ALBuf->OriginalAlign != align)
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Preserving data of mismatched alignment");
+        if(ALBuf->mChannels != DstChannels || ALBuf->mType != DstType) UNLIKELY
+            return context->setError(AL_INVALID_VALUE, "Preserving data of mismatched format");
+        if(ALBuf->mBlockAlign != align) UNLIKELY
+            return context->setError(AL_INVALID_VALUE, "Preserving data of mismatched alignment");
+        if(ALBuf->mAmbiOrder != ambiorder) UNLIKELY
+            return context->setError(AL_INVALID_VALUE, "Preserving data of mismatched order");
     }
 
-    /* Convert the input/source size in bytes to sample frames using the unpack
-     * block alignment.
-     */
-    const ALuint SrcByteAlign{
-        (SrcType == UserFmtIMA4) ? ((align-1)/2 + 4) * ChannelsFromUserFmt(SrcChannels) :
-        (SrcType == UserFmtMSADPCM) ? ((align-2)/2 + 7) * ChannelsFromUserFmt(SrcChannels) :
-        (align * FrameSizeFromUserFmt(SrcChannels, SrcType))
-    };
-    if UNLIKELY((size%SrcByteAlign) != 0)
-        SETERR_RETURN(context, AL_INVALID_VALUE,,
+    /* Convert the size in bytes to blocks using the unpack block alignment. */
+    const ALuint NumChannels{ChannelsFromFmt(DstChannels, ambiorder)};
+    const ALuint BlockSize{NumChannels *
+        ((DstType == FmtIMA4) ? (align-1)/2 + 4 :
+        (DstType == FmtMSADPCM) ? (align-2)/2 + 7 :
+        (align * BytesFromFmt(DstType)))};
+    if((size%BlockSize) != 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
             "Data size %d is not a multiple of frame size %d (%d unpack alignment)",
-            size, SrcByteAlign, align);
+            size, BlockSize, align);
+    const ALuint blocks{size / BlockSize};
 
-    if UNLIKELY(size/SrcByteAlign > std::numeric_limits<ALsizei>::max()/align)
-        SETERR_RETURN(context, AL_OUT_OF_MEMORY,,
-            "Buffer size overflow, %d blocks x %d samples per block", size/SrcByteAlign, align);
-    const ALuint frames{size / SrcByteAlign * align};
+    if(blocks > std::numeric_limits<ALsizei>::max()/align) UNLIKELY
+        return context->setError(AL_OUT_OF_MEMORY,
+            "Buffer size overflow, %d blocks x %d samples per block", blocks, align);
+    if(blocks > std::numeric_limits<size_t>::max()/BlockSize) UNLIKELY
+        return context->setError(AL_OUT_OF_MEMORY,
+            "Buffer size overflow, %d frames x %d bytes per frame", blocks, BlockSize);
 
-    /* Convert the sample frames to the number of bytes needed for internal
-     * storage.
-     */
-    ALuint NumChannels{ChannelsFromFmt(DstChannels)};
-    ALuint FrameSize{NumChannels * BytesFromFmt(DstType)};
-    if UNLIKELY(frames > std::numeric_limits<size_t>::max()/FrameSize)
-        SETERR_RETURN(context, AL_OUT_OF_MEMORY,,
-            "Buffer size overflow, %d frames x %d bytes per frame", frames, FrameSize);
-    size_t newsize{static_cast<size_t>(frames) * FrameSize};
-
-    /* Round up to the next 16-byte multiple. This could reallocate only when
-     * increasing or the new size is less than half the current, but then the
-     * buffer's AL_SIZE would not be very reliable for accounting buffer memory
-     * usage, and reporting the real size could cause problems for apps that
-     * use AL_SIZE to try to get the buffer's play length.
+    const size_t newsize{static_cast<size_t>(blocks) * BlockSize};
+
+#ifdef ALSOFT_EAX
+    if(ALBuf->eax_x_ram_mode == EaxStorage::Hardware)
+    {
+        ALCdevice &device = *context->mALDevice;
+        if(!eax_x_ram_check_availability(device, *ALBuf, size))
+            return context->setError(AL_OUT_OF_MEMORY,
+                "Out of X-RAM memory (avail: %u, needed: %u)", device.eax_x_ram_free_size, size);
+    }
+#endif
+
+    /* This could reallocate only when increasing the size or the new size is
+     * less than half the current, but then the buffer's AL_SIZE would not be
+     * very reliable for accounting buffer memory usage, and reporting the real
+     * size could cause problems for apps that use AL_SIZE to try to get the
+     * buffer's play length.
      */
-    newsize = RoundUp(newsize, 16);
-    if(newsize != ALBuf->mData.size())
+    if(newsize != ALBuf->mDataStorage.size())
     {
         auto newdata = al::vector<al::byte,16>(newsize, al::byte{});
         if((access&AL_PRESERVE_DATA_BIT_SOFT))
         {
-            const size_t tocopy{minz(newdata.size(), ALBuf->mData.size())};
-            std::copy_n(ALBuf->mData.begin(), tocopy, newdata.begin());
+            const size_t tocopy{minz(newdata.size(), ALBuf->mDataStorage.size())};
+            std::copy_n(ALBuf->mDataStorage.begin(), tocopy, newdata.begin());
         }
-        ALBuf->mData = std::move(newdata);
+        newdata.swap(ALBuf->mDataStorage);
     }
+    ALBuf->mData = ALBuf->mDataStorage;
+#ifdef ALSOFT_EAX
+    eax_x_ram_clear(*context->mALDevice, *ALBuf);
+#endif
 
-    if(SrcType == UserFmtIMA4)
-    {
-        assert(DstType == FmtShort);
-        if(SrcData != nullptr && !ALBuf->mData.empty())
-            Convert_ALshort_ALima4(reinterpret_cast<ALshort*>(ALBuf->mData.data()),
-                SrcData, NumChannels, frames, align);
-        ALBuf->OriginalAlign = align;
-    }
-    else if(SrcType == UserFmtMSADPCM)
+    if(SrcData != nullptr && !ALBuf->mData.empty())
+        std::copy_n(SrcData, blocks*BlockSize, ALBuf->mData.begin());
+    ALBuf->mBlockAlign = (DstType == FmtIMA4 || DstType == FmtMSADPCM) ? align : 1;
+
+    ALBuf->OriginalSize = size;
+
+    ALBuf->Access = access;
+
+    ALBuf->mSampleRate = static_cast<ALuint>(freq);
+    ALBuf->mChannels = DstChannels;
+    ALBuf->mType = DstType;
+    ALBuf->mAmbiOrder = ambiorder;
+
+    ALBuf->mCallback = nullptr;
+    ALBuf->mUserData = nullptr;
+
+    ALBuf->mSampleLen = blocks * align;
+    ALBuf->mLoopStart = 0;
+    ALBuf->mLoopEnd = ALBuf->mSampleLen;
+
+#ifdef ALSOFT_EAX
+    if(eax_g_is_enabled && ALBuf->eax_x_ram_mode == EaxStorage::Hardware)
+        eax_x_ram_apply(*context->mALDevice, *ALBuf);
+#endif
+}
+
+/** Prepares the buffer to use the specified callback, using the specified format. */
+void PrepareCallback(ALCcontext *context, ALbuffer *ALBuf, ALsizei freq,
+    const FmtChannels DstChannels, const FmtType DstType, ALBUFFERCALLBACKTYPESOFT callback,
+    void *userptr)
+{
+    if(ReadRef(ALBuf->ref) != 0 || ALBuf->MappedAccess != 0) UNLIKELY
+        return context->setError(AL_INVALID_OPERATION, "Modifying callback for in-use buffer %u",
+            ALBuf->id);
+
+    const ALuint ambiorder{IsBFormat(DstChannels) ? ALBuf->UnpackAmbiOrder :
+        (IsUHJ(DstChannels) ? 1 : 0)};
+
+    const ALuint unpackalign{ALBuf->UnpackAlign};
+    const ALuint align{SanitizeAlignment(DstType, unpackalign)};
+    const ALuint BlockSize{ChannelsFromFmt(DstChannels, ambiorder) *
+        ((DstType == FmtIMA4) ? (align-1)/2 + 4 :
+        (DstType == FmtMSADPCM) ? (align-2)/2 + 7 :
+        (align * BytesFromFmt(DstType)))};
+
+    /* The maximum number of samples a callback buffer may need to store is a
+     * full mixing line * max pitch * channel count, since it may need to hold
+     * a full line's worth of sample frames before downsampling. An additional
+     * MaxResamplerEdge is needed for "future" samples during resampling (the
+     * voice will hold a history for the past samples).
+     */
+    static constexpr size_t line_size{DeviceBase::MixerLineSize*MaxPitch + MaxResamplerEdge};
+    const size_t line_blocks{(line_size + align-1) / align};
+
+    using BufferVectorType = decltype(ALBuf->mDataStorage);
+    BufferVectorType(line_blocks*BlockSize).swap(ALBuf->mDataStorage);
+    ALBuf->mData = ALBuf->mDataStorage;
+
+#ifdef ALSOFT_EAX
+    eax_x_ram_clear(*context->mALDevice, *ALBuf);
+#endif
+
+    ALBuf->mCallback = callback;
+    ALBuf->mUserData = userptr;
+
+    ALBuf->OriginalSize = 0;
+    ALBuf->Access = 0;
+
+    ALBuf->mBlockAlign = (DstType == FmtIMA4 || DstType == FmtMSADPCM) ? align : 1;
+    ALBuf->mSampleRate = static_cast<ALuint>(freq);
+    ALBuf->mChannels = DstChannels;
+    ALBuf->mType = DstType;
+    ALBuf->mAmbiOrder = ambiorder;
+
+    ALBuf->mSampleLen = 0;
+    ALBuf->mLoopStart = 0;
+    ALBuf->mLoopEnd = ALBuf->mSampleLen;
+}
+
+/** Prepares the buffer to use caller-specified storage. */
+void PrepareUserPtr(ALCcontext *context, ALbuffer *ALBuf, ALsizei freq,
+    const FmtChannels DstChannels, const FmtType DstType, al::byte *sdata, const ALuint sdatalen)
+{
+    if(ReadRef(ALBuf->ref) != 0 || ALBuf->MappedAccess != 0) UNLIKELY
+        return context->setError(AL_INVALID_OPERATION, "Modifying storage for in-use buffer %u",
+            ALBuf->id);
+
+    const ALuint unpackalign{ALBuf->UnpackAlign};
+    const ALuint align{SanitizeAlignment(DstType, unpackalign)};
+    if(align < 1) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid unpack alignment %u for %s samples",
+            unpackalign, NameFromFormat(DstType));
+
+    auto get_type_alignment = [](const FmtType type) noexcept -> ALuint
     {
-        assert(DstType == FmtShort);
-        if(SrcData != nullptr && !ALBuf->mData.empty())
-            Convert_ALshort_ALmsadpcm(reinterpret_cast<ALshort*>(ALBuf->mData.data()),
-                SrcData, NumChannels, frames, align);
-        ALBuf->OriginalAlign = align;
-    }
-    else
+        /* NOTE: This only needs to be the required alignment for the CPU to
+         * read/write the given sample type in the mixer.
+         */
+        switch(type)
+        {
+        case FmtUByte: return alignof(ALubyte);
+        case FmtShort: return alignof(ALshort);
+        case FmtFloat: return alignof(ALfloat);
+        case FmtDouble: return alignof(ALdouble);
+        case FmtMulaw: return alignof(ALubyte);
+        case FmtAlaw: return alignof(ALubyte);
+        case FmtIMA4: break;
+        case FmtMSADPCM: break;
+        }
+        return 1;
+    };
+    const auto typealign = get_type_alignment(DstType);
+    if((reinterpret_cast<uintptr_t>(sdata) & (typealign-1)) != 0)
+        return context->setError(AL_INVALID_VALUE, "Pointer %p is misaligned for %s samples (%u)",
+            static_cast<void*>(sdata), NameFromFormat(DstType), typealign);
+
+    const ALuint ambiorder{IsBFormat(DstChannels) ? ALBuf->UnpackAmbiOrder :
+        (IsUHJ(DstChannels) ? 1 : 0)};
+
+    /* Convert the size in bytes to blocks using the unpack block alignment. */
+    const ALuint NumChannels{ChannelsFromFmt(DstChannels, ambiorder)};
+    const ALuint BlockSize{NumChannels *
+        ((DstType == FmtIMA4) ? (align-1)/2 + 4 :
+        (DstType == FmtMSADPCM) ? (align-2)/2 + 7 :
+        (align * BytesFromFmt(DstType)))};
+    if((sdatalen%BlockSize) != 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
+            "Data size %u is not a multiple of frame size %u (%u unpack alignment)",
+            sdatalen, BlockSize, align);
+    const ALuint blocks{sdatalen / BlockSize};
+
+    if(blocks > std::numeric_limits<ALsizei>::max()/align) UNLIKELY
+        return context->setError(AL_OUT_OF_MEMORY,
+            "Buffer size overflow, %d blocks x %d samples per block", blocks, align);
+    if(blocks > std::numeric_limits<size_t>::max()/BlockSize) UNLIKELY
+        return context->setError(AL_OUT_OF_MEMORY,
+            "Buffer size overflow, %d frames x %d bytes per frame", blocks, BlockSize);
+
+#ifdef ALSOFT_EAX
+    if(ALBuf->eax_x_ram_mode == EaxStorage::Hardware)
     {
-        assert(static_cast<long>(SrcType) == static_cast<long>(DstType));
-        if(SrcData != nullptr && !ALBuf->mData.empty())
-            std::copy_n(SrcData, frames*FrameSize, ALBuf->mData.begin());
-        ALBuf->OriginalAlign = 1;
+        ALCdevice &device = *context->mALDevice;
+        if(!eax_x_ram_check_availability(device, *ALBuf, sdatalen))
+            return context->setError(AL_OUT_OF_MEMORY,
+                "Out of X-RAM memory (avail: %u, needed: %u)", device.eax_x_ram_free_size,
+                sdatalen);
     }
-    ALBuf->OriginalSize = size;
-    ALBuf->OriginalType = SrcType;
+#endif
 
-    ALBuf->Frequency = static_cast<ALuint>(freq);
-    ALBuf->mFmtChannels = DstChannels;
-    ALBuf->mFmtType = DstType;
-    ALBuf->Access = access;
+    decltype(ALBuf->mDataStorage){}.swap(ALBuf->mDataStorage);
+    ALBuf->mData = {static_cast<al::byte*>(sdata), sdatalen};
+
+#ifdef ALSOFT_EAX
+    eax_x_ram_clear(*context->mALDevice, *ALBuf);
+#endif
+
+    ALBuf->mCallback = nullptr;
+    ALBuf->mUserData = nullptr;
+
+    ALBuf->OriginalSize = sdatalen;
+    ALBuf->Access = 0;
+
+    ALBuf->mBlockAlign = (DstType == FmtIMA4 || DstType == FmtMSADPCM) ? align : 1;
+    ALBuf->mSampleRate = static_cast<ALuint>(freq);
+    ALBuf->mChannels = DstChannels;
+    ALBuf->mType = DstType;
+    ALBuf->mAmbiOrder = ambiorder;
+
+    ALBuf->mSampleLen = blocks * align;
+    ALBuf->mLoopStart = 0;
+    ALBuf->mLoopEnd = ALBuf->mSampleLen;
 
-    ALBuf->SampleLen = frames;
-    ALBuf->LoopStart = 0;
-    ALBuf->LoopEnd = ALBuf->SampleLen;
+#ifdef ALSOFT_EAX
+    if(ALBuf->eax_x_ram_mode == EaxStorage::Hardware)
+        eax_x_ram_apply(*context->mALDevice, *ALBuf);
+#endif
 }
 
-struct DecompResult { UserFmtChannels channels; UserFmtType type; };
+
+struct DecompResult { FmtChannels channels; FmtType type; };
 al::optional<DecompResult> DecomposeUserFormat(ALenum format)
 {
     struct FormatMap {
         ALenum format;
-        UserFmtChannels channels;
-        UserFmtType type;
+        FmtChannels channels;
+        FmtType type;
     };
-    static const std::array<FormatMap,46> UserFmtList{{
-        { AL_FORMAT_MONO8,             UserFmtMono, UserFmtUByte   },
-        { AL_FORMAT_MONO16,            UserFmtMono, UserFmtShort   },
-        { AL_FORMAT_MONO_FLOAT32,      UserFmtMono, UserFmtFloat   },
-        { AL_FORMAT_MONO_DOUBLE_EXT,   UserFmtMono, UserFmtDouble  },
-        { AL_FORMAT_MONO_IMA4,         UserFmtMono, UserFmtIMA4    },
-        { AL_FORMAT_MONO_MSADPCM_SOFT, UserFmtMono, UserFmtMSADPCM },
-        { AL_FORMAT_MONO_MULAW,        UserFmtMono, UserFmtMulaw   },
-        { AL_FORMAT_MONO_ALAW_EXT,     UserFmtMono, UserFmtAlaw    },
-
-        { AL_FORMAT_STEREO8,             UserFmtStereo, UserFmtUByte   },
-        { AL_FORMAT_STEREO16,            UserFmtStereo, UserFmtShort   },
-        { AL_FORMAT_STEREO_FLOAT32,      UserFmtStereo, UserFmtFloat   },
-        { AL_FORMAT_STEREO_DOUBLE_EXT,   UserFmtStereo, UserFmtDouble  },
-        { AL_FORMAT_STEREO_IMA4,         UserFmtStereo, UserFmtIMA4    },
-        { AL_FORMAT_STEREO_MSADPCM_SOFT, UserFmtStereo, UserFmtMSADPCM },
-        { AL_FORMAT_STEREO_MULAW,        UserFmtStereo, UserFmtMulaw   },
-        { AL_FORMAT_STEREO_ALAW_EXT,     UserFmtStereo, UserFmtAlaw    },
-
-        { AL_FORMAT_REAR8,      UserFmtRear, UserFmtUByte },
-        { AL_FORMAT_REAR16,     UserFmtRear, UserFmtShort },
-        { AL_FORMAT_REAR32,     UserFmtRear, UserFmtFloat },
-        { AL_FORMAT_REAR_MULAW, UserFmtRear, UserFmtMulaw },
-
-        { AL_FORMAT_QUAD8_LOKI,  UserFmtQuad, UserFmtUByte },
-        { AL_FORMAT_QUAD16_LOKI, UserFmtQuad, UserFmtShort },
-
-        { AL_FORMAT_QUAD8,      UserFmtQuad, UserFmtUByte },
-        { AL_FORMAT_QUAD16,     UserFmtQuad, UserFmtShort },
-        { AL_FORMAT_QUAD32,     UserFmtQuad, UserFmtFloat },
-        { AL_FORMAT_QUAD_MULAW, UserFmtQuad, UserFmtMulaw },
-
-        { AL_FORMAT_51CHN8,      UserFmtX51, UserFmtUByte },
-        { AL_FORMAT_51CHN16,     UserFmtX51, UserFmtShort },
-        { AL_FORMAT_51CHN32,     UserFmtX51, UserFmtFloat },
-        { AL_FORMAT_51CHN_MULAW, UserFmtX51, UserFmtMulaw },
-
-        { AL_FORMAT_61CHN8,      UserFmtX61, UserFmtUByte },
-        { AL_FORMAT_61CHN16,     UserFmtX61, UserFmtShort },
-        { AL_FORMAT_61CHN32,     UserFmtX61, UserFmtFloat },
-        { AL_FORMAT_61CHN_MULAW, UserFmtX61, UserFmtMulaw },
-
-        { AL_FORMAT_71CHN8,      UserFmtX71, UserFmtUByte },
-        { AL_FORMAT_71CHN16,     UserFmtX71, UserFmtShort },
-        { AL_FORMAT_71CHN32,     UserFmtX71, UserFmtFloat },
-        { AL_FORMAT_71CHN_MULAW, UserFmtX71, UserFmtMulaw },
-
-        { AL_FORMAT_BFORMAT2D_8,       UserFmtBFormat2D, UserFmtUByte },
-        { AL_FORMAT_BFORMAT2D_16,      UserFmtBFormat2D, UserFmtShort },
-        { AL_FORMAT_BFORMAT2D_FLOAT32, UserFmtBFormat2D, UserFmtFloat },
-        { AL_FORMAT_BFORMAT2D_MULAW,   UserFmtBFormat2D, UserFmtMulaw },
-
-        { AL_FORMAT_BFORMAT3D_8,       UserFmtBFormat3D, UserFmtUByte },
-        { AL_FORMAT_BFORMAT3D_16,      UserFmtBFormat3D, UserFmtShort },
-        { AL_FORMAT_BFORMAT3D_FLOAT32, UserFmtBFormat3D, UserFmtFloat },
-        { AL_FORMAT_BFORMAT3D_MULAW,   UserFmtBFormat3D, UserFmtMulaw },
+    static const std::array<FormatMap,63> UserFmtList{{
+        { AL_FORMAT_MONO8,             FmtMono, FmtUByte   },
+        { AL_FORMAT_MONO16,            FmtMono, FmtShort   },
+        { AL_FORMAT_MONO_FLOAT32,      FmtMono, FmtFloat   },
+        { AL_FORMAT_MONO_DOUBLE_EXT,   FmtMono, FmtDouble  },
+        { AL_FORMAT_MONO_IMA4,         FmtMono, FmtIMA4    },
+        { AL_FORMAT_MONO_MSADPCM_SOFT, FmtMono, FmtMSADPCM },
+        { AL_FORMAT_MONO_MULAW,        FmtMono, FmtMulaw   },
+        { AL_FORMAT_MONO_ALAW_EXT,     FmtMono, FmtAlaw    },
+
+        { AL_FORMAT_STEREO8,             FmtStereo, FmtUByte   },
+        { AL_FORMAT_STEREO16,            FmtStereo, FmtShort   },
+        { AL_FORMAT_STEREO_FLOAT32,      FmtStereo, FmtFloat   },
+        { AL_FORMAT_STEREO_DOUBLE_EXT,   FmtStereo, FmtDouble  },
+        { AL_FORMAT_STEREO_IMA4,         FmtStereo, FmtIMA4    },
+        { AL_FORMAT_STEREO_MSADPCM_SOFT, FmtStereo, FmtMSADPCM },
+        { AL_FORMAT_STEREO_MULAW,        FmtStereo, FmtMulaw   },
+        { AL_FORMAT_STEREO_ALAW_EXT,     FmtStereo, FmtAlaw    },
+
+        { AL_FORMAT_REAR8,      FmtRear, FmtUByte },
+        { AL_FORMAT_REAR16,     FmtRear, FmtShort },
+        { AL_FORMAT_REAR32,     FmtRear, FmtFloat },
+        { AL_FORMAT_REAR_MULAW, FmtRear, FmtMulaw },
+
+        { AL_FORMAT_QUAD8_LOKI,  FmtQuad, FmtUByte },
+        { AL_FORMAT_QUAD16_LOKI, FmtQuad, FmtShort },
+
+        { AL_FORMAT_QUAD8,      FmtQuad, FmtUByte },
+        { AL_FORMAT_QUAD16,     FmtQuad, FmtShort },
+        { AL_FORMAT_QUAD32,     FmtQuad, FmtFloat },
+        { AL_FORMAT_QUAD_MULAW, FmtQuad, FmtMulaw },
+
+        { AL_FORMAT_51CHN8,      FmtX51, FmtUByte },
+        { AL_FORMAT_51CHN16,     FmtX51, FmtShort },
+        { AL_FORMAT_51CHN32,     FmtX51, FmtFloat },
+        { AL_FORMAT_51CHN_MULAW, FmtX51, FmtMulaw },
+
+        { AL_FORMAT_61CHN8,      FmtX61, FmtUByte },
+        { AL_FORMAT_61CHN16,     FmtX61, FmtShort },
+        { AL_FORMAT_61CHN32,     FmtX61, FmtFloat },
+        { AL_FORMAT_61CHN_MULAW, FmtX61, FmtMulaw },
+
+        { AL_FORMAT_71CHN8,      FmtX71, FmtUByte },
+        { AL_FORMAT_71CHN16,     FmtX71, FmtShort },
+        { AL_FORMAT_71CHN32,     FmtX71, FmtFloat },
+        { AL_FORMAT_71CHN_MULAW, FmtX71, FmtMulaw },
+
+        { AL_FORMAT_BFORMAT2D_8,       FmtBFormat2D, FmtUByte },
+        { AL_FORMAT_BFORMAT2D_16,      FmtBFormat2D, FmtShort },
+        { AL_FORMAT_BFORMAT2D_FLOAT32, FmtBFormat2D, FmtFloat },
+        { AL_FORMAT_BFORMAT2D_MULAW,   FmtBFormat2D, FmtMulaw },
+
+        { AL_FORMAT_BFORMAT3D_8,       FmtBFormat3D, FmtUByte },
+        { AL_FORMAT_BFORMAT3D_16,      FmtBFormat3D, FmtShort },
+        { AL_FORMAT_BFORMAT3D_FLOAT32, FmtBFormat3D, FmtFloat },
+        { AL_FORMAT_BFORMAT3D_MULAW,   FmtBFormat3D, FmtMulaw },
+
+        { AL_FORMAT_UHJ2CHN8_SOFT,        FmtUHJ2, FmtUByte   },
+        { AL_FORMAT_UHJ2CHN16_SOFT,       FmtUHJ2, FmtShort   },
+        { AL_FORMAT_UHJ2CHN_FLOAT32_SOFT, FmtUHJ2, FmtFloat   },
+        { AL_FORMAT_UHJ2CHN_MULAW_SOFT,   FmtUHJ2, FmtMulaw   },
+        { AL_FORMAT_UHJ2CHN_ALAW_SOFT,    FmtUHJ2, FmtAlaw    },
+        { AL_FORMAT_UHJ2CHN_IMA4_SOFT,    FmtUHJ2, FmtIMA4    },
+        { AL_FORMAT_UHJ2CHN_MSADPCM_SOFT, FmtUHJ2, FmtMSADPCM },
+
+        { AL_FORMAT_UHJ3CHN8_SOFT,        FmtUHJ3, FmtUByte },
+        { AL_FORMAT_UHJ3CHN16_SOFT,       FmtUHJ3, FmtShort },
+        { AL_FORMAT_UHJ3CHN_FLOAT32_SOFT, FmtUHJ3, FmtFloat },
+        { AL_FORMAT_UHJ3CHN_MULAW_SOFT,   FmtUHJ3, FmtMulaw },
+        { AL_FORMAT_UHJ3CHN_ALAW_SOFT,    FmtUHJ3, FmtAlaw  },
+
+        { AL_FORMAT_UHJ4CHN8_SOFT,        FmtUHJ4, FmtUByte },
+        { AL_FORMAT_UHJ4CHN16_SOFT,       FmtUHJ4, FmtShort },
+        { AL_FORMAT_UHJ4CHN_FLOAT32_SOFT, FmtUHJ4, FmtFloat },
+        { AL_FORMAT_UHJ4CHN_MULAW_SOFT,   FmtUHJ4, FmtMulaw },
+        { AL_FORMAT_UHJ4CHN_ALAW_SOFT,    FmtUHJ4, FmtAlaw  },
     }};
 
     for(const auto &fmt : UserFmtList)
@@ -626,17 +632,17 @@ al::optional<DecompResult> DecomposeUserFormat(ALenum format)
 } // namespace
 
 
-AL_API ALvoid AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
+AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Generating %d buffers", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
     if(!EnsureBuffers(device, static_cast<ALuint>(n)))
     {
@@ -644,7 +650,7 @@ START_API_FUNC
         return;
     }
 
-    if LIKELY(n == 1)
+    if(n == 1) LIKELY
     {
         /* Special handling for the easy and normal case. */
         ALbuffer *buffer{AllocBuffer(device)};
@@ -666,17 +672,17 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
+AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Deleting %d buffers", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     /* First try to find any buffers that are invalid or in-use. */
@@ -684,12 +690,12 @@ START_API_FUNC
     {
         if(!bid) return true;
         ALbuffer *ALBuf{LookupBuffer(device, bid)};
-        if UNLIKELY(!ALBuf)
+        if(!ALBuf) UNLIKELY
         {
             context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", bid);
             return false;
         }
-        if UNLIKELY(ReadRef(ALBuf->ref) != 0)
+        if(ReadRef(ALBuf->ref) != 0) UNLIKELY
         {
             context->setError(AL_INVALID_OPERATION, "Deleting in-use buffer %u", bid);
             return false;
@@ -698,7 +704,7 @@ START_API_FUNC
     };
     const ALuint *buffers_end = buffers + n;
     auto invbuf = std::find_if_not(buffers, buffers_end, validate_buffer);
-    if UNLIKELY(invbuf != buffers_end) return;
+    if(invbuf != buffers_end) UNLIKELY return;
 
     /* All good. Delete non-0 buffer IDs. */
     auto delete_buffer = [device](const ALuint bid) -> void
@@ -714,9 +720,9 @@ AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if LIKELY(context)
+    if(context) LIKELY
     {
-        ALCdevice *device{context->mDevice.get()};
+        ALCdevice *device{context->mALDevice.get()};
         std::lock_guard<std::mutex> _{device->BufferLock};
         if(!buffer || LookupBuffer(device, buffer))
             return AL_TRUE;
@@ -726,7 +732,7 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq)
+AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq)
 START_API_FUNC
 { alBufferStorageSOFT(buffer, format, data, size, freq, 0); }
 END_API_FUNC
@@ -735,78 +741,108 @@ AL_API void AL_APIENTRY alBufferStorageSOFT(ALuint buffer, ALenum format, const
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(size < 0)
+    else if(size < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Negative storage size %d", size);
-    else if UNLIKELY(freq < 1)
+    else if(freq < 1) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Invalid sample rate %d", freq);
-    else if UNLIKELY((flags&INVALID_STORAGE_MASK) != 0)
+    else if((flags&INVALID_STORAGE_MASK) != 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Invalid storage flags 0x%x",
             flags&INVALID_STORAGE_MASK);
-    else if UNLIKELY((flags&AL_MAP_PERSISTENT_BIT_SOFT) && !(flags&MAP_READ_WRITE_FLAGS))
+    else if((flags&AL_MAP_PERSISTENT_BIT_SOFT) && !(flags&MAP_READ_WRITE_FLAGS)) UNLIKELY
         context->setError(AL_INVALID_VALUE,
             "Declaring persistently mapped storage without read or write access");
     else
     {
         auto usrfmt = DecomposeUserFormat(format);
-        if UNLIKELY(!usrfmt)
+        if(!usrfmt) UNLIKELY
             context->setError(AL_INVALID_ENUM, "Invalid format 0x%04x", format);
         else
+        {
             LoadData(context.get(), albuf, freq, static_cast<ALuint>(size), usrfmt->channels,
                 usrfmt->type, static_cast<const al::byte*>(data), flags);
+        }
     }
 }
 END_API_FUNC
 
+void AL_APIENTRY alBufferDataStatic(const ALuint buffer, ALenum format, ALvoid *data, ALsizei size,
+    ALsizei freq)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->BufferLock};
+
+    ALbuffer *albuf = LookupBuffer(device, buffer);
+    if(!albuf) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
+    if(size < 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Negative storage size %d", size);
+    if(freq < 1) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid sample rate %d", freq);
+
+    auto usrfmt = DecomposeUserFormat(format);
+    if(!usrfmt) UNLIKELY
+        return context->setError(AL_INVALID_ENUM, "Invalid format 0x%04x", format);
+
+    PrepareUserPtr(context.get(), albuf, freq, usrfmt->channels, usrfmt->type,
+        static_cast<al::byte*>(data), static_cast<ALuint>(size));
+}
+END_API_FUNC
+
 AL_API void* AL_APIENTRY alMapBufferSOFT(ALuint buffer, ALsizei offset, ALsizei length, ALbitfieldSOFT access)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return nullptr;
+    if(!context) UNLIKELY return nullptr;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY((access&INVALID_MAP_FLAGS) != 0)
+    else if((access&INVALID_MAP_FLAGS) != 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Invalid map flags 0x%x", access&INVALID_MAP_FLAGS);
-    else if UNLIKELY(!(access&MAP_READ_WRITE_FLAGS))
+    else if(!(access&MAP_READ_WRITE_FLAGS)) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Mapping buffer %u without read or write access",
             buffer);
     else
     {
         ALbitfieldSOFT unavailable = (albuf->Access^access) & access;
-        if UNLIKELY(ReadRef(albuf->ref) != 0 && !(access&AL_MAP_PERSISTENT_BIT_SOFT))
+        if(ReadRef(albuf->ref) != 0 && !(access&AL_MAP_PERSISTENT_BIT_SOFT)) UNLIKELY
             context->setError(AL_INVALID_OPERATION,
                 "Mapping in-use buffer %u without persistent mapping", buffer);
-        else if UNLIKELY(albuf->MappedAccess != 0)
+        else if(albuf->MappedAccess != 0) UNLIKELY
             context->setError(AL_INVALID_OPERATION, "Mapping already-mapped buffer %u", buffer);
-        else if UNLIKELY((unavailable&AL_MAP_READ_BIT_SOFT))
+        else if((unavailable&AL_MAP_READ_BIT_SOFT)) UNLIKELY
             context->setError(AL_INVALID_VALUE,
                 "Mapping buffer %u for reading without read access", buffer);
-        else if UNLIKELY((unavailable&AL_MAP_WRITE_BIT_SOFT))
+        else if((unavailable&AL_MAP_WRITE_BIT_SOFT)) UNLIKELY
             context->setError(AL_INVALID_VALUE,
                 "Mapping buffer %u for writing without write access", buffer);
-        else if UNLIKELY((unavailable&AL_MAP_PERSISTENT_BIT_SOFT))
+        else if((unavailable&AL_MAP_PERSISTENT_BIT_SOFT)) UNLIKELY
             context->setError(AL_INVALID_VALUE,
                 "Mapping buffer %u persistently without persistent access", buffer);
-        else if UNLIKELY(offset < 0 || length <= 0
+        else if(offset < 0 || length <= 0
             || static_cast<ALuint>(offset) >= albuf->OriginalSize
             || static_cast<ALuint>(length) > albuf->OriginalSize - static_cast<ALuint>(offset))
+            UNLIKELY
             context->setError(AL_INVALID_VALUE, "Mapping invalid range %d+%d for buffer %u",
                 offset, length, buffer);
         else
         {
-            void *retval = albuf->mData.data() + offset;
+            void *retval{albuf->mData.data() + offset};
             albuf->MappedAccess = access;
             albuf->MappedOffset = offset;
             albuf->MappedSize = length;
@@ -822,15 +858,15 @@ AL_API void AL_APIENTRY alUnmapBufferSOFT(ALuint buffer)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(albuf->MappedAccess == 0)
+    else if(albuf->MappedAccess == 0) UNLIKELY
         context->setError(AL_INVALID_OPERATION, "Unmapping unmapped buffer %u", buffer);
     else
     {
@@ -845,20 +881,20 @@ AL_API void AL_APIENTRY alFlushMappedBufferSOFT(ALuint buffer, ALsizei offset, A
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!(albuf->MappedAccess&AL_MAP_WRITE_BIT_SOFT))
+    else if(!(albuf->MappedAccess&AL_MAP_WRITE_BIT_SOFT)) UNLIKELY
         context->setError(AL_INVALID_OPERATION, "Flushing buffer %u while not mapped for writing",
             buffer);
-    else if UNLIKELY(offset < albuf->MappedOffset || length <= 0
+    else if(offset < albuf->MappedOffset || length <= 0
         || offset >= albuf->MappedOffset+albuf->MappedSize
-        || length > albuf->MappedOffset+albuf->MappedSize-offset)
+        || length > albuf->MappedOffset+albuf->MappedSize-offset) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Flushing invalid range %d+%d on buffer %u", offset,
             length, buffer);
     else
@@ -873,84 +909,62 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length)
+AL_API void AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
-    {
-        context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-        return;
-    }
+    if(!albuf) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
 
     auto usrfmt = DecomposeUserFormat(format);
-    if UNLIKELY(!usrfmt)
-    {
-        context->setError(AL_INVALID_ENUM, "Invalid format 0x%04x", format);
-        return;
-    }
-
-    ALuint unpack_align{albuf->UnpackAlign};
-    ALuint align{SanitizeAlignment(usrfmt->type, unpack_align)};
-    if UNLIKELY(align < 1)
-        context->setError(AL_INVALID_VALUE, "Invalid unpack alignment %u", unpack_align);
-    else if UNLIKELY(long{usrfmt->channels} != long{albuf->mFmtChannels}
-        || usrfmt->type != albuf->OriginalType)
-        context->setError(AL_INVALID_ENUM, "Unpacking data with mismatched format");
-    else if UNLIKELY(align != albuf->OriginalAlign)
-        context->setError(AL_INVALID_VALUE,
+    if(!usrfmt) UNLIKELY
+        return context->setError(AL_INVALID_ENUM, "Invalid format 0x%04x", format);
+
+    const ALuint unpack_align{albuf->UnpackAlign};
+    const ALuint align{SanitizeAlignment(usrfmt->type, unpack_align)};
+    if(align < 1) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid unpack alignment %u", unpack_align);
+    if(usrfmt->channels != albuf->mChannels || usrfmt->type != albuf->mType) UNLIKELY
+        return context->setError(AL_INVALID_ENUM, "Unpacking data with mismatched format");
+    if(align != albuf->mBlockAlign) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
             "Unpacking data with alignment %u does not match original alignment %u", align,
-            albuf->OriginalAlign);
-    else if UNLIKELY(albuf->MappedAccess != 0)
-        context->setError(AL_INVALID_OPERATION, "Unpacking data into mapped buffer %u", buffer);
-    else
-    {
-        ALuint num_chans{ChannelsFromFmt(albuf->mFmtChannels)};
-        ALuint frame_size{num_chans * BytesFromFmt(albuf->mFmtType)};
-        ALuint byte_align{
-            (albuf->OriginalType == UserFmtIMA4) ? ((align-1)/2 + 4) * num_chans :
-            (albuf->OriginalType == UserFmtMSADPCM) ? ((align-2)/2 + 7) * num_chans :
-            (align * frame_size)
-        };
-
-        if UNLIKELY(offset < 0 || length < 0 || static_cast<ALuint>(offset) > albuf->OriginalSize
-            || static_cast<ALuint>(length) > albuf->OriginalSize-static_cast<ALuint>(offset))
-            context->setError(AL_INVALID_VALUE, "Invalid data sub-range %d+%d on buffer %u",
-                offset, length, buffer);
-        else if UNLIKELY((static_cast<ALuint>(offset)%byte_align) != 0)
-            context->setError(AL_INVALID_VALUE,
-                "Sub-range offset %d is not a multiple of frame size %d (%d unpack alignment)",
-                offset, byte_align, align);
-        else if UNLIKELY((static_cast<ALuint>(length)%byte_align) != 0)
-            context->setError(AL_INVALID_VALUE,
-                "Sub-range length %d is not a multiple of frame size %d (%d unpack alignment)",
-                length, byte_align, align);
-        else
-        {
-            /* offset -> byte offset, length -> sample count */
-            size_t byteoff{static_cast<ALuint>(offset)/byte_align * align * frame_size};
-            size_t samplen{static_cast<ALuint>(length)/byte_align * align};
-
-            void *dst = albuf->mData.data() + byteoff;
-            if(usrfmt->type == UserFmtIMA4 && albuf->mFmtType == FmtShort)
-                Convert_ALshort_ALima4(static_cast<ALshort*>(dst),
-                    static_cast<const al::byte*>(data), num_chans, samplen, align);
-            else if(usrfmt->type == UserFmtMSADPCM && albuf->mFmtType == FmtShort)
-                Convert_ALshort_ALmsadpcm(static_cast<ALshort*>(dst),
-                    static_cast<const al::byte*>(data), num_chans, samplen, align);
-            else
-            {
-                assert(long{usrfmt->type} == long{albuf->mFmtType});
-                memcpy(dst, data, size_t{samplen} * frame_size);
-            }
-        }
-    }
+            albuf->mBlockAlign);
+    if(albuf->isBFormat() && albuf->UnpackAmbiOrder != albuf->mAmbiOrder) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
+            "Unpacking data with mismatched ambisonic order");
+    if(albuf->MappedAccess != 0) UNLIKELY
+        return context->setError(AL_INVALID_OPERATION, "Unpacking data into mapped buffer %u",
+            buffer);
+
+    const ALuint num_chans{albuf->channelsFromFmt()};
+    const ALuint byte_align{
+        (albuf->mType == FmtIMA4) ? ((align-1)/2 + 4) * num_chans :
+        (albuf->mType == FmtMSADPCM) ? ((align-2)/2 + 7) * num_chans :
+        (align * albuf->bytesFromFmt() * num_chans)};
+
+    if(offset < 0 || length < 0 || static_cast<ALuint>(offset) > albuf->OriginalSize
+        || static_cast<ALuint>(length) > albuf->OriginalSize-static_cast<ALuint>(offset))
+        UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid data sub-range %d+%d on buffer %u",
+            offset, length, buffer);
+    if((static_cast<ALuint>(offset)%byte_align) != 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
+            "Sub-range offset %d is not a multiple of frame size %d (%d unpack alignment)",
+            offset, byte_align, align);
+    if((static_cast<ALuint>(length)%byte_align) != 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE,
+            "Sub-range length %d is not a multiple of frame size %d (%d unpack alignment)",
+            length, byte_align, align);
+
+    assert(al::to_underlying(usrfmt->type) == al::to_underlying(albuf->mType));
+    memcpy(albuf->mData.data()+offset, data, static_cast<ALuint>(length));
 }
 END_API_FUNC
 
@@ -961,7 +975,7 @@ AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint /*buffer*/, ALuint /*samplera
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     context->setError(AL_INVALID_OPERATION, "alBufferSamplesSOFT not supported");
 }
@@ -972,7 +986,7 @@ AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint /*buffer*/, ALsizei /*offs
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     context->setError(AL_INVALID_OPERATION, "alBufferSubSamplesSOFT not supported");
 }
@@ -983,7 +997,7 @@ AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint /*buffer*/, ALsizei /*offs
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     context->setError(AL_INVALID_OPERATION, "alGetBufferSamplesSOFT not supported");
 }
@@ -993,7 +1007,7 @@ AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum /*format*/)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return AL_FALSE;
+    if(!context) UNLIKELY return AL_FALSE;
 
     context->setError(AL_INVALID_OPERATION, "alIsBufferFormatSupportedSOFT not supported");
     return AL_FALSE;
@@ -1005,12 +1019,12 @@ AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat /*value*/
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
     else switch(param)
     {
@@ -1025,12 +1039,12 @@ AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param,
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
     else switch(param)
     {
@@ -1044,14 +1058,14 @@ AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *v
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!values)
+    else if(!values) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
@@ -1066,30 +1080,57 @@ AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
     else switch(param)
     {
     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
-        if UNLIKELY(value < 0)
+        if(value < 0) UNLIKELY
             context->setError(AL_INVALID_VALUE, "Invalid unpack block alignment %d", value);
         else
             albuf->UnpackAlign = static_cast<ALuint>(value);
         break;
 
     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
-        if UNLIKELY(value < 0)
+        if(value < 0) UNLIKELY
             context->setError(AL_INVALID_VALUE, "Invalid pack block alignment %d", value);
         else
             albuf->PackAlign = static_cast<ALuint>(value);
         break;
 
+    case AL_AMBISONIC_LAYOUT_SOFT:
+        if(ReadRef(albuf->ref) != 0) UNLIKELY
+            context->setError(AL_INVALID_OPERATION, "Modifying in-use buffer %u's ambisonic layout",
+                buffer);
+        else if(const auto layout = AmbiLayoutFromEnum(value))
+            albuf->mAmbiLayout = layout.value();
+        else UNLIKELY
+            context->setError(AL_INVALID_VALUE, "Invalid unpack ambisonic layout %04x", value);
+        break;
+
+    case AL_AMBISONIC_SCALING_SOFT:
+        if(ReadRef(albuf->ref) != 0) UNLIKELY
+            context->setError(AL_INVALID_OPERATION, "Modifying in-use buffer %u's ambisonic scaling",
+                buffer);
+        else if(const auto scaling = AmbiScalingFromEnum(value))
+            albuf->mAmbiScaling = scaling.value();
+        else UNLIKELY
+            context->setError(AL_INVALID_VALUE, "Invalid unpack ambisonic scaling %04x", value);
+        break;
+
+    case AL_UNPACK_AMBISONIC_ORDER_SOFT:
+        if(value < 1 || value > 14) UNLIKELY
+            context->setError(AL_INVALID_VALUE, "Invalid unpack ambisonic order %d", value);
+        else
+            albuf->UnpackAmbiOrder = static_cast<ALuint>(value);
+        break;
+
     default:
         context->setError(AL_INVALID_ENUM, "Invalid buffer integer property 0x%04x", param);
     }
@@ -1101,12 +1142,12 @@ AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param,
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
     else switch(param)
     {
@@ -1125,36 +1166,39 @@ START_API_FUNC
         {
         case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
         case AL_PACK_BLOCK_ALIGNMENT_SOFT:
+        case AL_AMBISONIC_LAYOUT_SOFT:
+        case AL_AMBISONIC_SCALING_SOFT:
+        case AL_UNPACK_AMBISONIC_ORDER_SOFT:
             alBufferi(buffer, param, values[0]);
             return;
         }
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!values)
+    else if(!values) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
     case AL_LOOP_POINTS_SOFT:
-        if UNLIKELY(ReadRef(albuf->ref) != 0)
+        if(ReadRef(albuf->ref) != 0) UNLIKELY
             context->setError(AL_INVALID_OPERATION, "Modifying in-use buffer %u's loop points",
                 buffer);
-        else if UNLIKELY(values[0] < 0 || values[0] >= values[1]
-            || static_cast<ALuint>(values[1]) > albuf->SampleLen)
+        else if(values[0] < 0 || values[0] >= values[1]
+            || static_cast<ALuint>(values[1]) > albuf->mSampleLen) UNLIKELY
             context->setError(AL_INVALID_VALUE, "Invalid loop point range %d -> %d on buffer %u",
                 values[0], values[1], buffer);
         else
         {
-            albuf->LoopStart = static_cast<ALuint>(values[0]);
-            albuf->LoopEnd = static_cast<ALuint>(values[1]);
+            albuf->mLoopStart = static_cast<ALuint>(values[0]);
+            albuf->mLoopEnd = static_cast<ALuint>(values[1]);
         }
         break;
 
@@ -1165,22 +1209,27 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
+    case AL_SEC_LENGTH_SOFT:
+        *value = (albuf->mSampleRate < 1) ? 0.0f :
+            (static_cast<float>(albuf->mSampleLen) / static_cast<float>(albuf->mSampleRate));
+        break;
+
     default:
         context->setError(AL_INVALID_ENUM, "Invalid buffer float property 0x%04x", param);
     }
@@ -1191,14 +1240,14 @@ AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *valu
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!value1 || !value2 || !value3)
+    else if(!value1 || !value2 || !value3) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
@@ -1219,14 +1268,14 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
 
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!values)
+    else if(!values) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
@@ -1237,36 +1286,45 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
     case AL_FREQUENCY:
-        *value = static_cast<ALint>(albuf->Frequency);
+        *value = static_cast<ALint>(albuf->mSampleRate);
         break;
 
     case AL_BITS:
-        *value = static_cast<ALint>(BytesFromFmt(albuf->mFmtType) * 8);
+        *value = (albuf->mType == FmtIMA4 || albuf->mType == FmtMSADPCM) ? 4
+            : static_cast<ALint>(albuf->bytesFromFmt() * 8);
         break;
 
     case AL_CHANNELS:
-        *value = static_cast<ALint>(ChannelsFromFmt(albuf->mFmtChannels));
+        *value = static_cast<ALint>(albuf->channelsFromFmt());
         break;
 
     case AL_SIZE:
-        *value = static_cast<ALint>(albuf->SampleLen *
-            FrameSizeFromFmt(albuf->mFmtChannels, albuf->mFmtType));
+        *value = albuf->mCallback ? 0 : static_cast<ALint>(albuf->mData.size());
+        break;
+
+    case AL_BYTE_LENGTH_SOFT:
+        *value = static_cast<ALint>(albuf->mSampleLen / albuf->mBlockAlign
+            * albuf->blockSizeFromFmt());
+        break;
+
+    case AL_SAMPLE_LENGTH_SOFT:
+        *value = static_cast<ALint>(albuf->mSampleLen);
         break;
 
     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
@@ -1277,6 +1335,18 @@ START_API_FUNC
         *value = static_cast<ALint>(albuf->PackAlign);
         break;
 
+    case AL_AMBISONIC_LAYOUT_SOFT:
+        *value = EnumFromAmbiLayout(albuf->mAmbiLayout);
+        break;
+
+    case AL_AMBISONIC_SCALING_SOFT:
+        *value = EnumFromAmbiScaling(albuf->mAmbiScaling);
+        break;
+
+    case AL_UNPACK_AMBISONIC_ORDER_SOFT:
+        *value = static_cast<int>(albuf->UnpackAmbiOrder);
+        break;
+
     default:
         context->setError(AL_INVALID_ENUM, "Invalid buffer integer property 0x%04x", param);
     }
@@ -1287,13 +1357,13 @@ AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
-    if UNLIKELY(LookupBuffer(device, buffer) == nullptr)
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!value1 || !value2 || !value3)
+    else if(!value1 || !value2 || !value3) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
@@ -1317,25 +1387,28 @@ START_API_FUNC
     case AL_SAMPLE_LENGTH_SOFT:
     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
+    case AL_AMBISONIC_LAYOUT_SOFT:
+    case AL_AMBISONIC_SCALING_SOFT:
+    case AL_UNPACK_AMBISONIC_ORDER_SOFT:
         alGetBufferi(buffer, param, values);
         return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->BufferLock};
     ALbuffer *albuf = LookupBuffer(device, buffer);
-    if UNLIKELY(!albuf)
+    if(!albuf) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
-    else if UNLIKELY(!values)
+    else if(!values) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
     case AL_LOOP_POINTS_SOFT:
-        values[0] = static_cast<ALint>(albuf->LoopStart);
-        values[1] = static_cast<ALint>(albuf->LoopEnd);
+        values[0] = static_cast<ALint>(albuf->mLoopStart);
+        values[1] = static_cast<ALint>(albuf->mLoopEnd);
         break;
 
     default:
@@ -1345,35 +1418,110 @@ START_API_FUNC
 END_API_FUNC
 
 
-ALuint BytesFromFmt(FmtType type)
+AL_API void AL_APIENTRY alBufferCallbackSOFT(ALuint buffer, ALenum format, ALsizei freq,
+    ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->BufferLock};
+
+    ALbuffer *albuf = LookupBuffer(device, buffer);
+    if(!albuf) UNLIKELY
+        context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
+    else if(freq < 1) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "Invalid sample rate %d", freq);
+    else if(callback == nullptr) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "NULL callback");
+    else
+    {
+        auto usrfmt = DecomposeUserFormat(format);
+        if(!usrfmt) UNLIKELY
+            context->setError(AL_INVALID_ENUM, "Invalid format 0x%04x", format);
+        else
+            PrepareCallback(context.get(), albuf, freq, usrfmt->channels, usrfmt->type, callback,
+                userptr);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetBufferPtrSOFT(ALuint buffer, ALenum param, ALvoid **value)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->BufferLock};
+    ALbuffer *albuf = LookupBuffer(device, buffer);
+    if(!albuf) UNLIKELY
+        context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
+    else if(!value) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
+    {
+    case AL_BUFFER_CALLBACK_FUNCTION_SOFT:
+        *value = reinterpret_cast<void*>(albuf->mCallback);
+        break;
+    case AL_BUFFER_CALLBACK_USER_PARAM_SOFT:
+        *value = albuf->mUserData;
+        break;
+
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid buffer pointer property 0x%04x", param);
+    }
+}
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetBuffer3PtrSOFT(ALuint buffer, ALenum param, ALvoid **value1, ALvoid **value2, ALvoid **value3)
+START_API_FUNC
 {
-    switch(type)
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->BufferLock};
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
+        context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
+    else if(!value1 || !value2 || !value3) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
     {
-    case FmtUByte: return sizeof(ALubyte);
-    case FmtShort: return sizeof(ALshort);
-    case FmtFloat: return sizeof(ALfloat);
-    case FmtDouble: return sizeof(ALdouble);
-    case FmtMulaw: return sizeof(ALubyte);
-    case FmtAlaw: return sizeof(ALubyte);
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid buffer 3-pointer property 0x%04x", param);
     }
-    return 0;
 }
-ALuint ChannelsFromFmt(FmtChannels chans)
+END_API_FUNC
+
+AL_API void AL_APIENTRY alGetBufferPtrvSOFT(ALuint buffer, ALenum param, ALvoid **values)
+START_API_FUNC
 {
-    switch(chans)
+    switch(param)
+    {
+    case AL_BUFFER_CALLBACK_FUNCTION_SOFT:
+    case AL_BUFFER_CALLBACK_USER_PARAM_SOFT:
+        alGetBufferPtrSOFT(buffer, param, values);
+        return;
+    }
+
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->BufferLock};
+    if(LookupBuffer(device, buffer) == nullptr) UNLIKELY
+        context->setError(AL_INVALID_NAME, "Invalid buffer ID %u", buffer);
+    else if(!values) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+    else switch(param)
     {
-    case FmtMono: return 1;
-    case FmtStereo: return 2;
-    case FmtRear: return 2;
-    case FmtQuad: return 4;
-    case FmtX51: return 6;
-    case FmtX61: return 7;
-    case FmtX71: return 8;
-    case FmtBFormat2D: return 3;
-    case FmtBFormat3D: return 4;
+    default:
+        context->setError(AL_INVALID_ENUM, "Invalid buffer pointer-vector property 0x%04x", param);
     }
-    return 0;
 }
+END_API_FUNC
 
 
 BufferSubList::~BufferSubList()
@@ -1381,7 +1529,7 @@ BufferSubList::~BufferSubList()
     uint64_t usemask{~FreeMask};
     while(usemask)
     {
-        ALsizei idx{CTZ64(usemask)};
+        const int idx{al::countr_zero(usemask)};
         al::destroy_at(Buffers+idx);
         usemask &= ~(1_u64 << idx);
     }
@@ -1389,3 +1537,156 @@ BufferSubList::~BufferSubList()
     al_free(Buffers);
     Buffers = nullptr;
 }
+
+
+#ifdef ALSOFT_EAX
+FORCE_ALIGN ALboolean AL_APIENTRY EAXSetBufferMode(ALsizei n, const ALuint* buffers, ALint value)
+START_API_FUNC
+{
+#define EAX_PREFIX "[EAXSetBufferMode] "
+
+    const auto context = ContextRef{GetContextRef()};
+    if(!context)
+    {
+        ERR(EAX_PREFIX "%s\n", "No current context.");
+        return ALC_FALSE;
+    }
+
+    if(!eax_g_is_enabled)
+    {
+        context->setError(AL_INVALID_OPERATION, EAX_PREFIX "%s", "EAX not enabled.");
+        return ALC_FALSE;
+    }
+
+    const auto storage = EaxStorageFromEnum(value);
+    if(!storage)
+    {
+        context->setError(AL_INVALID_ENUM, EAX_PREFIX "Unsupported X-RAM mode 0x%x", value);
+        return ALC_FALSE;
+    }
+
+    if(n == 0)
+        return ALC_TRUE;
+
+    if(n < 0)
+    {
+        context->setError(AL_INVALID_VALUE, EAX_PREFIX "Buffer count %d out of range", n);
+        return ALC_FALSE;
+    }
+
+    if(!buffers)
+    {
+        context->setError(AL_INVALID_VALUE, EAX_PREFIX "%s", "Null AL buffers");
+        return ALC_FALSE;
+    }
+
+    auto device = context->mALDevice.get();
+    std::lock_guard<std::mutex> device_lock{device->BufferLock};
+    size_t total_needed{0};
+
+    // Validate the buffers.
+    //
+    for(auto i = 0;i < n;++i)
+    {
+        const auto bufid = buffers[i];
+        if(bufid == AL_NONE)
+            continue;
+
+        const auto buffer = LookupBuffer(device, bufid);
+        if(!buffer) UNLIKELY
+        {
+            ERR(EAX_PREFIX "Invalid buffer ID %u.\n", bufid);
+            return ALC_FALSE;
+        }
+
+        /* TODO: Is the store location allowed to change for in-use buffers, or
+         * only when not set/queued on a source?
+         */
+
+        if(*storage == EaxStorage::Hardware && !buffer->eax_x_ram_is_hardware)
+        {
+            /* FIXME: This doesn't account for duplicate buffers. When the same
+             * buffer ID is specified multiple times in the provided list, it
+             * counts each instance as more memory that needs to fit in X-RAM.
+             */
+            if(std::numeric_limits<size_t>::max()-buffer->OriginalSize < total_needed) UNLIKELY
+            {
+                context->setError(AL_OUT_OF_MEMORY, EAX_PREFIX "Size overflow (%u + %zu)\n",
+                    buffer->OriginalSize, total_needed);
+                return ALC_FALSE;
+            }
+            total_needed += buffer->OriginalSize;
+        }
+    }
+    if(total_needed > device->eax_x_ram_free_size)
+    {
+        context->setError(AL_OUT_OF_MEMORY,EAX_PREFIX "Out of X-RAM memory (need: %zu, avail: %u)",
+            total_needed, device->eax_x_ram_free_size);
+        return ALC_FALSE;
+    }
+
+    // Update the mode.
+    //
+    for(auto i = 0;i < n;++i)
+    {
+        const auto bufid = buffers[i];
+        if(bufid == AL_NONE)
+            continue;
+
+        const auto buffer = LookupBuffer(device, bufid);
+        assert(buffer);
+
+        if(*storage == EaxStorage::Hardware)
+            eax_x_ram_apply(*device, *buffer);
+        else
+            eax_x_ram_clear(*device, *buffer);
+        buffer->eax_x_ram_mode = *storage;
+    }
+
+    return AL_TRUE;
+
+#undef EAX_PREFIX
+}
+END_API_FUNC
+
+FORCE_ALIGN ALenum AL_APIENTRY EAXGetBufferMode(ALuint buffer, ALint* pReserved)
+START_API_FUNC
+{
+#define EAX_PREFIX "[EAXGetBufferMode] "
+
+    const auto context = ContextRef{GetContextRef()};
+    if(!context)
+    {
+        ERR(EAX_PREFIX "%s\n", "No current context.");
+        return AL_NONE;
+    }
+
+    if(!eax_g_is_enabled)
+    {
+        context->setError(AL_INVALID_OPERATION, EAX_PREFIX "%s", "EAX not enabled.");
+        return AL_NONE;
+    }
+
+    if(pReserved)
+    {
+        context->setError(AL_INVALID_VALUE, EAX_PREFIX "%s", "Non-null reserved parameter");
+        return AL_NONE;
+    }
+
+    auto device = context->mALDevice.get();
+    std::lock_guard<std::mutex> device_lock{device->BufferLock};
+
+    const auto al_buffer = LookupBuffer(device, buffer);
+    if(!al_buffer)
+    {
+        context->setError(AL_INVALID_NAME, EAX_PREFIX "Invalid buffer ID %u", buffer);
+        return AL_NONE;
+    }
+
+    return EnumFromEaxStorage(al_buffer->eax_x_ram_mode);
+
+#undef EAX_PREFIX
+}
+END_API_FUNC
+
+#endif // ALSOFT_EAX
diff --git a/al/buffer.h b/al/buffer.h
index d41eec5d..64ebe1f3 100644
--- a/al/buffer.h
+++ b/al/buffer.h
@@ -6,94 +6,53 @@
 #include "AL/al.h"
 
 #include "albyte.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
 #include "atomic.h"
-#include "inprogext.h"
+#include "core/buffer_storage.h"
 #include "vector.h"
 
+#ifdef ALSOFT_EAX
+#include "eax/x_ram.h"
 
-/* User formats */
-enum UserFmtType : unsigned char {
-    UserFmtUByte,
-    UserFmtShort,
-    UserFmtFloat,
-    UserFmtDouble,
-    UserFmtMulaw,
-    UserFmtAlaw,
-    UserFmtIMA4,
-    UserFmtMSADPCM,
+enum class EaxStorage : uint8_t {
+    Automatic,
+    Accessible,
+    Hardware
 };
-enum UserFmtChannels : unsigned char {
-    UserFmtMono,
-    UserFmtStereo,
-    UserFmtRear,
-    UserFmtQuad,
-    UserFmtX51, /* (WFX order) */
-    UserFmtX61, /* (WFX order) */
-    UserFmtX71, /* (WFX order) */
-    UserFmtBFormat2D, /* WXY */
-    UserFmtBFormat3D, /* WXYZ */
-};
-
-
-/* Storable formats */
-enum FmtType : unsigned char {
-    FmtUByte  = UserFmtUByte,
-    FmtShort  = UserFmtShort,
-    FmtFloat  = UserFmtFloat,
-    FmtDouble = UserFmtDouble,
-    FmtMulaw  = UserFmtMulaw,
-    FmtAlaw   = UserFmtAlaw,
-};
-enum FmtChannels : unsigned char {
-    FmtMono   = UserFmtMono,
-    FmtStereo = UserFmtStereo,
-    FmtRear   = UserFmtRear,
-    FmtQuad   = UserFmtQuad,
-    FmtX51    = UserFmtX51,
-    FmtX61    = UserFmtX61,
-    FmtX71    = UserFmtX71,
-    FmtBFormat2D = UserFmtBFormat2D,
-    FmtBFormat3D = UserFmtBFormat3D,
-};
-#define MAX_INPUT_CHANNELS  (8)
-
+#endif // ALSOFT_EAX
 
-ALuint BytesFromFmt(FmtType type);
-ALuint ChannelsFromFmt(FmtChannels chans);
-inline ALuint FrameSizeFromFmt(FmtChannels chans, FmtType type)
-{ return ChannelsFromFmt(chans) * BytesFromFmt(type); }
 
-
-struct ALbuffer {
-    al::vector<al::byte,16> mData;
-
-    ALuint Frequency{0u};
+struct ALbuffer : public BufferStorage {
     ALbitfieldSOFT Access{0u};
-    ALuint SampleLen{0u};
 
-    FmtChannels mFmtChannels{};
-    FmtType     mFmtType{};
+    al::vector<al::byte,16> mDataStorage;
 
-    UserFmtType OriginalType{};
     ALuint OriginalSize{0};
-    ALuint OriginalAlign{0};
-
-    ALuint LoopStart{0u};
-    ALuint LoopEnd{0u};
 
     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()
+
+#ifdef ALSOFT_EAX
+    EaxStorage eax_x_ram_mode{EaxStorage::Automatic};
+    bool eax_x_ram_is_hardware{};
+#endif // ALSOFT_EAX
 };
 
 #endif
diff --git a/al/eax/api.cpp b/al/eax/api.cpp
new file mode 100644
index 00000000..f0809df1
--- /dev/null
+++ b/al/eax/api.cpp
@@ -0,0 +1,1621 @@
+//
+// EAX API.
+//
+// Based on headers `eax[2-5].h` included in Doom 3 source code:
+// https://github.com/id-Software/DOOM-3/tree/master/neo/openal/include
+//
+
+#include "config.h"
+
+#include <algorithm>
+
+#include "api.h"
+
+
+const GUID DSPROPSETID_EAX_ReverbProperties =
+{
+    0x4A4E6FC1,
+    0xC341,
+    0x11D1,
+    {0xB7, 0x3A, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}
+};
+
+const GUID DSPROPSETID_EAXBUFFER_ReverbProperties =
+{
+    0x4A4E6FC0,
+    0xC341,
+    0x11D1,
+    {0xB7, 0x3A, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}
+};
+
+const GUID DSPROPSETID_EAX20_ListenerProperties =
+{
+    0x306A6A8,
+    0xB224,
+    0x11D2,
+    {0x99, 0xE5, 0x00, 0x00, 0xE8, 0xD8, 0xC7, 0x22}
+};
+
+const GUID DSPROPSETID_EAX20_BufferProperties =
+{
+    0x306A6A7,
+    0xB224,
+    0x11D2,
+    {0x99, 0xE5, 0x00, 0x00, 0xE8, 0xD8, 0xC7, 0x22}
+};
+
+const GUID DSPROPSETID_EAX30_ListenerProperties =
+{
+    0xA8FA6882,
+    0xB476,
+    0x11D3,
+    {0xBD, 0xB9, 0x00, 0xC0, 0xF0, 0x2D, 0xDF, 0x87}
+};
+
+const GUID DSPROPSETID_EAX30_BufferProperties =
+{
+    0xA8FA6881,
+    0xB476,
+    0x11D3,
+    {0xBD, 0xB9, 0x00, 0xC0, 0xF0, 0x2D, 0xDF, 0x87}
+};
+
+const GUID EAX_NULL_GUID =
+{
+    0x00000000,
+    0x0000,
+    0x0000,
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+};
+
+const GUID EAX_PrimaryFXSlotID =
+{
+    0xF317866D,
+    0x924C,
+    0x450C,
+    {0x86, 0x1B, 0xE6, 0xDA, 0xA2, 0x5E, 0x7C, 0x20}
+};
+
+const GUID EAXPROPERTYID_EAX40_Context =
+{
+    0x1D4870AD,
+    0xDEF,
+    0x43C0,
+    {0xA4, 0xC, 0x52, 0x36, 0x32, 0x29, 0x63, 0x42}
+};
+
+const GUID EAXPROPERTYID_EAX50_Context =
+{
+    0x57E13437,
+    0xB932,
+    0x4AB2,
+    {0xB8, 0xBD, 0x52, 0x66, 0xC1, 0xA8, 0x87, 0xEE}
+};
+
+const GUID EAXPROPERTYID_EAX40_FXSlot0 =
+{
+    0xC4D79F1E,
+    0xF1AC,
+    0x436B,
+    {0xA8, 0x1D, 0xA7, 0x38, 0xE7, 0x04, 0x54, 0x69}
+};
+
+const GUID EAXPROPERTYID_EAX50_FXSlot0 =
+{
+    0x91F9590F,
+    0xC388,
+    0x407A,
+    {0x84, 0xB0, 0x1B, 0xAE, 0xE, 0xF7, 0x1A, 0xBC}
+};
+
+const GUID EAXPROPERTYID_EAX40_FXSlot1 =
+{
+    0x8C00E96,
+    0x74BE,
+    0x4491,
+    {0x93, 0xAA, 0xE8, 0xAD, 0x35, 0xA4, 0x91, 0x17}
+};
+
+const GUID EAXPROPERTYID_EAX50_FXSlot1 =
+{
+    0x8F5F7ACA,
+    0x9608,
+    0x4965,
+    {0x81, 0x37, 0x82, 0x13, 0xC7, 0xB9, 0xD9, 0xDE}
+};
+
+const GUID EAXPROPERTYID_EAX40_FXSlot2 =
+{
+    0x1D433B88,
+    0xF0F6,
+    0x4637,
+    {0x91, 0x9F, 0x60, 0xE7, 0xE0, 0x6B, 0x5E, 0xDD}
+};
+
+const GUID EAXPROPERTYID_EAX50_FXSlot2 =
+{
+    0x3C0F5252,
+    0x9834,
+    0x46F0,
+    {0xA1, 0xD8, 0x5B, 0x95, 0xC4, 0xA0, 0xA, 0x30}
+};
+
+const GUID EAXPROPERTYID_EAX40_FXSlot3 =
+{
+    0xEFFF08EA,
+    0xC7D8,
+    0x44AB,
+    {0x93, 0xAD, 0x6D, 0xBD, 0x5F, 0x91, 0x00, 0x64}
+};
+
+const GUID EAXPROPERTYID_EAX50_FXSlot3 =
+{
+    0xE2EB0EAA,
+    0xE806,
+    0x45E7,
+    {0x9F, 0x86, 0x06, 0xC1, 0x57, 0x1A, 0x6F, 0xA3}
+};
+
+const GUID EAXPROPERTYID_EAX40_Source =
+{
+    0x1B86B823,
+    0x22DF,
+    0x4EAE,
+    {0x8B, 0x3C, 0x12, 0x78, 0xCE, 0x54, 0x42, 0x27}
+};
+
+const GUID EAXPROPERTYID_EAX50_Source =
+{
+    0x5EDF82F0,
+    0x24A7,
+    0x4F38,
+    {0x8E, 0x64, 0x2F, 0x09, 0xCA, 0x05, 0xDE, 0xE1}
+};
+
+const GUID EAX_REVERB_EFFECT =
+{
+    0xCF95C8F,
+    0xA3CC,
+    0x4849,
+    {0xB0, 0xB6, 0x83, 0x2E, 0xCC, 0x18, 0x22, 0xDF}
+};
+
+const GUID EAX_AGCCOMPRESSOR_EFFECT =
+{
+    0xBFB7A01E,
+    0x7825,
+    0x4039,
+    {0x92, 0x7F, 0x03, 0xAA, 0xBD, 0xA0, 0xC5, 0x60}
+};
+
+const GUID EAX_AUTOWAH_EFFECT =
+{
+    0xEC3130C0,
+    0xAC7A,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_CHORUS_EFFECT =
+{
+    0xDE6D6FE0,
+    0xAC79,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_DISTORTION_EFFECT =
+{
+    0x975A4CE0,
+    0xAC7E,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_ECHO_EFFECT =
+{
+    0xE9F1BC0,
+    0xAC82,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_EQUALIZER_EFFECT =
+{
+    0x65F94CE0,
+    0x9793,
+    0x11D3,
+    {0x93, 0x9D, 0x00, 0xC0, 0xF0, 0x2D, 0xD6, 0xF0}
+};
+
+const GUID EAX_FLANGER_EFFECT =
+{
+    0xA70007C0,
+    0x7D2,
+    0x11D3,
+    {0x9B, 0x1E, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_FREQUENCYSHIFTER_EFFECT =
+{
+    0xDC3E1880,
+    0x9212,
+    0x11D3,
+    {0x93, 0x9D, 0x00, 0xC0, 0xF0, 0x2D, 0xD6, 0xF0}
+};
+
+const GUID EAX_VOCALMORPHER_EFFECT =
+{
+    0xE41CF10C,
+    0x3383,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_PITCHSHIFTER_EFFECT =
+{
+    0xE7905100,
+    0xAFB2,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+const GUID EAX_RINGMODULATOR_EFFECT =
+{
+    0xB89FE60,
+    0xAFB5,
+    0x11D2,
+    {0x88, 0xDD, 0x00, 0xA0, 0x24, 0xD1, 0x3C, 0xE1}
+};
+
+
+const GUID EAX40CONTEXT_DEFAULTPRIMARYFXSLOTID = EAXPROPERTYID_EAX40_FXSlot0;
+const GUID EAX50CONTEXT_DEFAULTPRIMARYFXSLOTID = EAXPROPERTYID_EAX50_FXSlot0;
+
+const EAX40ACTIVEFXSLOTS EAX40SOURCE_DEFAULTACTIVEFXSLOTID = EAX40ACTIVEFXSLOTS
+{{
+    EAX_NULL_GUID,
+    EAXPROPERTYID_EAX40_FXSlot0,
+}};
+
+const EAX50ACTIVEFXSLOTS EAX50SOURCE_3DDEFAULTACTIVEFXSLOTID = EAX50ACTIVEFXSLOTS
+{{
+    EAX_NULL_GUID,
+    EAX_PrimaryFXSlotID,
+    EAX_NULL_GUID,
+    EAX_NULL_GUID,
+}};
+
+
+const EAX50ACTIVEFXSLOTS EAX50SOURCE_2DDEFAULTACTIVEFXSLOTID = EAX50ACTIVEFXSLOTS
+{{
+    EAX_NULL_GUID,
+    EAX_NULL_GUID,
+    EAX_NULL_GUID,
+    EAX_NULL_GUID,
+}};
+
+
+// EAX1 =====================================================================
+
+namespace {
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_GENERIC = {EAX_ENVIRONMENT_GENERIC, 0.5F, 1.493F, 0.5F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_PADDEDCELL = {EAX_ENVIRONMENT_PADDEDCELL, 0.25F, 0.1F, 0.0F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_ROOM = {EAX_ENVIRONMENT_ROOM, 0.417F, 0.4F, 0.666F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_BATHROOM = {EAX_ENVIRONMENT_BATHROOM, 0.653F, 1.499F, 0.166F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_LIVINGROOM = {EAX_ENVIRONMENT_LIVINGROOM, 0.208F, 0.478F, 0.0F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_STONEROOM = {EAX_ENVIRONMENT_STONEROOM, 0.5F, 2.309F, 0.888F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_AUDITORIUM = {EAX_ENVIRONMENT_AUDITORIUM, 0.403F, 4.279F, 0.5F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_CONCERTHALL = {EAX_ENVIRONMENT_CONCERTHALL, 0.5F, 3.961F, 0.5F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_CAVE = {EAX_ENVIRONMENT_CAVE, 0.5F, 2.886F, 1.304F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_ARENA = {EAX_ENVIRONMENT_ARENA, 0.361F, 7.284F, 0.332F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_HANGAR = {EAX_ENVIRONMENT_HANGAR, 0.5F, 10.0F, 0.3F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_CARPETTEDHALLWAY = {EAX_ENVIRONMENT_CARPETEDHALLWAY, 0.153F, 0.259F, 2.0F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_HALLWAY = {EAX_ENVIRONMENT_HALLWAY, 0.361F, 1.493F, 0.0F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_STONECORRIDOR = {EAX_ENVIRONMENT_STONECORRIDOR, 0.444F, 2.697F, 0.638F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_ALLEY = {EAX_ENVIRONMENT_ALLEY, 0.25F, 1.752F, 0.776F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_FOREST = {EAX_ENVIRONMENT_FOREST, 0.111F, 3.145F, 0.472F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_CITY = {EAX_ENVIRONMENT_CITY, 0.111F, 2.767F, 0.224F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_MOUNTAINS = {EAX_ENVIRONMENT_MOUNTAINS, 0.194F, 7.841F, 0.472F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_QUARRY = {EAX_ENVIRONMENT_QUARRY, 1.0F, 1.499F, 0.5F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_PLAIN = {EAX_ENVIRONMENT_PLAIN, 0.097F, 2.767F, 0.224F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_PARKINGLOT = {EAX_ENVIRONMENT_PARKINGLOT, 0.208F, 1.652F, 1.5F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_SEWERPIPE = {EAX_ENVIRONMENT_SEWERPIPE, 0.652F, 2.886F, 0.25F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_UNDERWATER = {EAX_ENVIRONMENT_UNDERWATER, 1.0F, 1.499F, 0.0F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_DRUGGED = {EAX_ENVIRONMENT_DRUGGED, 0.875F, 8.392F, 1.388F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_DIZZY = {EAX_ENVIRONMENT_DIZZY, 0.139F, 17.234F, 0.666F};
+constexpr EAX_REVERBPROPERTIES EAX1REVERB_PRESET_PSYCHOTIC = {EAX_ENVIRONMENT_PSYCHOTIC, 0.486F, 7.563F, 0.806F};
+} // namespace
+
+const Eax1ReverbPresets EAX1REVERB_PRESETS{{
+    EAX1REVERB_PRESET_GENERIC,
+    EAX1REVERB_PRESET_PADDEDCELL,
+    EAX1REVERB_PRESET_ROOM,
+    EAX1REVERB_PRESET_BATHROOM,
+    EAX1REVERB_PRESET_LIVINGROOM,
+    EAX1REVERB_PRESET_STONEROOM,
+    EAX1REVERB_PRESET_AUDITORIUM,
+    EAX1REVERB_PRESET_CONCERTHALL,
+    EAX1REVERB_PRESET_CAVE,
+    EAX1REVERB_PRESET_ARENA,
+    EAX1REVERB_PRESET_HANGAR,
+    EAX1REVERB_PRESET_CARPETTEDHALLWAY,
+    EAX1REVERB_PRESET_HALLWAY,
+    EAX1REVERB_PRESET_STONECORRIDOR,
+    EAX1REVERB_PRESET_ALLEY,
+    EAX1REVERB_PRESET_FOREST,
+    EAX1REVERB_PRESET_CITY,
+    EAX1REVERB_PRESET_MOUNTAINS,
+    EAX1REVERB_PRESET_QUARRY,
+    EAX1REVERB_PRESET_PLAIN,
+    EAX1REVERB_PRESET_PARKINGLOT,
+    EAX1REVERB_PRESET_SEWERPIPE,
+    EAX1REVERB_PRESET_UNDERWATER,
+    EAX1REVERB_PRESET_DRUGGED,
+    EAX1REVERB_PRESET_DIZZY,
+    EAX1REVERB_PRESET_PSYCHOTIC,
+}};
+
+// EAX2 =====================================================================
+
+namespace {
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_GENERIC{
+    EAX2LISTENER_DEFAULTROOM,
+    EAX2LISTENER_DEFAULTROOMHF,
+    EAX2LISTENER_DEFAULTROOMROLLOFFFACTOR,
+    EAX2LISTENER_DEFAULTDECAYTIME,
+    EAX2LISTENER_DEFAULTDECAYHFRATIO,
+    EAX2LISTENER_DEFAULTREFLECTIONS,
+    EAX2LISTENER_DEFAULTREFLECTIONSDELAY,
+    EAX2LISTENER_DEFAULTREVERB,
+    EAX2LISTENER_DEFAULTREVERBDELAY,
+    EAX2LISTENER_DEFAULTENVIRONMENT,
+    EAX2LISTENER_DEFAULTENVIRONMENTSIZE,
+    EAX2LISTENER_DEFAULTENVIRONMENTDIFFUSION,
+    EAX2LISTENER_DEFAULTAIRABSORPTIONHF,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_PADDEDCELL{
+    -1'000L,
+    -6'000L,
+    0.0F,
+    0.17F,
+    0.1F,
+    -1'204L,
+    0.001F,
+    207L,
+    0.002F,
+    EAX2_ENVIRONMENT_PADDEDCELL,
+    1.4F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_ROOM{
+    -1'000L,
+    -454L,
+    0.0F,
+    0.4F,
+    0.83F,
+    -1'646L,
+    0.002F,
+    53L,
+    0.003F,
+    EAX2_ENVIRONMENT_ROOM,
+    1.9F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_BATHROOM{
+    -1'000L,
+    -1'200L,
+    0.0F,
+    1.49F,
+    0.54F,
+    -370L,
+    0.007F,
+    1'030L,
+    0.011F,
+    EAX2_ENVIRONMENT_BATHROOM,
+    1.4F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_LIVINGROOM{
+    -1'000L,
+    -6'000L,
+    0.0F,
+    0.5F,
+    0.1F,
+    -1'376L,
+    0.003F,
+    -1'104L,
+    0.004F,
+    EAX2_ENVIRONMENT_LIVINGROOM,
+    2.5F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_STONEROOM{
+    -1'000L,
+    -300L,
+    0.0F,
+    2.31F,
+    0.64F,
+    -711L,
+    0.012F,
+    83L,
+    0.017F,
+    EAX2_ENVIRONMENT_STONEROOM,
+    11.6F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_AUDITORIUM{
+    -1'000L,
+    -476L,
+    0.0F,
+    4.32F,
+    0.59F,
+    -789L,
+    0.02F,
+    -289L,
+    0.03F,
+    EAX2_ENVIRONMENT_AUDITORIUM,
+    21.6F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_CONCERTHALL{
+    -1'000L,
+    -500L,
+    0.0F,
+    3.92F,
+    0.7F,
+    -1'230L,
+    0.02F,
+    -2L,
+    0.029F,
+    EAX2_ENVIRONMENT_CONCERTHALL,
+    19.6F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_CAVE{
+    -1'000L,
+    0L,
+    0.0F,
+    2.91F,
+    1.3F,
+    -602L,
+    0.015F,
+    -302L,
+    0.022F,
+    EAX2_ENVIRONMENT_CAVE,
+    14.6F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_ARENA{
+    -1'000L,
+    -698L,
+    0.0F,
+    7.24F,
+    0.33F,
+    -1'166L,
+    0.02F,
+    16L,
+    0.03F,
+    EAX2_ENVIRONMENT_ARENA,
+    36.2F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_HANGAR{
+    -1'000L,
+    -1'000L,
+    0.0F,
+    10.05F,
+    0.23F,
+    -602L,
+    0.02F,
+    198L,
+    0.03F,
+    EAX2_ENVIRONMENT_HANGAR,
+    50.3F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_CARPETTEDHALLWAY{
+    -1'000L,
+    -4'000L,
+    0.0F,
+    0.3F,
+    0.1F,
+    -1'831L,
+    0.002F,
+    -1'630L,
+    0.03F,
+    EAX2_ENVIRONMENT_CARPETEDHALLWAY,
+    1.9F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_HALLWAY{
+    -1'000L,
+    -300L,
+    0.0F,
+    1.49F,
+    0.59F,
+    -1'219L,
+    0.007F,
+    441L,
+    0.011F,
+    EAX2_ENVIRONMENT_HALLWAY,
+    1.8F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_STONECORRIDOR{
+    -1'000L,
+    -237L,
+    0.0F,
+    2.7F,
+    0.79F,
+    -1'214L,
+    0.013F,
+    395L,
+    0.02F,
+    EAX2_ENVIRONMENT_STONECORRIDOR,
+    13.5F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_ALLEY{
+    -1'000L,
+    -270L,
+    0.0F,
+    1.49F,
+    0.86F,
+    -1'204L,
+    0.007F,
+    -4L,
+    0.011F,
+    EAX2_ENVIRONMENT_ALLEY,
+    7.5F,
+    0.3F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_FOREST{
+    -1'000L,
+    -3'300L,
+    0.0F,
+    1.49F,
+    0.54F,
+    -2'560L,
+    0.162F,
+    -229L,
+    0.088F,
+    EAX2_ENVIRONMENT_FOREST,
+    38.0F,
+    0.3F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_CITY{
+    -1'000L,
+    -800L,
+    0.0F,
+    1.49F,
+    0.67F,
+    -2'273L,
+    0.007F,
+    -1'691L,
+    0.011F,
+    EAX2_ENVIRONMENT_CITY,
+    7.5F,
+    0.5F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_MOUNTAINS{
+    -1'000L,
+    -2'500L,
+    0.0F,
+    1.49F,
+    0.21F,
+    -2'780L,
+    0.3F,
+    -1'434L,
+    0.1F,
+    EAX2_ENVIRONMENT_MOUNTAINS,
+    100.0F,
+    0.27F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_QUARRY{
+    -1'000L,
+    -1'000L,
+    0.0F,
+    1.49F,
+    0.83F,
+    -10'000L,
+    0.061F,
+    500L,
+    0.025F,
+    EAX2_ENVIRONMENT_QUARRY,
+    17.5F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_PLAIN{
+    -1'000L,
+    -2'000L,
+    0.0F,
+    1.49F,
+    0.5F,
+    -2'466L,
+    0.179F,
+    -1'926L,
+    0.1F,
+    EAX2_ENVIRONMENT_PLAIN,
+    42.5F,
+    0.21F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_PARKINGLOT{
+    -1'000L,
+    0L,
+    0.0F,
+    1.65F,
+    1.5F,
+    -1'363L,
+    0.008F,
+    -1'153L,
+    0.012F,
+    EAX2_ENVIRONMENT_PARKINGLOT,
+    8.3F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_SEWERPIPE{
+    -1'000L,
+    -1'000L,
+    0.0F,
+    2.81F,
+    0.14F,
+    429L,
+    0.014F,
+    1'023L,
+    0.021F,
+    EAX2_ENVIRONMENT_SEWERPIPE,
+    1.7F,
+    0.8F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_UNDERWATER{
+    -1'000L,
+    -4'000L,
+    0.0F,
+    1.49F,
+    0.1F,
+    -449L,
+    0.007F,
+    1'700L,
+    0.011F,
+    EAX2_ENVIRONMENT_UNDERWATER,
+    1.8F,
+    1.0F,
+    -5.0F,
+    EAX2LISTENER_DEFAULTFLAGS,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_DRUGGED{
+    -1'000L,
+    0L,
+    0.0F,
+    8.39F,
+    1.39F,
+    -115L,
+    0.002F,
+    985L,
+    0.03F,
+    EAX2_ENVIRONMENT_DRUGGED,
+    1.9F,
+    0.5F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_DIZZY{
+    -1'000L,
+    -400L,
+    0.0F,
+    17.23F,
+    0.56F,
+    -1'713L,
+    0.02F,
+    -613L,
+    0.03F,
+    EAX2_ENVIRONMENT_DIZZY,
+    1.8F,
+    0.6F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+constexpr EAX20LISTENERPROPERTIES EAX2REVERB_PRESET_PSYCHOTIC{
+    -1'000L,
+    -151L,
+    0.0F,
+    7.56F,
+    0.91F,
+    -626L,
+    0.02F,
+    774L,
+    0.03F,
+    EAX2_ENVIRONMENT_PSYCHOTIC,
+    1.0F,
+    0.5F,
+    -5.0F,
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+        EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+        EAX2LISTENERFLAGS_REVERBSCALE |
+        EAX2LISTENERFLAGS_REVERBDELAYSCALE,
+};
+
+} // namespace
+
+const Eax2ReverbPresets EAX2REVERB_PRESETS{
+    EAX2REVERB_PRESET_GENERIC,
+    EAX2REVERB_PRESET_PADDEDCELL,
+    EAX2REVERB_PRESET_ROOM,
+    EAX2REVERB_PRESET_BATHROOM,
+    EAX2REVERB_PRESET_LIVINGROOM,
+    EAX2REVERB_PRESET_STONEROOM,
+    EAX2REVERB_PRESET_AUDITORIUM,
+    EAX2REVERB_PRESET_CONCERTHALL,
+    EAX2REVERB_PRESET_CAVE,
+    EAX2REVERB_PRESET_ARENA,
+    EAX2REVERB_PRESET_HANGAR,
+    EAX2REVERB_PRESET_CARPETTEDHALLWAY,
+    EAX2REVERB_PRESET_HALLWAY,
+    EAX2REVERB_PRESET_STONECORRIDOR,
+    EAX2REVERB_PRESET_ALLEY,
+    EAX2REVERB_PRESET_FOREST,
+    EAX2REVERB_PRESET_CITY,
+    EAX2REVERB_PRESET_MOUNTAINS,
+    EAX2REVERB_PRESET_QUARRY,
+    EAX2REVERB_PRESET_PLAIN,
+    EAX2REVERB_PRESET_PARKINGLOT,
+    EAX2REVERB_PRESET_SEWERPIPE,
+    EAX2REVERB_PRESET_UNDERWATER,
+    EAX2REVERB_PRESET_DRUGGED,
+    EAX2REVERB_PRESET_DIZZY,
+    EAX2REVERB_PRESET_PSYCHOTIC,
+};
+
+// EAX3+ ====================================================================
+
+namespace {
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_GENERIC =
+{
+    EAXREVERB_DEFAULTENVIRONMENT,
+    EAXREVERB_DEFAULTENVIRONMENTSIZE,
+    EAXREVERB_DEFAULTENVIRONMENTDIFFUSION,
+    EAXREVERB_DEFAULTROOM,
+    EAXREVERB_DEFAULTROOMHF,
+    EAXREVERB_DEFAULTROOMLF,
+    EAXREVERB_DEFAULTDECAYTIME,
+    EAXREVERB_DEFAULTDECAYHFRATIO,
+    EAXREVERB_DEFAULTDECAYLFRATIO,
+    EAXREVERB_DEFAULTREFLECTIONS,
+    EAXREVERB_DEFAULTREFLECTIONSDELAY,
+    EAXREVERB_DEFAULTREFLECTIONSPAN,
+    EAXREVERB_DEFAULTREVERB,
+    EAXREVERB_DEFAULTREVERBDELAY,
+    EAXREVERB_DEFAULTREVERBPAN,
+    EAXREVERB_DEFAULTECHOTIME,
+    EAXREVERB_DEFAULTECHODEPTH,
+    EAXREVERB_DEFAULTMODULATIONTIME,
+    EAXREVERB_DEFAULTMODULATIONDEPTH,
+    EAXREVERB_DEFAULTAIRABSORPTIONHF,
+    EAXREVERB_DEFAULTHFREFERENCE,
+    EAXREVERB_DEFAULTLFREFERENCE,
+    EAXREVERB_DEFAULTROOMROLLOFFFACTOR,
+    EAXREVERB_DEFAULTFLAGS,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_PADDEDCELL =
+{
+    EAX_ENVIRONMENT_PADDEDCELL,
+    1.4F,
+    1.0F,
+    -1'000L,
+    -6'000L,
+    0L,
+    0.17F,
+    0.10F,
+    1.0F,
+    -1'204L,
+    0.001F,
+    EAXVECTOR{},
+    207L,
+    0.002F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_ROOM =
+{
+    EAX_ENVIRONMENT_ROOM,
+    1.9F,
+    1.0F,
+    -1'000L,
+    -454L,
+    0L,
+    0.40F,
+    0.83F,
+    1.0F,
+    -1'646L,
+    0.002F,
+    EAXVECTOR{},
+    53L,
+    0.003F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_BATHROOM =
+{
+    EAX_ENVIRONMENT_BATHROOM,
+    1.4F,
+    1.0F,
+    -1'000L,
+    -1'200L,
+    0L,
+    1.49F,
+    0.54F,
+    1.0F,
+    -370L,
+    0.007F,
+    EAXVECTOR{},
+    1'030L,
+    0.011F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_LIVINGROOM =
+{
+    EAX_ENVIRONMENT_LIVINGROOM,
+    2.5F,
+    1.0F,
+    -1'000L,
+    -6'000L,
+    0L,
+    0.50F,
+    0.10F,
+    1.0F,
+    -1'376,
+    0.003F,
+    EAXVECTOR{},
+    -1'104L,
+    0.004F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_STONEROOM =
+{
+    EAX_ENVIRONMENT_STONEROOM,
+    11.6F,
+    1.0F,
+    -1'000L,
+    -300L,
+    0L,
+    2.31F,
+    0.64F,
+    1.0F,
+    -711L,
+    0.012F,
+    EAXVECTOR{},
+    83L,
+    0.017F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_AUDITORIUM =
+{
+    EAX_ENVIRONMENT_AUDITORIUM,
+    21.6F,
+    1.0F,
+    -1'000L,
+    -476L,
+    0L,
+    4.32F,
+    0.59F,
+    1.0F,
+    -789L,
+    0.020F,
+    EAXVECTOR{},
+    -289L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_CONCERTHALL =
+{
+    EAX_ENVIRONMENT_CONCERTHALL,
+    19.6F,
+    1.0F,
+    -1'000L,
+    -500L,
+    0L,
+    3.92F,
+    0.70F,
+    1.0F,
+    -1'230L,
+    0.020F,
+    EAXVECTOR{},
+    -2L,
+    0.029F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_CAVE =
+{
+    EAX_ENVIRONMENT_CAVE,
+    14.6F,
+    1.0F,
+    -1'000L,
+    0L,
+    0L,
+    2.91F,
+    1.30F,
+    1.0F,
+    -602L,
+    0.015F,
+    EAXVECTOR{},
+    -302L,
+    0.022F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_ARENA =
+{
+    EAX_ENVIRONMENT_ARENA,
+    36.2F,
+    1.0F,
+    -1'000L,
+    -698L,
+    0L,
+    7.24F,
+    0.33F,
+    1.0F,
+    -1'166L,
+    0.020F,
+    EAXVECTOR{},
+    16L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_HANGAR =
+{
+    EAX_ENVIRONMENT_HANGAR,
+    50.3F,
+    1.0F,
+    -1'000L,
+    -1'000L,
+    0L,
+    10.05F,
+    0.23F,
+    1.0F,
+    -602L,
+    0.020F,
+    EAXVECTOR{},
+    198L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_CARPETTEDHALLWAY =
+{
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    1.9F,
+    1.0F,
+    -1'000L,
+    -4'000L,
+    0L,
+    0.30F,
+    0.10F,
+    1.0F,
+    -1'831L,
+    0.002F,
+    EAXVECTOR{},
+    -1'630L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_HALLWAY =
+{
+    EAX_ENVIRONMENT_HALLWAY,
+    1.8F,
+    1.0F,
+    -1'000L,
+    -300L,
+    0L,
+    1.49F,
+    0.59F,
+    1.0F,
+    -1'219L,
+    0.007F,
+    EAXVECTOR{},
+    441L,
+    0.011F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_STONECORRIDOR =
+{
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    13.5F,
+    1.0F,
+    -1'000L,
+    -237L,
+    0L,
+    2.70F,
+    0.79F,
+    1.0F,
+    -1'214L,
+    0.013F,
+    EAXVECTOR{},
+    395L,
+    0.020F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_ALLEY =
+{
+    EAX_ENVIRONMENT_ALLEY,
+    7.5F,
+    0.300F,
+    -1'000L,
+    -270L,
+    0L,
+    1.49F,
+    0.86F,
+    1.0F,
+    -1'204L,
+    0.007F,
+    EAXVECTOR{},
+    -4L,
+    0.011F,
+    EAXVECTOR{},
+    0.125F,
+    0.950F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_FOREST =
+{
+    EAX_ENVIRONMENT_FOREST,
+    38.0F,
+    0.300F,
+    -1'000L,
+    -3'300L,
+    0L,
+    1.49F,
+    0.54F,
+    1.0F,
+    -2'560L,
+    0.162F,
+    EAXVECTOR{},
+    -229L,
+    0.088F,
+    EAXVECTOR{},
+    0.125F,
+    1.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_CITY =
+{
+    EAX_ENVIRONMENT_CITY,
+    7.5F,
+    0.500F,
+    -1'000L,
+    -800L,
+    0L,
+    1.49F,
+    0.67F,
+    1.0F,
+    -2'273L,
+    0.007F,
+    EAXVECTOR{},
+    -1'691L,
+    0.011F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_MOUNTAINS =
+{
+    EAX_ENVIRONMENT_MOUNTAINS,
+    100.0F,
+    0.270F,
+    -1'000L,
+    -2'500L,
+    0L,
+    1.49F,
+    0.21F,
+    1.0F,
+    -2'780L,
+    0.300F,
+    EAXVECTOR{},
+    -1'434L,
+    0.100F,
+    EAXVECTOR{},
+    0.250F,
+    1.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_QUARRY =
+{
+    EAX_ENVIRONMENT_QUARRY,
+    17.5F,
+    1.0F,
+    -1'000L,
+    -1'000L,
+    0L,
+    1.49F,
+    0.83F,
+    1.0F,
+    -10'000L,
+    0.061F,
+    EAXVECTOR{},
+    500L,
+    0.025F,
+    EAXVECTOR{},
+    0.125F,
+    0.700F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_PLAIN =
+{
+    EAX_ENVIRONMENT_PLAIN,
+    42.5F,
+    0.210F,
+    -1'000L,
+    -2'000L,
+    0L,
+    1.49F,
+    0.50F,
+    1.0F,
+    -2'466L,
+    0.179F,
+    EAXVECTOR{},
+    -1'926L,
+    0.100F,
+    EAXVECTOR{},
+    0.250F,
+    1.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_PARKINGLOT =
+{
+    EAX_ENVIRONMENT_PARKINGLOT,
+    8.3F,
+    1.0F,
+    -1'000L,
+    0L,
+    0L,
+    1.65F,
+    1.50F,
+    1.0F,
+    -1'363L,
+    0.008F,
+    EAXVECTOR{},
+    -1'153L,
+    0.012F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_SEWERPIPE =
+{
+    EAX_ENVIRONMENT_SEWERPIPE,
+    1.7F,
+    0.800F,
+    -1'000L,
+    -1'000L,
+    0L,
+    2.81F,
+    0.14F,
+    1.0F,
+    429L,
+    0.014F,
+    EAXVECTOR{},
+    1'023L,
+    0.021F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    0.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_UNDERWATER =
+{
+    EAX_ENVIRONMENT_UNDERWATER,
+    1.8F,
+    1.0F,
+    -1'000L,
+    -4'000L,
+    0L,
+    1.49F,
+    0.10F,
+    1.0F,
+    -449L,
+    0.007F,
+    EAXVECTOR{},
+    1'700L,
+    0.011F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    1.180F,
+    0.348F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x3FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_DRUGGED =
+{
+    EAX_ENVIRONMENT_DRUGGED,
+    1.9F,
+    0.500F,
+    -1'000L,
+    0L,
+    0L,
+    8.39F,
+    1.39F,
+    1.0F,
+    -115L,
+    0.002F,
+    EAXVECTOR{},
+    985L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    0.250F,
+    1.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_DIZZY =
+{
+    EAX_ENVIRONMENT_DIZZY,
+    1.8F,
+    0.600F,
+    -1'000L,
+    -400L,
+    0L,
+    17.23F,
+    0.56F,
+    1.0F,
+    -1'713L,
+    0.020F,
+    EAXVECTOR{},
+    -613L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    1.0F,
+    0.810F,
+    0.310F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+constexpr EAXREVERBPROPERTIES EAXREVERB_PRESET_PSYCHOTIC =
+{
+    EAX_ENVIRONMENT_PSYCHOTIC,
+    1.0F,
+    0.500F,
+    -1'000L,
+    -151L,
+    0L,
+    7.56F,
+    0.91F,
+    1.0F,
+    -626L,
+    0.020F,
+    EAXVECTOR{},
+    774L,
+    0.030F,
+    EAXVECTOR{},
+    0.250F,
+    0.0F,
+    4.0F,
+    1.0F,
+    -5.0F,
+    5'000.0F,
+    250.0F,
+    0.0F,
+    0x1FUL,
+};
+
+} // namespace
+
+const EaxReverbPresets EAXREVERB_PRESETS{{
+    EAXREVERB_PRESET_GENERIC,
+    EAXREVERB_PRESET_PADDEDCELL,
+    EAXREVERB_PRESET_ROOM,
+    EAXREVERB_PRESET_BATHROOM,
+    EAXREVERB_PRESET_LIVINGROOM,
+    EAXREVERB_PRESET_STONEROOM,
+    EAXREVERB_PRESET_AUDITORIUM,
+    EAXREVERB_PRESET_CONCERTHALL,
+    EAXREVERB_PRESET_CAVE,
+    EAXREVERB_PRESET_ARENA,
+    EAXREVERB_PRESET_HANGAR,
+    EAXREVERB_PRESET_CARPETTEDHALLWAY,
+    EAXREVERB_PRESET_HALLWAY,
+    EAXREVERB_PRESET_STONECORRIDOR,
+    EAXREVERB_PRESET_ALLEY,
+    EAXREVERB_PRESET_FOREST,
+    EAXREVERB_PRESET_CITY,
+    EAXREVERB_PRESET_MOUNTAINS,
+    EAXREVERB_PRESET_QUARRY,
+    EAXREVERB_PRESET_PLAIN,
+    EAXREVERB_PRESET_PARKINGLOT,
+    EAXREVERB_PRESET_SEWERPIPE,
+    EAXREVERB_PRESET_UNDERWATER,
+    EAXREVERB_PRESET_DRUGGED,
+    EAXREVERB_PRESET_DIZZY,
+    EAXREVERB_PRESET_PSYCHOTIC,
+}};
diff --git a/al/eax/api.h b/al/eax/api.h
new file mode 100644
index 00000000..d254da1f
--- /dev/null
+++ b/al/eax/api.h
@@ -0,0 +1,1493 @@
+#ifndef EAX_API_INCLUDED
+#define EAX_API_INCLUDED
+
+
+//
+// EAX API.
+//
+// Based on headers `eax[2-5].h` included in Doom 3 source code:
+// https://github.com/id-Software/DOOM-3/tree/master/neo/openal/include
+//
+
+
+#include <cfloat>
+#include <cstdint>
+#include <cstring>
+
+#include <array>
+
+#include "AL/al.h"
+
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+typedef struct _GUID {
+    std::uint32_t Data1;
+    std::uint16_t Data2;
+    std::uint16_t Data3;
+    std::uint8_t Data4[8];
+} GUID;
+
+#ifndef _SYS_GUID_OPERATOR_EQ_
+#define _SYS_GUID_OPERATOR_EQ_
+inline bool operator==(const GUID& lhs, const GUID& rhs) noexcept
+{ return std::memcmp(&lhs, &rhs, sizeof(GUID)) == 0; }
+
+inline bool operator!=(const GUID& lhs, const GUID& rhs) noexcept
+{ return !(lhs == rhs); }
+#endif  // _SYS_GUID_OPERATOR_EQ_
+#endif // GUID_DEFINED
+
+
+extern const GUID DSPROPSETID_EAX_ReverbProperties;
+
+enum DSPROPERTY_EAX_REVERBPROPERTY : unsigned int {
+    DSPROPERTY_EAX_ALL,
+    DSPROPERTY_EAX_ENVIRONMENT,
+    DSPROPERTY_EAX_VOLUME,
+    DSPROPERTY_EAX_DECAYTIME,
+    DSPROPERTY_EAX_DAMPING,
+}; // DSPROPERTY_EAX_REVERBPROPERTY
+
+struct EAX_REVERBPROPERTIES {
+    unsigned long environment;
+    float fVolume;
+    float fDecayTime_sec;
+    float fDamping;
+}; // EAX_REVERBPROPERTIES
+
+
+extern const GUID DSPROPSETID_EAXBUFFER_ReverbProperties;
+
+enum DSPROPERTY_EAXBUFFER_REVERBPROPERTY : unsigned int {
+    DSPROPERTY_EAXBUFFER_ALL,
+    DSPROPERTY_EAXBUFFER_REVERBMIX,
+}; // DSPROPERTY_EAXBUFFER_REVERBPROPERTY
+
+struct EAXBUFFER_REVERBPROPERTIES {
+    float fMix;
+};
+
+constexpr auto EAX_BUFFER_MINREVERBMIX = 0.0F;
+constexpr auto EAX_BUFFER_MAXREVERBMIX = 1.0F;
+constexpr auto EAX_REVERBMIX_USEDISTANCE = -1.0F;
+
+
+extern const GUID DSPROPSETID_EAX20_ListenerProperties;
+
+enum DSPROPERTY_EAX20_LISTENERPROPERTY : unsigned int {
+    DSPROPERTY_EAX20LISTENER_NONE,
+    DSPROPERTY_EAX20LISTENER_ALLPARAMETERS,
+    DSPROPERTY_EAX20LISTENER_ROOM,
+    DSPROPERTY_EAX20LISTENER_ROOMHF,
+    DSPROPERTY_EAX20LISTENER_ROOMROLLOFFFACTOR,
+    DSPROPERTY_EAX20LISTENER_DECAYTIME,
+    DSPROPERTY_EAX20LISTENER_DECAYHFRATIO,
+    DSPROPERTY_EAX20LISTENER_REFLECTIONS,
+    DSPROPERTY_EAX20LISTENER_REFLECTIONSDELAY,
+    DSPROPERTY_EAX20LISTENER_REVERB,
+    DSPROPERTY_EAX20LISTENER_REVERBDELAY,
+    DSPROPERTY_EAX20LISTENER_ENVIRONMENT,
+    DSPROPERTY_EAX20LISTENER_ENVIRONMENTSIZE,
+    DSPROPERTY_EAX20LISTENER_ENVIRONMENTDIFFUSION,
+    DSPROPERTY_EAX20LISTENER_AIRABSORPTIONHF,
+    DSPROPERTY_EAX20LISTENER_FLAGS
+}; // DSPROPERTY_EAX20_LISTENERPROPERTY
+
+struct EAX20LISTENERPROPERTIES {
+    long lRoom; // room effect level at low frequencies
+    long lRoomHF; // room effect high-frequency level re. low frequency level
+    float flRoomRolloffFactor; // like DS3D flRolloffFactor but for room effect
+    float flDecayTime; // reverberation decay time at low frequencies
+    float flDecayHFRatio; // high-frequency to low-frequency decay time ratio
+    long lReflections; // early reflections level relative to room effect
+    float flReflectionsDelay; // initial reflection delay time
+    long lReverb; // late reverberation level relative to room effect
+    float flReverbDelay; // late reverberation delay time relative to initial reflection
+    unsigned long dwEnvironment; // sets all listener properties
+    float flEnvironmentSize; // environment size in meters
+    float flEnvironmentDiffusion; // environment diffusion
+    float flAirAbsorptionHF; // change in level per meter at 5 kHz
+    unsigned long dwFlags; // modifies the behavior of properties
+}; // EAX20LISTENERPROPERTIES
+
+enum : unsigned long {
+    EAX2_ENVIRONMENT_GENERIC,
+    EAX2_ENVIRONMENT_PADDEDCELL,
+    EAX2_ENVIRONMENT_ROOM,
+    EAX2_ENVIRONMENT_BATHROOM,
+    EAX2_ENVIRONMENT_LIVINGROOM,
+    EAX2_ENVIRONMENT_STONEROOM,
+    EAX2_ENVIRONMENT_AUDITORIUM,
+    EAX2_ENVIRONMENT_CONCERTHALL,
+    EAX2_ENVIRONMENT_CAVE,
+    EAX2_ENVIRONMENT_ARENA,
+    EAX2_ENVIRONMENT_HANGAR,
+    EAX2_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX2_ENVIRONMENT_HALLWAY,
+    EAX2_ENVIRONMENT_STONECORRIDOR,
+    EAX2_ENVIRONMENT_ALLEY,
+    EAX2_ENVIRONMENT_FOREST,
+    EAX2_ENVIRONMENT_CITY,
+    EAX2_ENVIRONMENT_MOUNTAINS,
+    EAX2_ENVIRONMENT_QUARRY,
+    EAX2_ENVIRONMENT_PLAIN,
+    EAX2_ENVIRONMENT_PARKINGLOT,
+    EAX2_ENVIRONMENT_SEWERPIPE,
+    EAX2_ENVIRONMENT_UNDERWATER,
+    EAX2_ENVIRONMENT_DRUGGED,
+    EAX2_ENVIRONMENT_DIZZY,
+    EAX2_ENVIRONMENT_PSYCHOTIC,
+
+    EAX2_ENVIRONMENT_COUNT,
+};
+
+constexpr auto EAX2LISTENERFLAGS_DECAYTIMESCALE = 0x00000001UL;
+constexpr auto EAX2LISTENERFLAGS_REFLECTIONSSCALE = 0x00000002UL;
+constexpr auto EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE = 0x00000004UL;
+constexpr auto EAX2LISTENERFLAGS_REVERBSCALE = 0x00000008UL;
+constexpr auto EAX2LISTENERFLAGS_REVERBDELAYSCALE = 0x00000010UL;
+constexpr auto EAX2LISTENERFLAGS_DECAYHFLIMIT = 0x00000020UL;
+constexpr auto EAX2LISTENERFLAGS_RESERVED = 0xFFFFFFC0UL;
+
+constexpr auto EAX2LISTENER_MINROOM = -10'000L;
+constexpr auto EAX2LISTENER_MAXROOM = 0L;
+constexpr auto EAX2LISTENER_DEFAULTROOM = -1'000L;
+
+constexpr auto EAX2LISTENER_MINROOMHF = -10'000L;
+constexpr auto EAX2LISTENER_MAXROOMHF = 0L;
+constexpr auto EAX2LISTENER_DEFAULTROOMHF = -100L;
+
+constexpr auto EAX2LISTENER_MINROOMROLLOFFFACTOR = 0.0F;
+constexpr auto EAX2LISTENER_MAXROOMROLLOFFFACTOR = 10.0F;
+constexpr auto EAX2LISTENER_DEFAULTROOMROLLOFFFACTOR = 0.0F;
+
+constexpr auto EAX2LISTENER_MINDECAYTIME = 0.1F;
+constexpr auto EAX2LISTENER_MAXDECAYTIME = 20.0F;
+constexpr auto EAX2LISTENER_DEFAULTDECAYTIME = 1.49F;
+
+constexpr auto EAX2LISTENER_MINDECAYHFRATIO = 0.1F;
+constexpr auto EAX2LISTENER_MAXDECAYHFRATIO = 2.0F;
+constexpr auto EAX2LISTENER_DEFAULTDECAYHFRATIO = 0.83F;
+
+constexpr auto EAX2LISTENER_MINREFLECTIONS = -10'000L;
+constexpr auto EAX2LISTENER_MAXREFLECTIONS = 1'000L;
+constexpr auto EAX2LISTENER_DEFAULTREFLECTIONS = -2'602L;
+
+constexpr auto EAX2LISTENER_MINREFLECTIONSDELAY = 0.0F;
+constexpr auto EAX2LISTENER_MAXREFLECTIONSDELAY = 0.3F;
+constexpr auto EAX2LISTENER_DEFAULTREFLECTIONSDELAY = 0.007F;
+
+constexpr auto EAX2LISTENER_MINREVERB = -10'000L;
+constexpr auto EAX2LISTENER_MAXREVERB = 2'000L;
+constexpr auto EAX2LISTENER_DEFAULTREVERB = 200L;
+
+constexpr auto EAX2LISTENER_MINREVERBDELAY = 0.0F;
+constexpr auto EAX2LISTENER_MAXREVERBDELAY = 0.1F;
+constexpr auto EAX2LISTENER_DEFAULTREVERBDELAY = 0.011F;
+
+constexpr auto EAX2LISTENER_MINENVIRONMENT = 0UL;
+constexpr auto EAX2LISTENER_MAXENVIRONMENT = EAX2_ENVIRONMENT_COUNT - 1;
+constexpr auto EAX2LISTENER_DEFAULTENVIRONMENT = EAX2_ENVIRONMENT_GENERIC;
+
+constexpr auto EAX2LISTENER_MINENVIRONMENTSIZE = 1.0F;
+constexpr auto EAX2LISTENER_MAXENVIRONMENTSIZE = 100.0F;
+constexpr auto EAX2LISTENER_DEFAULTENVIRONMENTSIZE = 7.5F;
+
+constexpr auto EAX2LISTENER_MINENVIRONMENTDIFFUSION = 0.0F;
+constexpr auto EAX2LISTENER_MAXENVIRONMENTDIFFUSION = 1.0F;
+constexpr auto EAX2LISTENER_DEFAULTENVIRONMENTDIFFUSION = 1.0F;
+
+constexpr auto EAX2LISTENER_MINAIRABSORPTIONHF = -100.0F;
+constexpr auto EAX2LISTENER_MAXAIRABSORPTIONHF = 0.0F;
+constexpr auto EAX2LISTENER_DEFAULTAIRABSORPTIONHF = -5.0F;
+
+constexpr auto EAX2LISTENER_DEFAULTFLAGS =
+    EAX2LISTENERFLAGS_DECAYTIMESCALE |
+    EAX2LISTENERFLAGS_REFLECTIONSSCALE |
+    EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE |
+    EAX2LISTENERFLAGS_REVERBSCALE |
+    EAX2LISTENERFLAGS_REVERBDELAYSCALE |
+    EAX2LISTENERFLAGS_DECAYHFLIMIT;
+
+
+extern const GUID DSPROPSETID_EAX20_BufferProperties;
+
+enum DSPROPERTY_EAX20_BUFFERPROPERTY : unsigned int {
+    DSPROPERTY_EAX20BUFFER_NONE,
+    DSPROPERTY_EAX20BUFFER_ALLPARAMETERS,
+    DSPROPERTY_EAX20BUFFER_DIRECT,
+    DSPROPERTY_EAX20BUFFER_DIRECTHF,
+    DSPROPERTY_EAX20BUFFER_ROOM,
+    DSPROPERTY_EAX20BUFFER_ROOMHF,
+    DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR,
+    DSPROPERTY_EAX20BUFFER_OBSTRUCTION,
+    DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO,
+    DSPROPERTY_EAX20BUFFER_OCCLUSION,
+    DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO,
+    DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO,
+    DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF,
+    DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR,
+    DSPROPERTY_EAX20BUFFER_FLAGS
+}; // DSPROPERTY_EAX20_BUFFERPROPERTY
+
+struct EAX20BUFFERPROPERTIES {
+    long lDirect; // direct path level
+    long lDirectHF; // direct path level at high frequencies
+    long lRoom; // room effect level
+    long lRoomHF; // room effect level at high frequencies
+    float flRoomRolloffFactor; // like DS3D flRolloffFactor but for room effect
+    long lObstruction; // main obstruction control (attenuation at high frequencies) 
+    float flObstructionLFRatio; // obstruction low-frequency level re. main control
+    long lOcclusion; // main occlusion control (attenuation at high frequencies)
+    float flOcclusionLFRatio; // occlusion low-frequency level re. main control
+    float flOcclusionRoomRatio; // occlusion room effect level re. main control
+    long lOutsideVolumeHF; // outside sound cone level at high frequencies
+    float flAirAbsorptionFactor; // multiplies DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF
+    unsigned long dwFlags; // modifies the behavior of properties
+}; // EAX20BUFFERPROPERTIES
+
+extern const GUID DSPROPSETID_EAX30_ListenerProperties;
+
+extern const GUID DSPROPSETID_EAX30_BufferProperties;
+
+
+constexpr auto EAX_MAX_FXSLOTS = 4;
+
+constexpr auto EAX40_MAX_ACTIVE_FXSLOTS = 2;
+constexpr auto EAX50_MAX_ACTIVE_FXSLOTS = 4;
+
+
+constexpr auto EAX_OK = 0L;
+constexpr auto EAXERR_INVALID_OPERATION = -1L;
+constexpr auto EAXERR_INVALID_VALUE = -2L;
+constexpr auto EAXERR_NO_EFFECT_LOADED = -3L;
+constexpr auto EAXERR_UNKNOWN_EFFECT = -4L;
+constexpr auto EAXERR_INCOMPATIBLE_SOURCE_TYPE = -5L;
+constexpr auto EAXERR_INCOMPATIBLE_EAX_VERSION = -6L;
+
+
+extern const GUID EAX_NULL_GUID;
+
+extern const GUID EAX_PrimaryFXSlotID;
+
+
+struct EAXVECTOR {
+    float x;
+    float y;
+    float z;
+}; // EAXVECTOR
+
+inline bool operator==(const EAXVECTOR& lhs, const EAXVECTOR& rhs) noexcept
+{ return std::memcmp(&lhs, &rhs, sizeof(EAXVECTOR)) == 0; }
+
+inline bool operator!=(const EAXVECTOR& lhs, const EAXVECTOR& rhs) noexcept
+{ return !(lhs == rhs); }
+
+
+extern const GUID EAXPROPERTYID_EAX40_Context;
+
+extern const GUID EAXPROPERTYID_EAX50_Context;
+
+// EAX50
+constexpr auto HEADPHONES = 0UL;
+constexpr auto SPEAKERS_2 = 1UL;
+constexpr auto SPEAKERS_4 = 2UL;
+constexpr auto SPEAKERS_5 = 3UL; // 5.1 speakers
+constexpr auto SPEAKERS_6 = 4UL; // 6.1 speakers
+constexpr auto SPEAKERS_7 = 5UL; // 7.1 speakers
+
+constexpr auto EAXCONTEXT_MINSPEAKERCONFIG = HEADPHONES;
+constexpr auto EAXCONTEXT_MAXSPEAKERCONFIG = SPEAKERS_7;
+
+// EAX50
+constexpr auto EAX_40 = 5UL; // EAX 4.0
+constexpr auto EAX_50 = 6UL; // EAX 5.0
+
+constexpr auto EAXCONTEXT_MINEAXSESSION = EAX_40;
+constexpr auto EAXCONTEXT_MAXEAXSESSION = EAX_50;
+constexpr auto EAXCONTEXT_DEFAULTEAXSESSION = EAX_40;
+
+constexpr auto EAXCONTEXT_MINMAXACTIVESENDS = 2UL;
+constexpr auto EAXCONTEXT_MAXMAXACTIVESENDS = 4UL;
+constexpr auto EAXCONTEXT_DEFAULTMAXACTIVESENDS = 2UL;
+
+// EAX50
+struct EAXSESSIONPROPERTIES {
+    unsigned long ulEAXVersion;
+    unsigned long ulMaxActiveSends;
+}; // EAXSESSIONPROPERTIES
+
+enum EAXCONTEXT_PROPERTY : unsigned int {
+    EAXCONTEXT_NONE = 0,
+    EAXCONTEXT_ALLPARAMETERS,
+    EAXCONTEXT_PRIMARYFXSLOTID,
+    EAXCONTEXT_DISTANCEFACTOR,
+    EAXCONTEXT_AIRABSORPTIONHF,
+    EAXCONTEXT_HFREFERENCE,
+    EAXCONTEXT_LASTERROR,
+
+    // EAX50
+    EAXCONTEXT_SPEAKERCONFIG,
+    EAXCONTEXT_EAXSESSION,
+    EAXCONTEXT_MACROFXFACTOR,
+}; // EAXCONTEXT_PROPERTY
+
+struct EAX40CONTEXTPROPERTIES {
+    GUID guidPrimaryFXSlotID;
+    float flDistanceFactor;
+    float flAirAbsorptionHF;
+    float flHFReference;
+}; // EAX40CONTEXTPROPERTIES
+
+struct EAX50CONTEXTPROPERTIES : public EAX40CONTEXTPROPERTIES {
+    float flMacroFXFactor;
+}; // EAX50CONTEXTPROPERTIES
+
+
+constexpr auto EAXCONTEXT_MINDISTANCEFACTOR = FLT_MIN;
+constexpr auto EAXCONTEXT_MAXDISTANCEFACTOR = FLT_MAX;
+constexpr auto EAXCONTEXT_DEFAULTDISTANCEFACTOR = 1.0F;
+
+constexpr auto EAXCONTEXT_MINAIRABSORPTIONHF = -100.0F;
+constexpr auto EAXCONTEXT_MAXAIRABSORPTIONHF = 0.0F;
+constexpr auto EAXCONTEXT_DEFAULTAIRABSORPTIONHF = -5.0F;
+
+constexpr auto EAXCONTEXT_MINHFREFERENCE = 1000.0F;
+constexpr auto EAXCONTEXT_MAXHFREFERENCE = 20000.0F;
+constexpr auto EAXCONTEXT_DEFAULTHFREFERENCE = 5000.0F;
+
+constexpr auto EAXCONTEXT_MINMACROFXFACTOR = 0.0F;
+constexpr auto EAXCONTEXT_MAXMACROFXFACTOR = 1.0F;
+constexpr auto EAXCONTEXT_DEFAULTMACROFXFACTOR = 0.0F;
+
+
+extern const GUID EAXPROPERTYID_EAX40_FXSlot0;
+extern const GUID EAXPROPERTYID_EAX50_FXSlot0;
+extern const GUID EAXPROPERTYID_EAX40_FXSlot1;
+extern const GUID EAXPROPERTYID_EAX50_FXSlot1;
+extern const GUID EAXPROPERTYID_EAX40_FXSlot2;
+extern const GUID EAXPROPERTYID_EAX50_FXSlot2;
+extern const GUID EAXPROPERTYID_EAX40_FXSlot3;
+extern const GUID EAXPROPERTYID_EAX50_FXSlot3;
+
+extern const GUID EAX40CONTEXT_DEFAULTPRIMARYFXSLOTID;
+extern const GUID EAX50CONTEXT_DEFAULTPRIMARYFXSLOTID;
+
+enum EAXFXSLOT_PROPERTY : unsigned int {
+    EAXFXSLOT_PARAMETER = 0,
+
+    EAXFXSLOT_NONE = 0x10000,
+    EAXFXSLOT_ALLPARAMETERS,
+    EAXFXSLOT_LOADEFFECT,
+    EAXFXSLOT_VOLUME,
+    EAXFXSLOT_LOCK,
+    EAXFXSLOT_FLAGS,
+
+    // EAX50
+    EAXFXSLOT_OCCLUSION,
+    EAXFXSLOT_OCCLUSIONLFRATIO,
+}; // EAXFXSLOT_PROPERTY
+
+constexpr auto EAXFXSLOTFLAGS_ENVIRONMENT = 0x00000001UL;
+// EAX50
+constexpr auto EAXFXSLOTFLAGS_UPMIX = 0x00000002UL;
+
+constexpr auto EAX40FXSLOTFLAGS_RESERVED = 0xFFFFFFFEUL; // reserved future use
+constexpr auto EAX50FXSLOTFLAGS_RESERVED = 0xFFFFFFFCUL; // reserved future use
+
+
+constexpr auto EAXFXSLOT_MINVOLUME = -10'000L;
+constexpr auto EAXFXSLOT_MAXVOLUME = 0L;
+constexpr auto EAXFXSLOT_DEFAULTVOLUME = 0L;
+
+constexpr auto EAXFXSLOT_MINLOCK = 0L;
+constexpr auto EAXFXSLOT_MAXLOCK = 1L;
+
+enum : long {
+    EAXFXSLOT_UNLOCKED = 0,
+    EAXFXSLOT_LOCKED = 1
+};
+
+constexpr auto EAXFXSLOT_MINOCCLUSION = -10'000L;
+constexpr auto EAXFXSLOT_MAXOCCLUSION = 0L;
+constexpr auto EAXFXSLOT_DEFAULTOCCLUSION = 0L;
+
+constexpr auto EAXFXSLOT_MINOCCLUSIONLFRATIO = 0.0F;
+constexpr auto EAXFXSLOT_MAXOCCLUSIONLFRATIO = 1.0F;
+constexpr auto EAXFXSLOT_DEFAULTOCCLUSIONLFRATIO = 0.25F;
+
+constexpr auto EAX40FXSLOT_DEFAULTFLAGS = EAXFXSLOTFLAGS_ENVIRONMENT;
+
+constexpr auto EAX50FXSLOT_DEFAULTFLAGS =
+    EAXFXSLOTFLAGS_ENVIRONMENT |
+    EAXFXSLOTFLAGS_UPMIX; // ignored for reverb;
+
+struct EAX40FXSLOTPROPERTIES {
+    GUID guidLoadEffect;
+    long lVolume;
+    long lLock;
+    unsigned long ulFlags;
+}; // EAX40FXSLOTPROPERTIES
+
+struct EAX50FXSLOTPROPERTIES : public EAX40FXSLOTPROPERTIES {
+    long lOcclusion;
+    float flOcclusionLFRatio;
+}; // EAX50FXSLOTPROPERTIES
+
+extern const GUID EAXPROPERTYID_EAX40_Source;
+extern const GUID EAXPROPERTYID_EAX50_Source;
+
+// Source object properties
+enum EAXSOURCE_PROPERTY : unsigned int {
+    // EAX30
+    EAXSOURCE_NONE,
+    EAXSOURCE_ALLPARAMETERS,
+    EAXSOURCE_OBSTRUCTIONPARAMETERS,
+    EAXSOURCE_OCCLUSIONPARAMETERS,
+    EAXSOURCE_EXCLUSIONPARAMETERS,
+    EAXSOURCE_DIRECT,
+    EAXSOURCE_DIRECTHF,
+    EAXSOURCE_ROOM,
+    EAXSOURCE_ROOMHF,
+    EAXSOURCE_OBSTRUCTION,
+    EAXSOURCE_OBSTRUCTIONLFRATIO,
+    EAXSOURCE_OCCLUSION,
+    EAXSOURCE_OCCLUSIONLFRATIO,
+    EAXSOURCE_OCCLUSIONROOMRATIO,
+    EAXSOURCE_OCCLUSIONDIRECTRATIO,
+    EAXSOURCE_EXCLUSION,
+    EAXSOURCE_EXCLUSIONLFRATIO,
+    EAXSOURCE_OUTSIDEVOLUMEHF,
+    EAXSOURCE_DOPPLERFACTOR,
+    EAXSOURCE_ROLLOFFFACTOR,
+    EAXSOURCE_ROOMROLLOFFFACTOR,
+    EAXSOURCE_AIRABSORPTIONFACTOR,
+    EAXSOURCE_FLAGS,
+
+    // EAX40
+    EAXSOURCE_SENDPARAMETERS,
+    EAXSOURCE_ALLSENDPARAMETERS,
+    EAXSOURCE_OCCLUSIONSENDPARAMETERS,
+    EAXSOURCE_EXCLUSIONSENDPARAMETERS,
+    EAXSOURCE_ACTIVEFXSLOTID,
+
+    // EAX50
+    EAXSOURCE_MACROFXFACTOR,
+    EAXSOURCE_SPEAKERLEVELS,
+    EAXSOURCE_ALL2DPARAMETERS,
+}; // EAXSOURCE_PROPERTY
+
+
+constexpr auto EAXSOURCEFLAGS_DIRECTHFAUTO = 0x00000001UL; // relates to EAXSOURCE_DIRECTHF
+constexpr auto EAXSOURCEFLAGS_ROOMAUTO = 0x00000002UL; // relates to EAXSOURCE_ROOM
+constexpr auto EAXSOURCEFLAGS_ROOMHFAUTO = 0x00000004UL; // relates to EAXSOURCE_ROOMHF
+// EAX50
+constexpr auto EAXSOURCEFLAGS_3DELEVATIONFILTER = 0x00000008UL;
+constexpr auto EAXSOURCEFLAGS_UPMIX = 0x00000010UL;
+constexpr auto EAXSOURCEFLAGS_APPLYSPEAKERLEVELS = 0x00000020UL;
+
+constexpr auto EAX20SOURCEFLAGS_RESERVED = 0xFFFFFFF8UL; // reserved future use
+constexpr auto EAX50SOURCEFLAGS_RESERVED = 0xFFFFFFC0UL; // reserved future use
+
+
+constexpr auto EAXSOURCE_MINSEND = -10'000L;
+constexpr auto EAXSOURCE_MAXSEND = 0L;
+constexpr auto EAXSOURCE_DEFAULTSEND = 0L;
+
+constexpr auto EAXSOURCE_MINSENDHF = -10'000L;
+constexpr auto EAXSOURCE_MAXSENDHF = 0L;
+constexpr auto EAXSOURCE_DEFAULTSENDHF = 0L;
+
+constexpr auto EAXSOURCE_MINDIRECT = -10'000L;
+constexpr auto EAXSOURCE_MAXDIRECT = 1'000L;
+constexpr auto EAXSOURCE_DEFAULTDIRECT = 0L;
+
+constexpr auto EAXSOURCE_MINDIRECTHF = -10'000L;
+constexpr auto EAXSOURCE_MAXDIRECTHF = 0L;
+constexpr auto EAXSOURCE_DEFAULTDIRECTHF = 0L;
+
+constexpr auto EAXSOURCE_MINROOM = -10'000L;
+constexpr auto EAXSOURCE_MAXROOM = 1'000L;
+constexpr auto EAXSOURCE_DEFAULTROOM = 0L;
+
+constexpr auto EAXSOURCE_MINROOMHF = -10'000L;
+constexpr auto EAXSOURCE_MAXROOMHF = 0L;
+constexpr auto EAXSOURCE_DEFAULTROOMHF = 0L;
+
+constexpr auto EAXSOURCE_MINOBSTRUCTION = -10'000L;
+constexpr auto EAXSOURCE_MAXOBSTRUCTION = 0L;
+constexpr auto EAXSOURCE_DEFAULTOBSTRUCTION = 0L;
+
+constexpr auto EAXSOURCE_MINOBSTRUCTIONLFRATIO = 0.0F;
+constexpr auto EAXSOURCE_MAXOBSTRUCTIONLFRATIO = 1.0F;
+constexpr auto EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO = 0.0F;
+
+constexpr auto EAXSOURCE_MINOCCLUSION = -10'000L;
+constexpr auto EAXSOURCE_MAXOCCLUSION = 0L;
+constexpr auto EAXSOURCE_DEFAULTOCCLUSION = 0L;
+
+constexpr auto EAXSOURCE_MINOCCLUSIONLFRATIO = 0.0F;
+constexpr auto EAXSOURCE_MAXOCCLUSIONLFRATIO = 1.0F;
+constexpr auto EAXSOURCE_DEFAULTOCCLUSIONLFRATIO = 0.25F;
+
+constexpr auto EAXSOURCE_MINOCCLUSIONROOMRATIO = 0.0F;
+constexpr auto EAXSOURCE_MAXOCCLUSIONROOMRATIO = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO = 1.5F;
+
+constexpr auto EAXSOURCE_MINOCCLUSIONDIRECTRATIO = 0.0F;
+constexpr auto EAXSOURCE_MAXOCCLUSIONDIRECTRATIO = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO = 1.0F;
+
+constexpr auto EAXSOURCE_MINEXCLUSION = -10'000L;
+constexpr auto EAXSOURCE_MAXEXCLUSION = 0L;
+constexpr auto EAXSOURCE_DEFAULTEXCLUSION = 0L;
+
+constexpr auto EAXSOURCE_MINEXCLUSIONLFRATIO = 0.0F;
+constexpr auto EAXSOURCE_MAXEXCLUSIONLFRATIO = 1.0F;
+constexpr auto EAXSOURCE_DEFAULTEXCLUSIONLFRATIO = 1.0F;
+
+constexpr auto EAXSOURCE_MINOUTSIDEVOLUMEHF = -10'000L;
+constexpr auto EAXSOURCE_MAXOUTSIDEVOLUMEHF = 0L;
+constexpr auto EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF = 0L;
+
+constexpr auto EAXSOURCE_MINDOPPLERFACTOR = 0.0F;
+constexpr auto EAXSOURCE_MAXDOPPLERFACTOR = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTDOPPLERFACTOR = 1.0F;
+
+constexpr auto EAXSOURCE_MINROLLOFFFACTOR = 0.0F;
+constexpr auto EAXSOURCE_MAXROLLOFFFACTOR = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTROLLOFFFACTOR = 0.0F;
+
+constexpr auto EAXSOURCE_MINROOMROLLOFFFACTOR = 0.0F;
+constexpr auto EAXSOURCE_MAXROOMROLLOFFFACTOR = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTROOMROLLOFFFACTOR = 0.0F;
+
+constexpr auto EAXSOURCE_MINAIRABSORPTIONFACTOR = 0.0F;
+constexpr auto EAXSOURCE_MAXAIRABSORPTIONFACTOR = 10.0F;
+constexpr auto EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR = 0.0F;
+
+// EAX50
+
+constexpr auto EAXSOURCE_MINMACROFXFACTOR = 0.0F;
+constexpr auto EAXSOURCE_MAXMACROFXFACTOR = 1.0F;
+constexpr auto EAXSOURCE_DEFAULTMACROFXFACTOR = 1.0F;
+
+constexpr auto EAXSOURCE_MINSPEAKERLEVEL = -10'000L;
+constexpr auto EAXSOURCE_MAXSPEAKERLEVEL = 0L;
+constexpr auto EAXSOURCE_DEFAULTSPEAKERLEVEL = -10'000L;
+
+constexpr auto EAXSOURCE_DEFAULTFLAGS =
+    EAXSOURCEFLAGS_DIRECTHFAUTO |
+    EAXSOURCEFLAGS_ROOMAUTO |
+    EAXSOURCEFLAGS_ROOMHFAUTO;
+
+enum : long {
+    EAXSPEAKER_FRONT_LEFT = 1,
+    EAXSPEAKER_FRONT_CENTER = 2,
+    EAXSPEAKER_FRONT_RIGHT = 3,
+    EAXSPEAKER_SIDE_RIGHT = 4,
+    EAXSPEAKER_REAR_RIGHT = 5,
+    EAXSPEAKER_REAR_CENTER = 6,
+    EAXSPEAKER_REAR_LEFT = 7,
+    EAXSPEAKER_SIDE_LEFT = 8,
+    EAXSPEAKER_LOW_FREQUENCY = 9
+};
+
+// EAXSOURCEFLAGS_DIRECTHFAUTO, EAXSOURCEFLAGS_ROOMAUTO and EAXSOURCEFLAGS_ROOMHFAUTO are ignored for 2D sources
+// EAXSOURCEFLAGS_UPMIX is ignored for 3D sources
+constexpr auto EAX50SOURCE_DEFAULTFLAGS =
+    EAXSOURCEFLAGS_DIRECTHFAUTO |
+    EAXSOURCEFLAGS_ROOMAUTO |
+    EAXSOURCEFLAGS_ROOMHFAUTO |
+    EAXSOURCEFLAGS_UPMIX;
+
+struct EAX30SOURCEPROPERTIES {
+    long lDirect; // direct path level (at low and mid frequencies)
+    long lDirectHF; // relative direct path level at high frequencies
+    long lRoom; // room effect level (at low and mid frequencies)
+    long lRoomHF; // relative room effect level at high frequencies
+    long lObstruction; // main obstruction control (attenuation at high frequencies) 
+    float flObstructionLFRatio; // obstruction low-frequency level re. main control
+    long lOcclusion; // main occlusion control (attenuation at high frequencies)
+    float flOcclusionLFRatio; // occlusion low-frequency level re. main control
+    float flOcclusionRoomRatio; // relative occlusion control for room effect
+    float flOcclusionDirectRatio; // relative occlusion control for direct path
+    long lExclusion; // main exlusion control (attenuation at high frequencies)
+    float flExclusionLFRatio; // exclusion low-frequency level re. main control
+    long lOutsideVolumeHF; // outside sound cone level at high frequencies
+    float flDopplerFactor; // like DS3D flDopplerFactor but per source
+    float flRolloffFactor; // like DS3D flRolloffFactor but per source
+    float flRoomRolloffFactor; // like DS3D flRolloffFactor but for room effect
+    float flAirAbsorptionFactor; // multiplies EAXREVERB_AIRABSORPTIONHF
+    unsigned long ulFlags; // modifies the behavior of properties
+}; // EAX30SOURCEPROPERTIES
+
+struct EAX50SOURCEPROPERTIES : public EAX30SOURCEPROPERTIES {
+    float flMacroFXFactor;
+}; // EAX50SOURCEPROPERTIES
+
+struct EAXSOURCEALLSENDPROPERTIES {
+    GUID guidReceivingFXSlotID;
+    long lSend; // send level (at low and mid frequencies)
+    long lSendHF; // relative send level at high frequencies
+    long lOcclusion;
+    float flOcclusionLFRatio;
+    float flOcclusionRoomRatio;
+    float flOcclusionDirectRatio;
+    long lExclusion;
+    float flExclusionLFRatio;
+}; // EAXSOURCEALLSENDPROPERTIES
+
+struct EAXSOURCE2DPROPERTIES {
+    long lDirect; // direct path level (at low and mid frequencies)
+    long lDirectHF; // relative direct path level at high frequencies
+    long lRoom; // room effect level (at low and mid frequencies)
+    long lRoomHF; // relative room effect level at high frequencies
+    unsigned long ulFlags; // modifies the behavior of properties
+}; // EAXSOURCE2DPROPERTIES
+
+struct EAXSPEAKERLEVELPROPERTIES {
+    long lSpeakerID;
+    long lLevel;
+}; // EAXSPEAKERLEVELPROPERTIES
+
+struct EAX40ACTIVEFXSLOTS {
+    GUID guidActiveFXSlots[EAX40_MAX_ACTIVE_FXSLOTS];
+}; // EAX40ACTIVEFXSLOTS
+
+struct EAX50ACTIVEFXSLOTS {
+    GUID guidActiveFXSlots[EAX50_MAX_ACTIVE_FXSLOTS];
+}; // EAX50ACTIVEFXSLOTS
+
+// Use this structure for EAXSOURCE_OBSTRUCTIONPARAMETERS property.
+struct EAXOBSTRUCTIONPROPERTIES {
+    long lObstruction;
+    float flObstructionLFRatio;
+}; // EAXOBSTRUCTIONPROPERTIES
+
+// Use this structure for EAXSOURCE_OCCLUSIONPARAMETERS property.
+struct EAXOCCLUSIONPROPERTIES {
+    long lOcclusion;
+    float flOcclusionLFRatio;
+    float flOcclusionRoomRatio;
+    float flOcclusionDirectRatio;
+}; // EAXOCCLUSIONPROPERTIES
+
+// Use this structure for EAXSOURCE_EXCLUSIONPARAMETERS property.
+struct EAXEXCLUSIONPROPERTIES {
+    long lExclusion;
+    float flExclusionLFRatio;
+}; // EAXEXCLUSIONPROPERTIES
+
+// Use this structure for EAXSOURCE_SENDPARAMETERS properties.
+struct EAXSOURCESENDPROPERTIES {
+    GUID guidReceivingFXSlotID;
+    long lSend;
+    long lSendHF;
+}; // EAXSOURCESENDPROPERTIES
+
+// Use this structure for EAXSOURCE_OCCLUSIONSENDPARAMETERS 
+struct EAXSOURCEOCCLUSIONSENDPROPERTIES {
+    GUID guidReceivingFXSlotID;
+    long lOcclusion;
+    float flOcclusionLFRatio;
+    float flOcclusionRoomRatio;
+    float flOcclusionDirectRatio;
+}; // EAXSOURCEOCCLUSIONSENDPROPERTIES
+
+// Use this structure for EAXSOURCE_EXCLUSIONSENDPARAMETERS
+struct EAXSOURCEEXCLUSIONSENDPROPERTIES {
+    GUID guidReceivingFXSlotID;
+    long lExclusion;
+    float flExclusionLFRatio;
+}; // EAXSOURCEEXCLUSIONSENDPROPERTIES
+
+extern const EAX40ACTIVEFXSLOTS EAX40SOURCE_DEFAULTACTIVEFXSLOTID;
+
+extern const EAX50ACTIVEFXSLOTS EAX50SOURCE_3DDEFAULTACTIVEFXSLOTID;
+
+extern const EAX50ACTIVEFXSLOTS EAX50SOURCE_2DDEFAULTACTIVEFXSLOTID;
+
+
+// EAX Reverb Effect
+
+extern const GUID EAX_REVERB_EFFECT;
+
+// Reverb effect properties
+enum EAXREVERB_PROPERTY : unsigned int {
+    EAXREVERB_NONE,
+    EAXREVERB_ALLPARAMETERS,
+    EAXREVERB_ENVIRONMENT,
+    EAXREVERB_ENVIRONMENTSIZE,
+    EAXREVERB_ENVIRONMENTDIFFUSION,
+    EAXREVERB_ROOM,
+    EAXREVERB_ROOMHF,
+    EAXREVERB_ROOMLF,
+    EAXREVERB_DECAYTIME,
+    EAXREVERB_DECAYHFRATIO,
+    EAXREVERB_DECAYLFRATIO,
+    EAXREVERB_REFLECTIONS,
+    EAXREVERB_REFLECTIONSDELAY,
+    EAXREVERB_REFLECTIONSPAN,
+    EAXREVERB_REVERB,
+    EAXREVERB_REVERBDELAY,
+    EAXREVERB_REVERBPAN,
+    EAXREVERB_ECHOTIME,
+    EAXREVERB_ECHODEPTH,
+    EAXREVERB_MODULATIONTIME,
+    EAXREVERB_MODULATIONDEPTH,
+    EAXREVERB_AIRABSORPTIONHF,
+    EAXREVERB_HFREFERENCE,
+    EAXREVERB_LFREFERENCE,
+    EAXREVERB_ROOMROLLOFFFACTOR,
+    EAXREVERB_FLAGS,
+}; // EAXREVERB_PROPERTY
+
+// used by EAXREVERB_ENVIRONMENT
+enum : unsigned long {
+    EAX_ENVIRONMENT_GENERIC,
+    EAX_ENVIRONMENT_PADDEDCELL,
+    EAX_ENVIRONMENT_ROOM,
+    EAX_ENVIRONMENT_BATHROOM,
+    EAX_ENVIRONMENT_LIVINGROOM,
+    EAX_ENVIRONMENT_STONEROOM,
+    EAX_ENVIRONMENT_AUDITORIUM,
+    EAX_ENVIRONMENT_CONCERTHALL,
+    EAX_ENVIRONMENT_CAVE,
+    EAX_ENVIRONMENT_ARENA,
+    EAX_ENVIRONMENT_HANGAR,
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX_ENVIRONMENT_HALLWAY,
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    EAX_ENVIRONMENT_ALLEY,
+    EAX_ENVIRONMENT_FOREST,
+    EAX_ENVIRONMENT_CITY,
+    EAX_ENVIRONMENT_MOUNTAINS,
+    EAX_ENVIRONMENT_QUARRY,
+    EAX_ENVIRONMENT_PLAIN,
+    EAX_ENVIRONMENT_PARKINGLOT,
+    EAX_ENVIRONMENT_SEWERPIPE,
+    EAX_ENVIRONMENT_UNDERWATER,
+    EAX_ENVIRONMENT_DRUGGED,
+    EAX_ENVIRONMENT_DIZZY,
+    EAX_ENVIRONMENT_PSYCHOTIC,
+
+    EAX1_ENVIRONMENT_COUNT,
+
+    // EAX30
+    EAX_ENVIRONMENT_UNDEFINED = EAX1_ENVIRONMENT_COUNT,
+
+    EAX3_ENVIRONMENT_COUNT,
+};
+
+
+// reverberation decay time
+constexpr auto EAXREVERBFLAGS_DECAYTIMESCALE = 0x00000001UL;
+
+// reflection level
+constexpr auto EAXREVERBFLAGS_REFLECTIONSSCALE = 0x00000002UL;
+
+// initial reflection delay time
+constexpr auto EAXREVERBFLAGS_REFLECTIONSDELAYSCALE = 0x00000004UL;
+
+// reflections level
+constexpr auto EAXREVERBFLAGS_REVERBSCALE = 0x00000008UL;
+
+// late reverberation delay time
+constexpr auto EAXREVERBFLAGS_REVERBDELAYSCALE = 0x00000010UL;
+
+// echo time
+// EAX30+
+constexpr auto EAXREVERBFLAGS_ECHOTIMESCALE = 0x00000040UL;
+
+// modulation time
+// EAX30+
+constexpr auto EAXREVERBFLAGS_MODULATIONTIMESCALE = 0x00000080UL;
+
+// This flag limits high-frequency decay time according to air absorption.
+constexpr auto EAXREVERBFLAGS_DECAYHFLIMIT = 0x00000020UL;
+
+constexpr auto EAXREVERBFLAGS_RESERVED = 0xFFFFFF00UL; // reserved future use
+
+
+struct EAXREVERBPROPERTIES {
+    unsigned long ulEnvironment; // sets all reverb properties
+    float flEnvironmentSize; // environment size in meters
+    float flEnvironmentDiffusion; // environment diffusion
+    long lRoom; // room effect level (at mid frequencies)
+    long lRoomHF; // relative room effect level at high frequencies
+    long lRoomLF; // relative room effect level at low frequencies  
+    float flDecayTime; // reverberation decay time at mid frequencies
+    float flDecayHFRatio; // high-frequency to mid-frequency decay time ratio
+    float flDecayLFRatio; // low-frequency to mid-frequency decay time ratio   
+    long lReflections; // early reflections level relative to room effect
+    float flReflectionsDelay; // initial reflection delay time
+    EAXVECTOR vReflectionsPan; // early reflections panning vector
+    long lReverb; // late reverberation level relative to room effect
+    float flReverbDelay; // late reverberation delay time relative to initial reflection
+    EAXVECTOR vReverbPan; // late reverberation panning vector
+    float flEchoTime; // echo time
+    float flEchoDepth; // echo depth
+    float flModulationTime; // modulation time
+    float flModulationDepth; // modulation depth
+    float flAirAbsorptionHF; // change in level per meter at high frequencies
+    float flHFReference; // reference high frequency
+    float flLFReference; // reference low frequency 
+    float flRoomRolloffFactor; // like DS3D flRolloffFactor but for room effect
+    unsigned long ulFlags; // modifies the behavior of properties
+}; // EAXREVERBPROPERTIES
+
+
+constexpr auto EAXREVERB_MINENVIRONMENT = static_cast<unsigned long>(EAX_ENVIRONMENT_GENERIC);
+constexpr auto EAX1REVERB_MAXENVIRONMENT = static_cast<unsigned long>(EAX_ENVIRONMENT_PSYCHOTIC);
+constexpr auto EAX30REVERB_MAXENVIRONMENT = static_cast<unsigned long>(EAX_ENVIRONMENT_UNDEFINED);
+constexpr auto EAXREVERB_DEFAULTENVIRONMENT = static_cast<unsigned long>(EAX_ENVIRONMENT_GENERIC);
+
+constexpr auto EAXREVERB_MINENVIRONMENTSIZE = 1.0F;
+constexpr auto EAXREVERB_MAXENVIRONMENTSIZE = 100.0F;
+constexpr auto EAXREVERB_DEFAULTENVIRONMENTSIZE = 7.5F;
+
+constexpr auto EAXREVERB_MINENVIRONMENTDIFFUSION = 0.0F;
+constexpr auto EAXREVERB_MAXENVIRONMENTDIFFUSION = 1.0F;
+constexpr auto EAXREVERB_DEFAULTENVIRONMENTDIFFUSION = 1.0F;
+
+constexpr auto EAXREVERB_MINROOM = -10'000L;
+constexpr auto EAXREVERB_MAXROOM = 0L;
+constexpr auto EAXREVERB_DEFAULTROOM = -1'000L;
+
+constexpr auto EAXREVERB_MINROOMHF = -10'000L;
+constexpr auto EAXREVERB_MAXROOMHF = 0L;
+constexpr auto EAXREVERB_DEFAULTROOMHF = -100L;
+
+constexpr auto EAXREVERB_MINROOMLF = -10'000L;
+constexpr auto EAXREVERB_MAXROOMLF = 0L;
+constexpr auto EAXREVERB_DEFAULTROOMLF = 0L;
+
+constexpr auto EAXREVERB_MINDECAYTIME = 0.1F;
+constexpr auto EAXREVERB_MAXDECAYTIME = 20.0F;
+constexpr auto EAXREVERB_DEFAULTDECAYTIME = 1.49F;
+
+constexpr auto EAXREVERB_MINDECAYHFRATIO = 0.1F;
+constexpr auto EAXREVERB_MAXDECAYHFRATIO = 2.0F;
+constexpr auto EAXREVERB_DEFAULTDECAYHFRATIO = 0.83F;
+
+constexpr auto EAXREVERB_MINDECAYLFRATIO = 0.1F;
+constexpr auto EAXREVERB_MAXDECAYLFRATIO = 2.0F;
+constexpr auto EAXREVERB_DEFAULTDECAYLFRATIO = 1.0F;
+
+constexpr auto EAXREVERB_MINREFLECTIONS = -10'000L;
+constexpr auto EAXREVERB_MAXREFLECTIONS = 1'000L;
+constexpr auto EAXREVERB_DEFAULTREFLECTIONS = -2'602L;
+
+constexpr auto EAXREVERB_MINREFLECTIONSDELAY = 0.0F;
+constexpr auto EAXREVERB_MAXREFLECTIONSDELAY = 0.3F;
+constexpr auto EAXREVERB_DEFAULTREFLECTIONSDELAY = 0.007F;
+
+constexpr auto EAXREVERB_DEFAULTREFLECTIONSPAN = EAXVECTOR{0.0F, 0.0F, 0.0F};
+
+constexpr auto EAXREVERB_MINREVERB = -10'000L;
+constexpr auto EAXREVERB_MAXREVERB = 2'000L;
+constexpr auto EAXREVERB_DEFAULTREVERB = 200L;
+
+constexpr auto EAXREVERB_MINREVERBDELAY = 0.0F;
+constexpr auto EAXREVERB_MAXREVERBDELAY = 0.1F;
+constexpr auto EAXREVERB_DEFAULTREVERBDELAY = 0.011F;
+
+constexpr auto EAXREVERB_DEFAULTREVERBPAN = EAXVECTOR{0.0F, 0.0F, 0.0F};
+
+constexpr auto EAXREVERB_MINECHOTIME = 0.075F;
+constexpr auto EAXREVERB_MAXECHOTIME = 0.25F;
+constexpr auto EAXREVERB_DEFAULTECHOTIME = 0.25F;
+
+constexpr auto EAXREVERB_MINECHODEPTH = 0.0F;
+constexpr auto EAXREVERB_MAXECHODEPTH = 1.0F;
+constexpr auto EAXREVERB_DEFAULTECHODEPTH = 0.0F;
+
+constexpr auto EAXREVERB_MINMODULATIONTIME = 0.04F;
+constexpr auto EAXREVERB_MAXMODULATIONTIME = 4.0F;
+constexpr auto EAXREVERB_DEFAULTMODULATIONTIME = 0.25F;
+
+constexpr auto EAXREVERB_MINMODULATIONDEPTH = 0.0F;
+constexpr auto EAXREVERB_MAXMODULATIONDEPTH = 1.0F;
+constexpr auto EAXREVERB_DEFAULTMODULATIONDEPTH = 0.0F;
+
+constexpr auto EAXREVERB_MINAIRABSORPTIONHF = -100.0F;
+constexpr auto EAXREVERB_MAXAIRABSORPTIONHF = 0.0F;
+constexpr auto EAXREVERB_DEFAULTAIRABSORPTIONHF = -5.0F;
+
+constexpr auto EAXREVERB_MINHFREFERENCE = 1'000.0F;
+constexpr auto EAXREVERB_MAXHFREFERENCE = 20'000.0F;
+constexpr auto EAXREVERB_DEFAULTHFREFERENCE = 5'000.0F;
+
+constexpr auto EAXREVERB_MINLFREFERENCE = 20.0F;
+constexpr auto EAXREVERB_MAXLFREFERENCE = 1'000.0F;
+constexpr auto EAXREVERB_DEFAULTLFREFERENCE = 250.0F;
+
+constexpr auto EAXREVERB_MINROOMROLLOFFFACTOR = 0.0F;
+constexpr auto EAXREVERB_MAXROOMROLLOFFFACTOR = 10.0F;
+constexpr auto EAXREVERB_DEFAULTROOMROLLOFFFACTOR = 0.0F;
+
+constexpr auto EAX1REVERB_MINVOLUME = 0.0F;
+constexpr auto EAX1REVERB_MAXVOLUME = 1.0F;
+
+constexpr auto EAX1REVERB_MINDAMPING = 0.0F;
+constexpr auto EAX1REVERB_MAXDAMPING = 2.0F;
+
+constexpr auto EAXREVERB_DEFAULTFLAGS =
+    EAXREVERBFLAGS_DECAYTIMESCALE |
+    EAXREVERBFLAGS_REFLECTIONSSCALE |
+    EAXREVERBFLAGS_REFLECTIONSDELAYSCALE |
+    EAXREVERBFLAGS_REVERBSCALE |
+    EAXREVERBFLAGS_REVERBDELAYSCALE |
+    EAXREVERBFLAGS_DECAYHFLIMIT;
+
+
+using Eax1ReverbPresets = std::array<EAX_REVERBPROPERTIES, EAX1_ENVIRONMENT_COUNT>;
+extern const Eax1ReverbPresets EAX1REVERB_PRESETS;
+
+using Eax2ReverbPresets = std::array<EAX20LISTENERPROPERTIES, EAX2_ENVIRONMENT_COUNT>;
+extern const Eax2ReverbPresets EAX2REVERB_PRESETS;
+
+using EaxReverbPresets = std::array<EAXREVERBPROPERTIES, EAX1_ENVIRONMENT_COUNT>;
+extern const EaxReverbPresets EAXREVERB_PRESETS;
+
+
+// AGC Compressor Effect
+
+extern const GUID EAX_AGCCOMPRESSOR_EFFECT;
+
+enum EAXAGCCOMPRESSOR_PROPERTY : unsigned int {
+    EAXAGCCOMPRESSOR_NONE,
+    EAXAGCCOMPRESSOR_ALLPARAMETERS,
+    EAXAGCCOMPRESSOR_ONOFF,
+}; // EAXAGCCOMPRESSOR_PROPERTY
+
+struct EAXAGCCOMPRESSORPROPERTIES {
+    unsigned long ulOnOff; // Switch Compressor on or off
+}; // EAXAGCCOMPRESSORPROPERTIES
+
+
+constexpr auto EAXAGCCOMPRESSOR_MINONOFF = 0UL;
+constexpr auto EAXAGCCOMPRESSOR_MAXONOFF = 1UL;
+constexpr auto EAXAGCCOMPRESSOR_DEFAULTONOFF = EAXAGCCOMPRESSOR_MAXONOFF;
+
+
+// Autowah Effect
+
+extern const GUID EAX_AUTOWAH_EFFECT;
+
+enum EAXAUTOWAH_PROPERTY : unsigned int {
+    EAXAUTOWAH_NONE,
+    EAXAUTOWAH_ALLPARAMETERS,
+    EAXAUTOWAH_ATTACKTIME,
+    EAXAUTOWAH_RELEASETIME,
+    EAXAUTOWAH_RESONANCE,
+    EAXAUTOWAH_PEAKLEVEL,
+}; // EAXAUTOWAH_PROPERTY
+
+struct EAXAUTOWAHPROPERTIES {
+    float flAttackTime; // Attack time (seconds)
+    float flReleaseTime; // Release time (seconds)
+    long lResonance; // Resonance (mB)
+    long lPeakLevel; // Peak level (mB)
+}; // EAXAUTOWAHPROPERTIES
+
+
+constexpr auto EAXAUTOWAH_MINATTACKTIME = 0.0001F;
+constexpr auto EAXAUTOWAH_MAXATTACKTIME = 1.0F;
+constexpr auto EAXAUTOWAH_DEFAULTATTACKTIME = 0.06F;
+
+constexpr auto EAXAUTOWAH_MINRELEASETIME = 0.0001F;
+constexpr auto EAXAUTOWAH_MAXRELEASETIME = 1.0F;
+constexpr auto EAXAUTOWAH_DEFAULTRELEASETIME = 0.06F;
+
+constexpr auto EAXAUTOWAH_MINRESONANCE = 600L;
+constexpr auto EAXAUTOWAH_MAXRESONANCE = 6000L;
+constexpr auto EAXAUTOWAH_DEFAULTRESONANCE = 6000L;
+
+constexpr auto EAXAUTOWAH_MINPEAKLEVEL = -9000L;
+constexpr auto EAXAUTOWAH_MAXPEAKLEVEL = 9000L;
+constexpr auto EAXAUTOWAH_DEFAULTPEAKLEVEL = 2100L;
+
+
+// Chorus Effect
+
+extern const GUID EAX_CHORUS_EFFECT;
+
+enum EAXCHORUS_PROPERTY : unsigned int {
+    EAXCHORUS_NONE,
+    EAXCHORUS_ALLPARAMETERS,
+    EAXCHORUS_WAVEFORM,
+    EAXCHORUS_PHASE,
+    EAXCHORUS_RATE,
+    EAXCHORUS_DEPTH,
+    EAXCHORUS_FEEDBACK,
+    EAXCHORUS_DELAY,
+}; // EAXCHORUS_PROPERTY
+
+enum : unsigned long {
+    EAX_CHORUS_SINUSOID,
+    EAX_CHORUS_TRIANGLE,
+};
+
+struct EAXCHORUSPROPERTIES {
+    unsigned long ulWaveform; // Waveform selector - see enum above
+    long lPhase; // Phase (Degrees)
+    float flRate; // Rate (Hz)
+    float flDepth; // Depth (0 to 1)
+    float flFeedback; // Feedback (-1 to 1)
+    float flDelay; // Delay (seconds)
+}; // EAXCHORUSPROPERTIES
+
+
+constexpr auto EAXCHORUS_MINWAVEFORM = 0UL;
+constexpr auto EAXCHORUS_MAXWAVEFORM = 1UL;
+constexpr auto EAXCHORUS_DEFAULTWAVEFORM = 1UL;
+
+constexpr auto EAXCHORUS_MINPHASE = -180L;
+constexpr auto EAXCHORUS_MAXPHASE = 180L;
+constexpr auto EAXCHORUS_DEFAULTPHASE = 90L;
+
+constexpr auto EAXCHORUS_MINRATE = 0.0F;
+constexpr auto EAXCHORUS_MAXRATE = 10.0F;
+constexpr auto EAXCHORUS_DEFAULTRATE = 1.1F;
+
+constexpr auto EAXCHORUS_MINDEPTH = 0.0F;
+constexpr auto EAXCHORUS_MAXDEPTH = 1.0F;
+constexpr auto EAXCHORUS_DEFAULTDEPTH = 0.1F;
+
+constexpr auto EAXCHORUS_MINFEEDBACK = -1.0F;
+constexpr auto EAXCHORUS_MAXFEEDBACK = 1.0F;
+constexpr auto EAXCHORUS_DEFAULTFEEDBACK = 0.25F;
+
+constexpr auto EAXCHORUS_MINDELAY = 0.0002F;
+constexpr auto EAXCHORUS_MAXDELAY = 0.016F;
+constexpr auto EAXCHORUS_DEFAULTDELAY = 0.016F;
+
+
+// Distortion Effect
+
+extern const GUID EAX_DISTORTION_EFFECT;
+
+enum EAXDISTORTION_PROPERTY : unsigned int {
+    EAXDISTORTION_NONE,
+    EAXDISTORTION_ALLPARAMETERS,
+    EAXDISTORTION_EDGE,
+    EAXDISTORTION_GAIN,
+    EAXDISTORTION_LOWPASSCUTOFF,
+    EAXDISTORTION_EQCENTER,
+    EAXDISTORTION_EQBANDWIDTH,
+}; // EAXDISTORTION_PROPERTY
+
+struct EAXDISTORTIONPROPERTIES {
+    float flEdge; // Controls the shape of the distortion (0 to 1)
+    long lGain; // Controls the post distortion gain (mB)
+    float flLowPassCutOff; // Controls the cut-off of the filter pre-distortion (Hz)
+    float flEQCenter; // Controls the center frequency of the EQ post-distortion (Hz)
+    float flEQBandwidth; // Controls the bandwidth of the EQ post-distortion (Hz)
+}; // EAXDISTORTIONPROPERTIES
+
+
+constexpr auto EAXDISTORTION_MINEDGE = 0.0F;
+constexpr auto EAXDISTORTION_MAXEDGE = 1.0F;
+constexpr auto EAXDISTORTION_DEFAULTEDGE = 0.2F;
+
+constexpr auto EAXDISTORTION_MINGAIN = -6000L;
+constexpr auto EAXDISTORTION_MAXGAIN = 0L;
+constexpr auto EAXDISTORTION_DEFAULTGAIN = -2600L;
+
+constexpr auto EAXDISTORTION_MINLOWPASSCUTOFF = 80.0F;
+constexpr auto EAXDISTORTION_MAXLOWPASSCUTOFF = 24000.0F;
+constexpr auto EAXDISTORTION_DEFAULTLOWPASSCUTOFF = 8000.0F;
+
+constexpr auto EAXDISTORTION_MINEQCENTER = 80.0F;
+constexpr auto EAXDISTORTION_MAXEQCENTER = 24000.0F;
+constexpr auto EAXDISTORTION_DEFAULTEQCENTER = 3600.0F;
+
+constexpr auto EAXDISTORTION_MINEQBANDWIDTH = 80.0F;
+constexpr auto EAXDISTORTION_MAXEQBANDWIDTH = 24000.0F;
+constexpr auto EAXDISTORTION_DEFAULTEQBANDWIDTH = 3600.0F;
+
+
+// Echo Effect
+
+extern const GUID EAX_ECHO_EFFECT;
+
+enum EAXECHO_PROPERTY : unsigned int {
+    EAXECHO_NONE,
+    EAXECHO_ALLPARAMETERS,
+    EAXECHO_DELAY,
+    EAXECHO_LRDELAY,
+    EAXECHO_DAMPING,
+    EAXECHO_FEEDBACK,
+    EAXECHO_SPREAD,
+}; // EAXECHO_PROPERTY
+
+struct EAXECHOPROPERTIES {
+    float flDelay; // Controls the initial delay time (seconds)
+    float flLRDelay; // Controls the delay time between the first and second taps (seconds)
+    float flDamping; // Controls a low-pass filter that dampens the echoes (0 to 1)
+    float flFeedback; // Controls the duration of echo repetition (0 to 1)
+    float flSpread; // Controls the left-right spread of the echoes
+}; // EAXECHOPROPERTIES
+
+
+constexpr auto EAXECHO_MINDAMPING = 0.0F;
+constexpr auto EAXECHO_MAXDAMPING = 0.99F;
+constexpr auto EAXECHO_DEFAULTDAMPING = 0.5F;
+
+constexpr auto EAXECHO_MINDELAY = 0.002F;
+constexpr auto EAXECHO_MAXDELAY = 0.207F;
+constexpr auto EAXECHO_DEFAULTDELAY = 0.1F;
+
+constexpr auto EAXECHO_MINLRDELAY = 0.0F;
+constexpr auto EAXECHO_MAXLRDELAY = 0.404F;
+constexpr auto EAXECHO_DEFAULTLRDELAY = 0.1F;
+
+constexpr auto EAXECHO_MINFEEDBACK = 0.0F;
+constexpr auto EAXECHO_MAXFEEDBACK = 1.0F;
+constexpr auto EAXECHO_DEFAULTFEEDBACK = 0.5F;
+
+constexpr auto EAXECHO_MINSPREAD = -1.0F;
+constexpr auto EAXECHO_MAXSPREAD = 1.0F;
+constexpr auto EAXECHO_DEFAULTSPREAD = -1.0F;
+
+
+// Equalizer Effect
+
+extern const GUID EAX_EQUALIZER_EFFECT;
+
+enum EAXEQUALIZER_PROPERTY : unsigned int {
+    EAXEQUALIZER_NONE,
+    EAXEQUALIZER_ALLPARAMETERS,
+    EAXEQUALIZER_LOWGAIN,
+    EAXEQUALIZER_LOWCUTOFF,
+    EAXEQUALIZER_MID1GAIN,
+    EAXEQUALIZER_MID1CENTER,
+    EAXEQUALIZER_MID1WIDTH,
+    EAXEQUALIZER_MID2GAIN,
+    EAXEQUALIZER_MID2CENTER,
+    EAXEQUALIZER_MID2WIDTH,
+    EAXEQUALIZER_HIGHGAIN,
+    EAXEQUALIZER_HIGHCUTOFF,
+}; // EAXEQUALIZER_PROPERTY
+
+struct EAXEQUALIZERPROPERTIES {
+    long lLowGain; // (mB)
+    float flLowCutOff; // (Hz)
+    long lMid1Gain; // (mB)
+    float flMid1Center; // (Hz)
+    float flMid1Width; // (octaves)
+    long lMid2Gain; // (mB)
+    float flMid2Center; // (Hz)
+    float flMid2Width; // (octaves)
+    long lHighGain; // (mB)
+    float flHighCutOff; // (Hz)
+}; // EAXEQUALIZERPROPERTIES
+
+
+constexpr auto EAXEQUALIZER_MINLOWGAIN = -1800L;
+constexpr auto EAXEQUALIZER_MAXLOWGAIN = 1800L;
+constexpr auto EAXEQUALIZER_DEFAULTLOWGAIN = 0L;
+
+constexpr auto EAXEQUALIZER_MINLOWCUTOFF = 50.0F;
+constexpr auto EAXEQUALIZER_MAXLOWCUTOFF = 800.0F;
+constexpr auto EAXEQUALIZER_DEFAULTLOWCUTOFF = 200.0F;
+
+constexpr auto EAXEQUALIZER_MINMID1GAIN = -1800L;
+constexpr auto EAXEQUALIZER_MAXMID1GAIN = 1800L;
+constexpr auto EAXEQUALIZER_DEFAULTMID1GAIN = 0L;
+
+constexpr auto EAXEQUALIZER_MINMID1CENTER = 200.0F;
+constexpr auto EAXEQUALIZER_MAXMID1CENTER = 3000.0F;
+constexpr auto EAXEQUALIZER_DEFAULTMID1CENTER = 500.0F;
+
+constexpr auto EAXEQUALIZER_MINMID1WIDTH = 0.01F;
+constexpr auto EAXEQUALIZER_MAXMID1WIDTH = 1.0F;
+constexpr auto EAXEQUALIZER_DEFAULTMID1WIDTH = 1.0F;
+
+constexpr auto EAXEQUALIZER_MINMID2GAIN = -1800L;
+constexpr auto EAXEQUALIZER_MAXMID2GAIN = 1800L;
+constexpr auto EAXEQUALIZER_DEFAULTMID2GAIN = 0L;
+
+constexpr auto EAXEQUALIZER_MINMID2CENTER = 1000.0F;
+constexpr auto EAXEQUALIZER_MAXMID2CENTER = 8000.0F;
+constexpr auto EAXEQUALIZER_DEFAULTMID2CENTER = 3000.0F;
+
+constexpr auto EAXEQUALIZER_MINMID2WIDTH = 0.01F;
+constexpr auto EAXEQUALIZER_MAXMID2WIDTH = 1.0F;
+constexpr auto EAXEQUALIZER_DEFAULTMID2WIDTH = 1.0F;
+
+constexpr auto EAXEQUALIZER_MINHIGHGAIN = -1800L;
+constexpr auto EAXEQUALIZER_MAXHIGHGAIN = 1800L;
+constexpr auto EAXEQUALIZER_DEFAULTHIGHGAIN = 0L;
+
+constexpr auto EAXEQUALIZER_MINHIGHCUTOFF = 4000.0F;
+constexpr auto EAXEQUALIZER_MAXHIGHCUTOFF = 16000.0F;
+constexpr auto EAXEQUALIZER_DEFAULTHIGHCUTOFF = 6000.0F;
+
+
+// Flanger Effect
+
+extern const GUID EAX_FLANGER_EFFECT;
+
+enum EAXFLANGER_PROPERTY : unsigned int {
+    EAXFLANGER_NONE,
+    EAXFLANGER_ALLPARAMETERS,
+    EAXFLANGER_WAVEFORM,
+    EAXFLANGER_PHASE,
+    EAXFLANGER_RATE,
+    EAXFLANGER_DEPTH,
+    EAXFLANGER_FEEDBACK,
+    EAXFLANGER_DELAY,
+}; // EAXFLANGER_PROPERTY
+
+enum : unsigned long {
+    EAX_FLANGER_SINUSOID,
+    EAX_FLANGER_TRIANGLE,
+};
+
+struct EAXFLANGERPROPERTIES {
+    unsigned long ulWaveform; // Waveform selector - see enum above
+    long lPhase; // Phase (Degrees)
+    float flRate; // Rate (Hz)
+    float flDepth; // Depth (0 to 1)
+    float flFeedback; // Feedback (0 to 1)
+    float flDelay; // Delay (seconds)
+}; // EAXFLANGERPROPERTIES
+
+
+constexpr auto EAXFLANGER_MINWAVEFORM = 0UL;
+constexpr auto EAXFLANGER_MAXWAVEFORM = 1UL;
+constexpr auto EAXFLANGER_DEFAULTWAVEFORM = 1UL;
+
+constexpr auto EAXFLANGER_MINPHASE = -180L;
+constexpr auto EAXFLANGER_MAXPHASE = 180L;
+constexpr auto EAXFLANGER_DEFAULTPHASE = 0L;
+
+constexpr auto EAXFLANGER_MINRATE = 0.0F;
+constexpr auto EAXFLANGER_MAXRATE = 10.0F;
+constexpr auto EAXFLANGER_DEFAULTRATE = 0.27F;
+
+constexpr auto EAXFLANGER_MINDEPTH = 0.0F;
+constexpr auto EAXFLANGER_MAXDEPTH = 1.0F;
+constexpr auto EAXFLANGER_DEFAULTDEPTH = 1.0F;
+
+constexpr auto EAXFLANGER_MINFEEDBACK = -1.0F;
+constexpr auto EAXFLANGER_MAXFEEDBACK = 1.0F;
+constexpr auto EAXFLANGER_DEFAULTFEEDBACK = -0.5F;
+
+constexpr auto EAXFLANGER_MINDELAY = 0.0002F;
+constexpr auto EAXFLANGER_MAXDELAY = 0.004F;
+constexpr auto EAXFLANGER_DEFAULTDELAY = 0.002F;
+
+
+// Frequency Shifter Effect
+
+extern const GUID EAX_FREQUENCYSHIFTER_EFFECT;
+
+enum EAXFREQUENCYSHIFTER_PROPERTY : unsigned int {
+    EAXFREQUENCYSHIFTER_NONE,
+    EAXFREQUENCYSHIFTER_ALLPARAMETERS,
+    EAXFREQUENCYSHIFTER_FREQUENCY,
+    EAXFREQUENCYSHIFTER_LEFTDIRECTION,
+    EAXFREQUENCYSHIFTER_RIGHTDIRECTION,
+}; // EAXFREQUENCYSHIFTER_PROPERTY
+
+enum : unsigned long {
+    EAX_FREQUENCYSHIFTER_DOWN,
+    EAX_FREQUENCYSHIFTER_UP,
+    EAX_FREQUENCYSHIFTER_OFF
+};
+
+struct EAXFREQUENCYSHIFTERPROPERTIES {
+    float flFrequency; // (Hz)
+    unsigned long ulLeftDirection; // see enum above
+    unsigned long ulRightDirection; // see enum above
+}; // EAXFREQUENCYSHIFTERPROPERTIES
+
+
+constexpr auto EAXFREQUENCYSHIFTER_MINFREQUENCY = 0.0F;
+constexpr auto EAXFREQUENCYSHIFTER_MAXFREQUENCY = 24000.0F;
+constexpr auto EAXFREQUENCYSHIFTER_DEFAULTFREQUENCY = EAXFREQUENCYSHIFTER_MINFREQUENCY;
+
+constexpr auto EAXFREQUENCYSHIFTER_MINLEFTDIRECTION = 0UL;
+constexpr auto EAXFREQUENCYSHIFTER_MAXLEFTDIRECTION = 2UL;
+constexpr auto EAXFREQUENCYSHIFTER_DEFAULTLEFTDIRECTION = EAXFREQUENCYSHIFTER_MINLEFTDIRECTION;
+
+constexpr auto EAXFREQUENCYSHIFTER_MINRIGHTDIRECTION = 0UL;
+constexpr auto EAXFREQUENCYSHIFTER_MAXRIGHTDIRECTION = 2UL;
+constexpr auto EAXFREQUENCYSHIFTER_DEFAULTRIGHTDIRECTION = EAXFREQUENCYSHIFTER_MINRIGHTDIRECTION;
+
+
+// Vocal Morpher Effect
+
+extern const GUID EAX_VOCALMORPHER_EFFECT;
+
+enum EAXVOCALMORPHER_PROPERTY : unsigned int {
+    EAXVOCALMORPHER_NONE,
+    EAXVOCALMORPHER_ALLPARAMETERS,
+    EAXVOCALMORPHER_PHONEMEA,
+    EAXVOCALMORPHER_PHONEMEACOARSETUNING,
+    EAXVOCALMORPHER_PHONEMEB,
+    EAXVOCALMORPHER_PHONEMEBCOARSETUNING,
+    EAXVOCALMORPHER_WAVEFORM,
+    EAXVOCALMORPHER_RATE,
+}; // EAXVOCALMORPHER_PROPERTY
+
+enum : unsigned long {
+    A,
+    E,
+    I,
+    O,
+    U,
+    AA,
+    AE,
+    AH,
+    AO,
+    EH,
+    ER,
+    IH,
+    IY,
+    UH,
+    UW,
+    B,
+    D,
+    F,
+    G,
+    J,
+    K,
+    L,
+    M,
+    N,
+    P,
+    R,
+    S,
+    T,
+    V,
+    Z,
+};
+
+enum : unsigned long {
+    EAX_VOCALMORPHER_SINUSOID,
+    EAX_VOCALMORPHER_TRIANGLE,
+    EAX_VOCALMORPHER_SAWTOOTH
+};
+
+// Use this structure for EAXVOCALMORPHER_ALLPARAMETERS
+struct EAXVOCALMORPHERPROPERTIES {
+    unsigned long ulPhonemeA; // see enum above
+    long lPhonemeACoarseTuning; // (semitones)
+    unsigned long ulPhonemeB; // see enum above
+    long lPhonemeBCoarseTuning; // (semitones)
+    unsigned long ulWaveform; // Waveform selector - see enum above
+    float flRate; // (Hz)
+}; // EAXVOCALMORPHERPROPERTIES
+
+
+constexpr auto EAXVOCALMORPHER_MINPHONEMEA = 0UL;
+constexpr auto EAXVOCALMORPHER_MAXPHONEMEA = 29UL;
+constexpr auto EAXVOCALMORPHER_DEFAULTPHONEMEA = EAXVOCALMORPHER_MINPHONEMEA;
+
+constexpr auto EAXVOCALMORPHER_MINPHONEMEACOARSETUNING = -24L;
+constexpr auto EAXVOCALMORPHER_MAXPHONEMEACOARSETUNING = 24L;
+constexpr auto EAXVOCALMORPHER_DEFAULTPHONEMEACOARSETUNING = 0L;
+
+constexpr auto EAXVOCALMORPHER_MINPHONEMEB = 0UL;
+constexpr auto EAXVOCALMORPHER_MAXPHONEMEB = 29UL;
+constexpr auto EAXVOCALMORPHER_DEFAULTPHONEMEB = 10UL;
+
+constexpr auto EAXVOCALMORPHER_MINPHONEMEBCOARSETUNING = -24L;
+constexpr auto EAXVOCALMORPHER_MAXPHONEMEBCOARSETUNING = 24L;
+constexpr auto EAXVOCALMORPHER_DEFAULTPHONEMEBCOARSETUNING = 0L;
+
+constexpr auto EAXVOCALMORPHER_MINWAVEFORM = 0UL;
+constexpr auto EAXVOCALMORPHER_MAXWAVEFORM = 2UL;
+constexpr auto EAXVOCALMORPHER_DEFAULTWAVEFORM = EAXVOCALMORPHER_MINWAVEFORM;
+
+constexpr auto EAXVOCALMORPHER_MINRATE = 0.0F;
+constexpr auto EAXVOCALMORPHER_MAXRATE = 10.0F;
+constexpr auto EAXVOCALMORPHER_DEFAULTRATE = 1.41F;
+
+
+// Pitch Shifter Effect
+
+extern const GUID EAX_PITCHSHIFTER_EFFECT;
+
+enum EAXPITCHSHIFTER_PROPERTY : unsigned int {
+    EAXPITCHSHIFTER_NONE,
+    EAXPITCHSHIFTER_ALLPARAMETERS,
+    EAXPITCHSHIFTER_COARSETUNE,
+    EAXPITCHSHIFTER_FINETUNE,
+}; // EAXPITCHSHIFTER_PROPERTY
+
+struct EAXPITCHSHIFTERPROPERTIES {
+    long lCoarseTune; // Amount of pitch shift (semitones)
+    long lFineTune; // Amount of pitch shift (cents)
+}; // EAXPITCHSHIFTERPROPERTIES
+
+
+constexpr auto EAXPITCHSHIFTER_MINCOARSETUNE = -12L;
+constexpr auto EAXPITCHSHIFTER_MAXCOARSETUNE = 12L;
+constexpr auto EAXPITCHSHIFTER_DEFAULTCOARSETUNE = 12L;
+
+constexpr auto EAXPITCHSHIFTER_MINFINETUNE = -50L;
+constexpr auto EAXPITCHSHIFTER_MAXFINETUNE = 50L;
+constexpr auto EAXPITCHSHIFTER_DEFAULTFINETUNE = 0L;
+
+
+// Ring Modulator Effect
+
+extern const GUID EAX_RINGMODULATOR_EFFECT;
+
+enum EAXRINGMODULATOR_PROPERTY : unsigned int {
+    EAXRINGMODULATOR_NONE,
+    EAXRINGMODULATOR_ALLPARAMETERS,
+    EAXRINGMODULATOR_FREQUENCY,
+    EAXRINGMODULATOR_HIGHPASSCUTOFF,
+    EAXRINGMODULATOR_WAVEFORM,
+}; // EAXRINGMODULATOR_PROPERTY
+
+enum : unsigned long {
+    EAX_RINGMODULATOR_SINUSOID,
+    EAX_RINGMODULATOR_SAWTOOTH,
+    EAX_RINGMODULATOR_SQUARE,
+};
+
+// Use this structure for EAXRINGMODULATOR_ALLPARAMETERS
+struct EAXRINGMODULATORPROPERTIES {
+    float flFrequency; // Frequency of modulation (Hz)
+    float flHighPassCutOff; // Cut-off frequency of high-pass filter (Hz)
+    unsigned long ulWaveform; // Waveform selector - see enum above
+}; // EAXRINGMODULATORPROPERTIES
+
+
+constexpr auto EAXRINGMODULATOR_MINFREQUENCY = 0.0F;
+constexpr auto EAXRINGMODULATOR_MAXFREQUENCY = 8000.0F;
+constexpr auto EAXRINGMODULATOR_DEFAULTFREQUENCY = 440.0F;
+
+constexpr auto EAXRINGMODULATOR_MINHIGHPASSCUTOFF = 0.0F;
+constexpr auto EAXRINGMODULATOR_MAXHIGHPASSCUTOFF = 24000.0F;
+constexpr auto EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF = 800.0F;
+
+constexpr auto EAXRINGMODULATOR_MINWAVEFORM = 0UL;
+constexpr auto EAXRINGMODULATOR_MAXWAVEFORM = 2UL;
+constexpr auto EAXRINGMODULATOR_DEFAULTWAVEFORM = EAXRINGMODULATOR_MINWAVEFORM;
+
+
+using LPEAXSET = ALenum(AL_APIENTRY*)(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_buffer,
+    ALuint property_size);
+
+using LPEAXGET = ALenum(AL_APIENTRY*)(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_buffer,
+    ALuint property_size);
+
+#endif // !EAX_API_INCLUDED
diff --git a/al/eax/call.cpp b/al/eax/call.cpp
new file mode 100644
index 00000000..689d5cf1
--- /dev/null
+++ b/al/eax/call.cpp
@@ -0,0 +1,219 @@
+#include "config.h"
+#include "call.h"
+#include "exception.h"
+
+namespace {
+
+constexpr auto deferred_flag = 0x80000000U;
+
+class EaxCallException : public EaxException {
+public:
+    explicit EaxCallException(const char* message)
+        : EaxException{"EAX_CALL", message}
+    {}
+}; // EaxCallException
+
+} // namespace
+
+EaxCall::EaxCall(
+    EaxCallType type,
+    const GUID& property_set_guid,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_buffer,
+    ALuint property_size)
+    : mCallType{type}, mVersion{0}, mPropertySetId{EaxCallPropertySetId::none}
+    , mIsDeferred{(property_id & deferred_flag) != 0}
+    , mPropertyId{property_id & ~deferred_flag}, mPropertySourceId{property_source_id}
+    , mPropertyBuffer{property_buffer}, mPropertyBufferSize{property_size}
+{
+    switch(mCallType)
+    {
+        case EaxCallType::get:
+        case EaxCallType::set:
+            break;
+
+        default:
+            fail("Invalid type.");
+    }
+
+    if (false)
+    {
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_Context)
+    {
+        mVersion = 4;
+        mPropertySetId = EaxCallPropertySetId::context;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_Context)
+    {
+        mVersion = 5;
+        mPropertySetId = EaxCallPropertySetId::context;
+    }
+    else if (property_set_guid == DSPROPSETID_EAX20_ListenerProperties)
+    {
+        mVersion = 2;
+        mFxSlotIndex = 0u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot_effect;
+    }
+    else if (property_set_guid == DSPROPSETID_EAX30_ListenerProperties)
+    {
+        mVersion = 3;
+        mFxSlotIndex = 0u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot_effect;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_FXSlot0)
+    {
+        mVersion = 4;
+        mFxSlotIndex = 0u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_FXSlot0)
+    {
+        mVersion = 5;
+        mFxSlotIndex = 0u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_FXSlot1)
+    {
+        mVersion = 4;
+        mFxSlotIndex = 1u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_FXSlot1)
+    {
+        mVersion = 5;
+        mFxSlotIndex = 1u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_FXSlot2)
+    {
+        mVersion = 4;
+        mFxSlotIndex = 2u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_FXSlot2)
+    {
+        mVersion = 5;
+        mFxSlotIndex = 2u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_FXSlot3)
+    {
+        mVersion = 4;
+        mFxSlotIndex = 3u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_FXSlot3)
+    {
+        mVersion = 5;
+        mFxSlotIndex = 3u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot;
+    }
+    else if (property_set_guid == DSPROPSETID_EAX20_BufferProperties)
+    {
+        mVersion = 2;
+        mPropertySetId = EaxCallPropertySetId::source;
+    }
+    else if (property_set_guid == DSPROPSETID_EAX30_BufferProperties)
+    {
+        mVersion = 3;
+        mPropertySetId = EaxCallPropertySetId::source;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX40_Source)
+    {
+        mVersion = 4;
+        mPropertySetId = EaxCallPropertySetId::source;
+    }
+    else if (property_set_guid == EAXPROPERTYID_EAX50_Source)
+    {
+        mVersion = 5;
+        mPropertySetId = EaxCallPropertySetId::source;
+    }
+    else if (property_set_guid == DSPROPSETID_EAX_ReverbProperties)
+    {
+        mVersion = 1;
+        mFxSlotIndex = 0u;
+        mPropertySetId = EaxCallPropertySetId::fx_slot_effect;
+    }
+    else if (property_set_guid == DSPROPSETID_EAXBUFFER_ReverbProperties)
+    {
+        mVersion = 1;
+        mPropertySetId = EaxCallPropertySetId::source;
+    }
+    else
+    {
+        fail("Unsupported property set id.");
+    }
+
+    switch(mPropertyId)
+    {
+    case EAXCONTEXT_LASTERROR:
+    case EAXCONTEXT_SPEAKERCONFIG:
+    case EAXCONTEXT_EAXSESSION:
+    case EAXFXSLOT_NONE:
+    case EAXFXSLOT_ALLPARAMETERS:
+    case EAXFXSLOT_LOADEFFECT:
+    case EAXFXSLOT_VOLUME:
+    case EAXFXSLOT_LOCK:
+    case EAXFXSLOT_FLAGS:
+    case EAXFXSLOT_OCCLUSION:
+    case EAXFXSLOT_OCCLUSIONLFRATIO:
+        // EAX allow to set "defer" flag on immediate-only properties.
+        // If we don't clear our flag then "applyAllUpdates" in EAX context won't be called.
+        mIsDeferred = false;
+        break;
+    }
+
+    if(!mIsDeferred)
+    {
+        if(mPropertySetId != EaxCallPropertySetId::fx_slot && mPropertyId != 0)
+        {
+            if(mPropertyBuffer == nullptr)
+                fail("Null property buffer.");
+
+            if(mPropertyBufferSize == 0)
+                fail("Empty property.");
+        }
+    }
+
+    if(mPropertySetId == EaxCallPropertySetId::source && mPropertySourceId == 0)
+        fail("Null AL source id.");
+
+    if(mPropertySetId == EaxCallPropertySetId::fx_slot)
+    {
+        if(mPropertyId < EAXFXSLOT_NONE)
+            mPropertySetId = EaxCallPropertySetId::fx_slot_effect;
+    }
+}
+
+[[noreturn]] void EaxCall::fail(const char* message)
+{
+    throw EaxCallException{message};
+}
+
+[[noreturn]] void EaxCall::fail_too_small()
+{
+    fail("Property buffer too small.");
+}
+
+EaxCall create_eax_call(
+    EaxCallType type,
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_buffer,
+    ALuint property_size)
+{
+    if(!property_set_id)
+        throw EaxCallException{"Null property set ID."};
+
+    return EaxCall{
+        type,
+        *property_set_id,
+        property_id,
+        property_source_id,
+        property_buffer,
+        property_size
+    };
+}
diff --git a/al/eax/call.h b/al/eax/call.h
new file mode 100644
index 00000000..5ec33b0f
--- /dev/null
+++ b/al/eax/call.h
@@ -0,0 +1,97 @@
+#ifndef EAX_EAX_CALL_INCLUDED
+#define EAX_EAX_CALL_INCLUDED
+
+#include "AL/al.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "api.h"
+#include "fx_slot_index.h"
+
+enum class EaxCallType {
+    none,
+    get,
+    set,
+}; // EaxCallType
+
+enum class EaxCallPropertySetId {
+    none,
+    context,
+    fx_slot,
+    source,
+    fx_slot_effect,
+}; // EaxCallPropertySetId
+
+class EaxCall {
+public:
+    EaxCall(
+        EaxCallType type,
+        const GUID& property_set_guid,
+        ALuint property_id,
+        ALuint property_source_id,
+        ALvoid* property_buffer,
+        ALuint property_size);
+
+    bool is_get() const noexcept { return mCallType == EaxCallType::get; }
+    bool is_deferred() const noexcept { return mIsDeferred; }
+    int get_version() const noexcept { return mVersion; }
+    EaxCallPropertySetId get_property_set_id() const noexcept { return mPropertySetId; }
+    ALuint get_property_id() const noexcept { return mPropertyId; }
+    ALuint get_property_al_name() const noexcept { return mPropertySourceId; }
+    EaxFxSlotIndex get_fx_slot_index() const noexcept { return mFxSlotIndex; }
+
+    template<typename TException, typename TValue>
+    TValue& get_value() const
+    {
+        if(mPropertyBufferSize < sizeof(TValue))
+            fail_too_small();
+
+        return *static_cast<TValue*>(mPropertyBuffer);
+    }
+
+    template<typename TValue>
+    al::span<TValue> get_values(size_t max_count) const
+    {
+        if(max_count == 0 || mPropertyBufferSize < sizeof(TValue))
+            fail_too_small();
+
+        const auto count = minz(mPropertyBufferSize / sizeof(TValue), max_count);
+        return al::as_span(static_cast<TValue*>(mPropertyBuffer), count);
+    }
+
+    template<typename TValue>
+    al::span<TValue> get_values() const
+    {
+        return get_values<TValue>(~size_t{});
+    }
+
+    template<typename TException, typename TValue>
+    void set_value(const TValue& value) const
+    {
+        get_value<TException, TValue>() = value;
+    }
+
+private:
+    const EaxCallType mCallType;
+    int mVersion;
+    EaxFxSlotIndex mFxSlotIndex;
+    EaxCallPropertySetId mPropertySetId;
+    bool mIsDeferred;
+
+    const ALuint mPropertyId;
+    const ALuint mPropertySourceId;
+    ALvoid*const mPropertyBuffer;
+    const ALuint mPropertyBufferSize;
+
+    [[noreturn]] static void fail(const char* message);
+    [[noreturn]] static void fail_too_small();
+}; // EaxCall
+
+EaxCall create_eax_call(
+    EaxCallType type,
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_buffer,
+    ALuint property_size);
+
+#endif // !EAX_EAX_CALL_INCLUDED
diff --git a/al/eax/effect.h b/al/eax/effect.h
new file mode 100644
index 00000000..a0b4e71b
--- /dev/null
+++ b/al/eax/effect.h
@@ -0,0 +1,418 @@
+#ifndef EAX_EFFECT_INCLUDED
+#define EAX_EFFECT_INCLUDED
+
+
+#include <cassert>
+#include <memory>
+
+#include "alnumeric.h"
+#include "AL/al.h"
+#include "core/effects/base.h"
+#include "call.h"
+
+struct EaxEffectErrorMessages
+{
+    static constexpr auto unknown_property_id() noexcept { return "Unknown property id."; }
+    static constexpr auto unknown_version() noexcept { return "Unknown version."; }
+}; // EaxEffectErrorMessages
+
+/* TODO: Use std::variant (C++17). */
+enum class EaxEffectType {
+    None, Reverb, Chorus, Autowah, Compressor, Distortion, Echo, Equalizer, Flanger,
+    FrequencyShifter, Modulator, PitchShifter, VocalMorpher
+};
+struct EaxEffectProps {
+    EaxEffectType mType;
+    union {
+        EAXREVERBPROPERTIES mReverb;
+        EAXCHORUSPROPERTIES mChorus;
+        EAXAUTOWAHPROPERTIES mAutowah;
+        EAXAGCCOMPRESSORPROPERTIES mCompressor;
+        EAXDISTORTIONPROPERTIES mDistortion;
+        EAXECHOPROPERTIES mEcho;
+        EAXEQUALIZERPROPERTIES mEqualizer;
+        EAXFLANGERPROPERTIES mFlanger;
+        EAXFREQUENCYSHIFTERPROPERTIES mFrequencyShifter;
+        EAXRINGMODULATORPROPERTIES mModulator;
+        EAXPITCHSHIFTERPROPERTIES mPitchShifter;
+        EAXVOCALMORPHERPROPERTIES mVocalMorpher;
+    };
+};
+
+constexpr ALenum EnumFromEaxEffectType(const EaxEffectProps &props)
+{
+    switch(props.mType)
+    {
+    case EaxEffectType::None: break;
+    case EaxEffectType::Reverb: return AL_EFFECT_EAXREVERB;
+    case EaxEffectType::Chorus: return AL_EFFECT_CHORUS;
+    case EaxEffectType::Autowah: return AL_EFFECT_AUTOWAH;
+    case EaxEffectType::Compressor: return AL_EFFECT_COMPRESSOR;
+    case EaxEffectType::Distortion: return AL_EFFECT_DISTORTION;
+    case EaxEffectType::Echo: return AL_EFFECT_ECHO;
+    case EaxEffectType::Equalizer: return AL_EFFECT_EQUALIZER;
+    case EaxEffectType::Flanger: return AL_EFFECT_FLANGER;
+    case EaxEffectType::FrequencyShifter: return AL_EFFECT_FREQUENCY_SHIFTER;
+    case EaxEffectType::Modulator: return AL_EFFECT_RING_MODULATOR;
+    case EaxEffectType::PitchShifter: return AL_EFFECT_PITCH_SHIFTER;
+    case EaxEffectType::VocalMorpher: return AL_EFFECT_VOCAL_MORPHER;
+    }
+    return AL_EFFECT_NULL;
+}
+
+struct EaxReverbCommitter {
+    struct Exception;
+
+    EaxReverbCommitter(EaxEffectProps &eaxprops, EffectProps &alprops)
+        : mEaxProps{eaxprops}, mAlProps{alprops}
+    { }
+
+    EaxEffectProps &mEaxProps;
+    EffectProps &mAlProps;
+
+    [[noreturn]] static void fail(const char* message);
+    [[noreturn]] static void fail_unknown_property_id()
+    { fail(EaxEffectErrorMessages::unknown_property_id()); }
+
+    template<typename TValidator, typename TProperty>
+    static void defer(const EaxCall& call, TProperty& property)
+    {
+        const auto& value = call.get_value<Exception, const TProperty>();
+        TValidator{}(value);
+        property = value;
+    }
+
+    template<typename TValidator, typename TDeferrer, typename TProperties, typename TProperty>
+    static void defer(const EaxCall& call, TProperties& properties, TProperty&)
+    {
+        const auto& value = call.get_value<Exception, const TProperty>();
+        TValidator{}(value);
+        TDeferrer{}(properties, value);
+    }
+
+    template<typename TValidator, typename TProperty>
+    static void defer3(const EaxCall& call, EAXREVERBPROPERTIES& properties, TProperty& property)
+    {
+        const auto& value = call.get_value<Exception, const TProperty>();
+        TValidator{}(value);
+        if (value == property)
+            return;
+        property = value;
+        properties.ulEnvironment = EAX_ENVIRONMENT_UNDEFINED;
+    }
+
+
+    bool commit(const EAX_REVERBPROPERTIES &props);
+    bool commit(const EAX20LISTENERPROPERTIES &props);
+    bool commit(const EAXREVERBPROPERTIES &props);
+    bool commit(const EaxEffectProps &props);
+
+    static void SetDefaults(EAX_REVERBPROPERTIES &props);
+    static void SetDefaults(EAX20LISTENERPROPERTIES &props);
+    static void SetDefaults(EAXREVERBPROPERTIES &props);
+    static void SetDefaults(EaxEffectProps &props);
+
+    static void Get(const EaxCall &call, const EAX_REVERBPROPERTIES &props);
+    static void Get(const EaxCall &call, const EAX20LISTENERPROPERTIES &props);
+    static void Get(const EaxCall &call, const EAXREVERBPROPERTIES &props);
+    static void Get(const EaxCall &call, const EaxEffectProps &props);
+
+    static void Set(const EaxCall &call, EAX_REVERBPROPERTIES &props);
+    static void Set(const EaxCall &call, EAX20LISTENERPROPERTIES &props);
+    static void Set(const EaxCall &call, EAXREVERBPROPERTIES &props);
+    static void Set(const EaxCall &call, EaxEffectProps &props);
+
+    static void translate(const EAX_REVERBPROPERTIES& src, EaxEffectProps& dst) noexcept;
+    static void translate(const EAX20LISTENERPROPERTIES& src, EaxEffectProps& dst) noexcept;
+    static void translate(const EAXREVERBPROPERTIES& src, EaxEffectProps& dst) noexcept;
+};
+
+template<typename T>
+struct EaxCommitter {
+    struct Exception;
+
+    EaxCommitter(EaxEffectProps &eaxprops, EffectProps &alprops)
+        : mEaxProps{eaxprops}, mAlProps{alprops}
+    { }
+
+    EaxEffectProps &mEaxProps;
+    EffectProps &mAlProps;
+
+    template<typename TValidator, typename TProperty>
+    static void defer(const EaxCall& call, TProperty& property)
+    {
+        const auto& value = call.get_value<Exception, const TProperty>();
+        TValidator{}(value);
+        property = value;
+    }
+
+    [[noreturn]] static void fail(const char *message);
+    [[noreturn]] static void fail_unknown_property_id()
+    { fail(EaxEffectErrorMessages::unknown_property_id()); }
+
+    bool commit(const EaxEffectProps &props);
+
+    static void SetDefaults(EaxEffectProps &props);
+    static void Get(const EaxCall &call, const EaxEffectProps &props);
+    static void Set(const EaxCall &call, EaxEffectProps &props);
+};
+
+struct EaxAutowahCommitter : public EaxCommitter<EaxAutowahCommitter> {
+    using EaxCommitter<EaxAutowahCommitter>::EaxCommitter;
+};
+struct EaxChorusCommitter : public EaxCommitter<EaxChorusCommitter> {
+    using EaxCommitter<EaxChorusCommitter>::EaxCommitter;
+};
+struct EaxCompressorCommitter : public EaxCommitter<EaxCompressorCommitter> {
+    using EaxCommitter<EaxCompressorCommitter>::EaxCommitter;
+};
+struct EaxDistortionCommitter : public EaxCommitter<EaxDistortionCommitter> {
+    using EaxCommitter<EaxDistortionCommitter>::EaxCommitter;
+};
+struct EaxEchoCommitter : public EaxCommitter<EaxEchoCommitter> {
+    using EaxCommitter<EaxEchoCommitter>::EaxCommitter;
+};
+struct EaxEqualizerCommitter : public EaxCommitter<EaxEqualizerCommitter> {
+    using EaxCommitter<EaxEqualizerCommitter>::EaxCommitter;
+};
+struct EaxFlangerCommitter : public EaxCommitter<EaxFlangerCommitter> {
+    using EaxCommitter<EaxFlangerCommitter>::EaxCommitter;
+};
+struct EaxFrequencyShifterCommitter : public EaxCommitter<EaxFrequencyShifterCommitter> {
+    using EaxCommitter<EaxFrequencyShifterCommitter>::EaxCommitter;
+};
+struct EaxModulatorCommitter : public EaxCommitter<EaxModulatorCommitter> {
+    using EaxCommitter<EaxModulatorCommitter>::EaxCommitter;
+};
+struct EaxPitchShifterCommitter : public EaxCommitter<EaxPitchShifterCommitter> {
+    using EaxCommitter<EaxPitchShifterCommitter>::EaxCommitter;
+};
+struct EaxVocalMorpherCommitter : public EaxCommitter<EaxVocalMorpherCommitter> {
+    using EaxCommitter<EaxVocalMorpherCommitter>::EaxCommitter;
+};
+struct EaxNullCommitter : public EaxCommitter<EaxNullCommitter> {
+    using EaxCommitter<EaxNullCommitter>::EaxCommitter;
+};
+
+
+class EaxEffect {
+public:
+    EaxEffect() noexcept = default;
+    ~EaxEffect() = default;
+
+    ALenum al_effect_type_{AL_EFFECT_NULL};
+    EffectProps al_effect_props_{};
+
+    using Props1 = EAX_REVERBPROPERTIES;
+    using Props2 = EAX20LISTENERPROPERTIES;
+    using Props3 = EAXREVERBPROPERTIES;
+    using Props4 = EaxEffectProps;
+
+    struct State1 {
+        Props1 i; // Immediate.
+        Props1 d; // Deferred.
+    };
+
+    struct State2 {
+        Props2 i; // Immediate.
+        Props2 d; // Deferred.
+    };
+
+    struct State3 {
+        Props3 i; // Immediate.
+        Props3 d; // Deferred.
+    };
+
+    struct State4 {
+        Props4 i; // Immediate.
+        Props4 d; // Deferred.
+    };
+
+    int version_{};
+    bool changed_{};
+    Props4 props_{};
+    State1 state1_{};
+    State2 state2_{};
+    State3 state3_{};
+    State4 state4_{};
+    State4 state5_{};
+
+
+    template<typename T, typename ...Args>
+    void call_set_defaults(Args&& ...args)
+    { return T::SetDefaults(std::forward<Args>(args)...); }
+
+    void call_set_defaults(const ALenum altype, EaxEffectProps &props)
+    {
+        if(altype == AL_EFFECT_EAXREVERB)
+            return call_set_defaults<EaxReverbCommitter>(props);
+        if(altype == AL_EFFECT_CHORUS)
+            return call_set_defaults<EaxChorusCommitter>(props);
+        if(altype == AL_EFFECT_AUTOWAH)
+            return call_set_defaults<EaxAutowahCommitter>(props);
+        if(altype == AL_EFFECT_COMPRESSOR)
+            return call_set_defaults<EaxCompressorCommitter>(props);
+        if(altype == AL_EFFECT_DISTORTION)
+            return call_set_defaults<EaxDistortionCommitter>(props);
+        if(altype == AL_EFFECT_ECHO)
+            return call_set_defaults<EaxEchoCommitter>(props);
+        if(altype == AL_EFFECT_EQUALIZER)
+            return call_set_defaults<EaxEqualizerCommitter>(props);
+        if(altype == AL_EFFECT_FLANGER)
+            return call_set_defaults<EaxFlangerCommitter>(props);
+        if(altype == AL_EFFECT_FREQUENCY_SHIFTER)
+            return call_set_defaults<EaxFrequencyShifterCommitter>(props);
+        if(altype == AL_EFFECT_RING_MODULATOR)
+            return call_set_defaults<EaxModulatorCommitter>(props);
+        if(altype == AL_EFFECT_PITCH_SHIFTER)
+            return call_set_defaults<EaxPitchShifterCommitter>(props);
+        if(altype == AL_EFFECT_VOCAL_MORPHER)
+            return call_set_defaults<EaxVocalMorpherCommitter>(props);
+        return call_set_defaults<EaxNullCommitter>(props);
+    }
+
+    template<typename T>
+    void init()
+    {
+        call_set_defaults<EaxReverbCommitter>(state1_.d);
+        state1_.i = state1_.d;
+        call_set_defaults<EaxReverbCommitter>(state2_.d);
+        state2_.i = state2_.d;
+        call_set_defaults<EaxReverbCommitter>(state3_.d);
+        state3_.i = state3_.d;
+        call_set_defaults<T>(state4_.d);
+        state4_.i = state4_.d;
+        call_set_defaults<T>(state5_.d);
+        state5_.i = state5_.d;
+    }
+
+    void set_defaults(int eax_version, ALenum altype)
+    {
+        switch(eax_version)
+        {
+        case 1: call_set_defaults<EaxReverbCommitter>(state1_.d); break;
+        case 2: call_set_defaults<EaxReverbCommitter>(state2_.d); break;
+        case 3: call_set_defaults<EaxReverbCommitter>(state3_.d); break;
+        case 4: call_set_defaults(altype, state4_.d); break;
+        case 5: call_set_defaults(altype, state5_.d); break;
+        }
+        changed_ = true;
+    }
+
+
+#define EAXCALL(T, Callable, ...)                                             \
+    if(T == EaxEffectType::Reverb)                                            \
+        return Callable<EaxReverbCommitter>(__VA_ARGS__);                     \
+    if(T == EaxEffectType::Chorus)                                            \
+        return Callable<EaxChorusCommitter>(__VA_ARGS__);                     \
+    if(T == EaxEffectType::Autowah)                                           \
+        return Callable<EaxAutowahCommitter>(__VA_ARGS__);                    \
+    if(T == EaxEffectType::Compressor)                                        \
+        return Callable<EaxCompressorCommitter>(__VA_ARGS__);                 \
+    if(T == EaxEffectType::Distortion)                                        \
+        return Callable<EaxDistortionCommitter>(__VA_ARGS__);                 \
+    if(T == EaxEffectType::Echo)                                              \
+        return Callable<EaxEchoCommitter>(__VA_ARGS__);                       \
+    if(T == EaxEffectType::Equalizer)                                         \
+        return Callable<EaxEqualizerCommitter>(__VA_ARGS__);                  \
+    if(T == EaxEffectType::Flanger)                                           \
+        return Callable<EaxFlangerCommitter>(__VA_ARGS__);                    \
+    if(T == EaxEffectType::FrequencyShifter)                                  \
+        return Callable<EaxFrequencyShifterCommitter>(__VA_ARGS__);           \
+    if(T == EaxEffectType::Modulator)                                         \
+        return Callable<EaxModulatorCommitter>(__VA_ARGS__);                  \
+    if(T == EaxEffectType::PitchShifter)                                      \
+        return Callable<EaxPitchShifterCommitter>(__VA_ARGS__);               \
+    if(T == EaxEffectType::VocalMorpher)                                      \
+        return Callable<EaxVocalMorpherCommitter>(__VA_ARGS__);               \
+    return Callable<EaxNullCommitter>(__VA_ARGS__)
+
+    template<typename T, typename ...Args>
+    static void call_set(Args&& ...args)
+    { return T::Set(std::forward<Args>(args)...); }
+
+    static void call_set(const EaxCall &call, EaxEffectProps &props)
+    { EAXCALL(props.mType, call_set, call, props); }
+
+    void set(const EaxCall &call)
+    {
+        switch(call.get_version())
+        {
+        case 1: call_set<EaxReverbCommitter>(call, state1_.d); break;
+        case 2: call_set<EaxReverbCommitter>(call, state2_.d); break;
+        case 3: call_set<EaxReverbCommitter>(call, state3_.d); break;
+        case 4: call_set(call, state4_.d); break;
+        case 5: call_set(call, state5_.d); break;
+        }
+        changed_ = true;
+    }
+
+
+    template<typename T, typename ...Args>
+    static void call_get(Args&& ...args)
+    { return T::Get(std::forward<Args>(args)...); }
+
+    static void call_get(const EaxCall &call, const EaxEffectProps &props)
+    { EAXCALL(props.mType, call_get, call, props); }
+
+    void get(const EaxCall &call)
+    {
+        switch(call.get_version())
+        {
+        case 1: call_get<EaxReverbCommitter>(call, state1_.d); break;
+        case 2: call_get<EaxReverbCommitter>(call, state2_.d); break;
+        case 3: call_get<EaxReverbCommitter>(call, state3_.d); break;
+        case 4: call_get(call, state4_.d); break;
+        case 5: call_get(call, state5_.d); break;
+        }
+    }
+
+
+    template<typename T, typename ...Args>
+    bool call_commit(Args&& ...args)
+    { return T{props_, al_effect_props_}.commit(std::forward<Args>(args)...); }
+
+    bool call_commit(const EaxEffectProps &props)
+    { EAXCALL(props.mType, call_commit, props); }
+
+    bool commit(int eax_version)
+    {
+        changed_ |= version_ != eax_version;
+        if(!changed_) return false;
+
+        bool ret{version_ != eax_version};
+        version_ = eax_version;
+        changed_ = false;
+
+        switch(eax_version)
+        {
+        case 1:
+            state1_.i = state1_.d;
+            ret |= call_commit<EaxReverbCommitter>(state1_.d);
+            break;
+        case 2:
+            state2_.i = state2_.d;
+            ret |= call_commit<EaxReverbCommitter>(state2_.d);
+            break;
+        case 3:
+            state3_.i = state3_.d;
+            ret |= call_commit<EaxReverbCommitter>(state3_.d);
+            break;
+        case 4:
+            state4_.i = state4_.d;
+            ret |= call_commit(state4_.d);
+            break;
+        case 5:
+            state5_.i = state5_.d;
+            ret |= call_commit(state5_.d);
+            break;
+        }
+        al_effect_type_ = EnumFromEaxEffectType(props_);
+        return ret;
+    }
+#undef EAXCALL
+}; // EaxEffect
+
+using EaxEffectUPtr = std::unique_ptr<EaxEffect>;
+
+#endif // !EAX_EFFECT_INCLUDED
diff --git a/al/eax/exception.cpp b/al/eax/exception.cpp
new file mode 100644
index 00000000..435e7442
--- /dev/null
+++ b/al/eax/exception.cpp
@@ -0,0 +1,59 @@
+#include "config.h"
+
+#include "exception.h"
+
+#include <cassert>
+#include <string>
+
+
+EaxException::EaxException(const char *context, const char *message)
+    : std::runtime_error{make_message(context, message)}
+{
+}
+EaxException::~EaxException() = default;
+
+
+std::string EaxException::make_message(const char *context, const char *message)
+{
+    const auto context_size = (context ? std::string::traits_type::length(context) : 0);
+    const auto has_contex = (context_size > 0);
+
+    const auto message_size = (message ? std::string::traits_type::length(message) : 0);
+    const auto has_message = (message_size > 0);
+
+    if (!has_contex && !has_message)
+    {
+        return std::string{};
+    }
+
+    static constexpr char left_prefix[] = "[";
+    const auto left_prefix_size = std::string::traits_type::length(left_prefix);
+
+    static constexpr char right_prefix[] = "] ";
+    const auto right_prefix_size = std::string::traits_type::length(right_prefix);
+
+    const auto what_size =
+        (
+            has_contex ?
+            left_prefix_size + context_size + right_prefix_size :
+            0) +
+        message_size +
+        1;
+
+    auto what = std::string{};
+    what.reserve(what_size);
+
+    if (has_contex)
+    {
+        what.append(left_prefix, left_prefix_size);
+        what.append(context, context_size);
+        what.append(right_prefix, right_prefix_size);
+    }
+
+    if (has_message)
+    {
+        what.append(message, message_size);
+    }
+
+    return what;
+}
diff --git a/al/eax/exception.h b/al/eax/exception.h
new file mode 100644
index 00000000..3ae88cdc
--- /dev/null
+++ b/al/eax/exception.h
@@ -0,0 +1,18 @@
+#ifndef EAX_EXCEPTION_INCLUDED
+#define EAX_EXCEPTION_INCLUDED
+
+
+#include <stdexcept>
+#include <string>
+
+
+class EaxException : public std::runtime_error {
+    static std::string make_message(const char *context, const char *message);
+
+public:
+    EaxException(const char *context, const char *message);
+    ~EaxException() override;
+}; // EaxException
+
+
+#endif // !EAX_EXCEPTION_INCLUDED
diff --git a/al/eax/fx_slot_index.cpp b/al/eax/fx_slot_index.cpp
new file mode 100644
index 00000000..28b11882
--- /dev/null
+++ b/al/eax/fx_slot_index.cpp
@@ -0,0 +1,71 @@
+#include "config.h"
+
+#include "fx_slot_index.h"
+
+#include "exception.h"
+
+
+namespace
+{
+
+
+class EaxFxSlotIndexException :
+    public EaxException
+{
+public:
+    explicit EaxFxSlotIndexException(
+        const char* message)
+        :
+        EaxException{"EAX_FX_SLOT_INDEX", message}
+    {
+    }
+}; // EaxFxSlotIndexException
+
+
+} // namespace
+
+
+void EaxFxSlotIndex::set(EaxFxSlotIndexValue index)
+{
+    if(index >= EaxFxSlotIndexValue{EAX_MAX_FXSLOTS})
+        fail("Index out of range.");
+
+    emplace(index);
+}
+
+void EaxFxSlotIndex::set(const GUID &guid)
+{
+    if (false)
+    {
+    }
+    else if (guid == EAX_NULL_GUID)
+    {
+        reset();
+    }
+    else if (guid == EAXPROPERTYID_EAX40_FXSlot0 || guid == EAXPROPERTYID_EAX50_FXSlot0)
+    {
+        emplace(0u);
+    }
+    else if (guid == EAXPROPERTYID_EAX40_FXSlot1 || guid == EAXPROPERTYID_EAX50_FXSlot1)
+    {
+        emplace(1u);
+    }
+    else if (guid == EAXPROPERTYID_EAX40_FXSlot2 || guid == EAXPROPERTYID_EAX50_FXSlot2)
+    {
+        emplace(2u);
+    }
+    else if (guid == EAXPROPERTYID_EAX40_FXSlot3 || guid == EAXPROPERTYID_EAX50_FXSlot3)
+    {
+        emplace(3u);
+    }
+    else
+    {
+        fail("Unsupported GUID.");
+    }
+}
+
+[[noreturn]]
+void EaxFxSlotIndex::fail(const char* message)
+{
+    throw EaxFxSlotIndexException{message};
+}
diff --git a/al/eax/fx_slot_index.h b/al/eax/fx_slot_index.h
new file mode 100644
index 00000000..63dba037
--- /dev/null
+++ b/al/eax/fx_slot_index.h
@@ -0,0 +1,41 @@
+#ifndef EAX_FX_SLOT_INDEX_INCLUDED
+#define EAX_FX_SLOT_INDEX_INCLUDED
+
+
+#include <cstddef>
+
+#include "aloptional.h"
+#include "api.h"
+
+
+using EaxFxSlotIndexValue = std::size_t;
+
+class EaxFxSlotIndex : public al::optional<EaxFxSlotIndexValue>
+{
+public:
+    using al::optional<EaxFxSlotIndexValue>::optional;
+
+    EaxFxSlotIndex& operator=(const EaxFxSlotIndexValue &value) { set(value); return *this; }
+    EaxFxSlotIndex& operator=(const GUID &guid) { set(guid); return *this; }
+
+    void set(EaxFxSlotIndexValue index);
+    void set(const GUID& guid);
+
+private:
+    [[noreturn]]
+    static void fail(const char *message);
+}; // EaxFxSlotIndex
+
+inline bool operator==(const EaxFxSlotIndex& lhs, const EaxFxSlotIndex& rhs) noexcept
+{
+    if(lhs.has_value() != rhs.has_value())
+        return false;
+    if(lhs.has_value())
+        return *lhs == *rhs;
+    return true;
+}
+
+inline bool operator!=(const EaxFxSlotIndex& lhs, const EaxFxSlotIndex& rhs) noexcept
+{ return !(lhs == rhs); }
+
+#endif // !EAX_FX_SLOT_INDEX_INCLUDED
diff --git a/al/eax/fx_slots.cpp b/al/eax/fx_slots.cpp
new file mode 100644
index 00000000..d04b70df
--- /dev/null
+++ b/al/eax/fx_slots.cpp
@@ -0,0 +1,75 @@
+#include "config.h"
+
+#include "fx_slots.h"
+
+#include <array>
+
+#include "api.h"
+#include "exception.h"
+
+
+namespace
+{
+
+
+class EaxFxSlotsException :
+    public EaxException
+{
+public:
+    explicit EaxFxSlotsException(
+        const char* message)
+        :
+        EaxException{"EAX_FX_SLOTS", message}
+    {
+    }
+}; // EaxFxSlotsException
+
+
+} // namespace
+
+
+void EaxFxSlots::initialize(ALCcontext& al_context)
+{
+    initialize_fx_slots(al_context);
+}
+
+void EaxFxSlots::uninitialize() noexcept
+{
+    for (auto& fx_slot : fx_slots_)
+    {
+        fx_slot = nullptr;
+    }
+}
+
+const ALeffectslot& EaxFxSlots::get(EaxFxSlotIndex index) const
+{
+    if(!index.has_value())
+        fail("Empty index.");
+    return *fx_slots_[index.value()];
+}
+
+ALeffectslot& EaxFxSlots::get(EaxFxSlotIndex index)
+{
+    if(!index.has_value())
+        fail("Empty index.");
+    return *fx_slots_[index.value()];
+}
+
+[[noreturn]]
+void EaxFxSlots::fail(
+    const char* message)
+{
+    throw EaxFxSlotsException{message};
+}
+
+void EaxFxSlots::initialize_fx_slots(ALCcontext& al_context)
+{
+    auto fx_slot_index = EaxFxSlotIndexValue{};
+
+    for (auto& fx_slot : fx_slots_)
+    {
+        fx_slot = eax_create_al_effect_slot(al_context);
+        fx_slot->eax_initialize(al_context, fx_slot_index);
+        fx_slot_index += 1;
+    }
+}
diff --git a/al/eax/fx_slots.h b/al/eax/fx_slots.h
new file mode 100644
index 00000000..18b2d3ad
--- /dev/null
+++ b/al/eax/fx_slots.h
@@ -0,0 +1,49 @@
+#ifndef EAX_FX_SLOTS_INCLUDED
+#define EAX_FX_SLOTS_INCLUDED
+
+
+#include <array>
+
+#include "al/auxeffectslot.h"
+
+#include "api.h"
+#include "call.h"
+#include "fx_slot_index.h"
+
+
+class EaxFxSlots
+{
+public:
+    void initialize(ALCcontext& al_context);
+
+    void uninitialize() noexcept;
+
+    void commit()
+    {
+        for(auto& fx_slot : fx_slots_)
+            fx_slot->eax_commit();
+    }
+
+
+    const ALeffectslot& get(
+        EaxFxSlotIndex index) const;
+
+    ALeffectslot& get(
+        EaxFxSlotIndex index);
+
+private:
+    using Items = std::array<EaxAlEffectSlotUPtr, EAX_MAX_FXSLOTS>;
+
+
+    Items fx_slots_{};
+
+
+    [[noreturn]]
+    static void fail(
+        const char* message);
+
+    void initialize_fx_slots(ALCcontext& al_context);
+}; // EaxFxSlots
+
+
+#endif // !EAX_FX_SLOTS_INCLUDED
diff --git a/al/eax/globals.cpp b/al/eax/globals.cpp
new file mode 100644
index 00000000..80e9dbfe
--- /dev/null
+++ b/al/eax/globals.cpp
@@ -0,0 +1,21 @@
+#include "config.h"
+
+#include "globals.h"
+
+
+bool eax_g_is_enabled = true;
+
+
+const char eax1_ext_name[] = "EAX";
+const char eax2_ext_name[] = "EAX2.0";
+const char eax3_ext_name[] = "EAX3.0";
+const char eax4_ext_name[] = "EAX4.0";
+const char eax5_ext_name[] = "EAX5.0";
+
+const char eax_x_ram_ext_name[] = "EAX-RAM";
+
+const char eax_eax_set_func_name[] = "EAXSet";
+const char eax_eax_get_func_name[] = "EAXGet";
+
+const char eax_eax_set_buffer_mode_func_name[] = "EAXSetBufferMode";
+const char eax_eax_get_buffer_mode_func_name[] = "EAXGetBufferMode";
diff --git a/al/eax/globals.h b/al/eax/globals.h
new file mode 100644
index 00000000..1b4d63b8
--- /dev/null
+++ b/al/eax/globals.h
@@ -0,0 +1,22 @@
+#ifndef EAX_GLOBALS_INCLUDED
+#define EAX_GLOBALS_INCLUDED
+
+
+extern bool eax_g_is_enabled;
+
+
+extern const char eax1_ext_name[];
+extern const char eax2_ext_name[];
+extern const char eax3_ext_name[];
+extern const char eax4_ext_name[];
+extern const char eax5_ext_name[];
+
+extern const char eax_x_ram_ext_name[];
+
+extern const char eax_eax_set_func_name[];
+extern const char eax_eax_get_func_name[];
+
+extern const char eax_eax_set_buffer_mode_func_name[];
+extern const char eax_eax_get_buffer_mode_func_name[];
+
+#endif // !EAX_GLOBALS_INCLUDED
diff --git a/al/eax/utils.cpp b/al/eax/utils.cpp
new file mode 100644
index 00000000..b3ed6ca1
--- /dev/null
+++ b/al/eax/utils.cpp
@@ -0,0 +1,26 @@
+#include "config.h"
+
+#include "utils.h"
+
+#include <cassert>
+#include <exception>
+
+#include "core/logging.h"
+
+
+void eax_log_exception(const char *message) noexcept
+{
+    const auto exception_ptr = std::current_exception();
+    assert(exception_ptr);
+
+    try {
+        std::rethrow_exception(exception_ptr);
+    }
+    catch(const std::exception& ex) {
+        const auto ex_message = ex.what();
+        ERR("%s %s\n", message ? message : "", ex_message);
+    }
+    catch(...) {
+        ERR("%s %s\n", message ? message : "", "Generic exception.");
+    }
+}
diff --git a/al/eax/utils.h b/al/eax/utils.h
new file mode 100644
index 00000000..8ff75a18
--- /dev/null
+++ b/al/eax/utils.h
@@ -0,0 +1,95 @@
+#ifndef EAX_UTILS_INCLUDED
+#define EAX_UTILS_INCLUDED
+
+#include <algorithm>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+
+using EaxDirtyFlags = unsigned int;
+
+struct EaxAlLowPassParam {
+    float gain;
+    float gain_hf;
+};
+
+void eax_log_exception(const char *message) noexcept;
+
+template<typename TException, typename TValue>
+void eax_validate_range(
+    const char* value_name,
+    const TValue& value,
+    const TValue& min_value,
+    const TValue& max_value)
+{
+    if (value >= min_value && value <= max_value)
+        return;
+
+    const auto message =
+        std::string{value_name} +
+        " out of range (value: " +
+        std::to_string(value) + "; min: " +
+        std::to_string(min_value) + "; max: " +
+        std::to_string(max_value) + ").";
+
+    throw TException{message.c_str()};
+}
+
+namespace detail {
+
+template<typename T>
+struct EaxIsBitFieldStruct {
+private:
+    using yes = std::true_type;
+    using no = std::false_type;
+
+    template<typename U>
+    static auto test(int) -> decltype(std::declval<typename U::EaxIsBitFieldStruct>(), yes{});
+
+    template<typename>
+    static no test(...);
+
+public:
+    static constexpr auto value = std::is_same<decltype(test<T>(0)), yes>::value;
+};
+
+template<typename T, typename TValue>
+inline bool eax_bit_fields_are_equal(const T& lhs, const T& rhs) noexcept
+{
+    static_assert(sizeof(T) == sizeof(TValue), "Invalid type size.");
+    return reinterpret_cast<const TValue&>(lhs) == reinterpret_cast<const TValue&>(rhs);
+}
+
+} // namespace detail
+
+template<
+    typename T,
+    std::enable_if_t<detail::EaxIsBitFieldStruct<T>::value, int> = 0
+>
+inline bool operator==(const T& lhs, const T& rhs) noexcept
+{
+    using Value = std::conditional_t<
+        sizeof(T) == 1,
+        std::uint8_t,
+        std::conditional_t<
+            sizeof(T) == 2,
+            std::uint16_t,
+            std::conditional_t<
+                sizeof(T) == 4,
+                std::uint32_t,
+                void>>>;
+
+    static_assert(!std::is_same<Value, void>::value, "Unsupported type.");
+    return detail::eax_bit_fields_are_equal<T, Value>(lhs, rhs);
+}
+
+template<
+    typename T,
+    std::enable_if_t<detail::EaxIsBitFieldStruct<T>::value, int> = 0
+>
+inline bool operator!=(const T& lhs, const T& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+#endif // !EAX_UTILS_INCLUDED
diff --git a/al/eax/x_ram.h b/al/eax/x_ram.h
new file mode 100644
index 00000000..438b9916
--- /dev/null
+++ b/al/eax/x_ram.h
@@ -0,0 +1,38 @@
+#ifndef EAX_X_RAM_INCLUDED
+#define EAX_X_RAM_INCLUDED
+
+
+#include "AL/al.h"
+
+
+constexpr auto eax_x_ram_min_size = ALsizei{};
+constexpr auto eax_x_ram_max_size = ALsizei{64 * 1'024 * 1'024};
+
+
+constexpr auto AL_EAX_RAM_SIZE = ALenum{0x202201};
+constexpr auto AL_EAX_RAM_FREE = ALenum{0x202202};
+
+constexpr auto AL_STORAGE_AUTOMATIC = ALenum{0x202203};
+constexpr auto AL_STORAGE_HARDWARE = ALenum{0x202204};
+constexpr auto AL_STORAGE_ACCESSIBLE = ALenum{0x202205};
+
+
+constexpr auto AL_EAX_RAM_SIZE_NAME = "AL_EAX_RAM_SIZE";
+constexpr auto AL_EAX_RAM_FREE_NAME = "AL_EAX_RAM_FREE";
+
+constexpr auto AL_STORAGE_AUTOMATIC_NAME = "AL_STORAGE_AUTOMATIC";
+constexpr auto AL_STORAGE_HARDWARE_NAME = "AL_STORAGE_HARDWARE";
+constexpr auto AL_STORAGE_ACCESSIBLE_NAME = "AL_STORAGE_ACCESSIBLE";
+
+
+ALboolean AL_APIENTRY EAXSetBufferMode(
+    ALsizei n,
+    const ALuint* buffers,
+    ALint value);
+
+ALenum AL_APIENTRY EAXGetBufferMode(
+    ALuint buffer,
+    ALint* pReserved);
+
+
+#endif // !EAX_X_RAM_INCLUDED
diff --git a/al/effect.cpp b/al/effect.cpp
index f7d17f50..bde89912 100644
--- a/al/effect.cpp
+++ b/al/effect.cpp
@@ -38,102 +38,123 @@
 #include "AL/efx-presets.h"
 #include "AL/efx.h"
 
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "albit.h"
+#include "alc/context.h"
+#include "alc/device.h"
+#include "alc/effects/base.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "alstring.h"
-#include "effects/base.h"
-#include "logging.h"
+#include "core/except.h"
+#include "core/logging.h"
 #include "opthelpers.h"
 #include "vector.h"
 
-
-const EffectList gEffectList[15]{
-    { "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 },
+#ifdef ALSOFT_EAX
+#include <cassert>
+
+#include "eax/exception.h"
+#endif // ALSOFT_EAX
+
+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 },
 };
 
-ALboolean DisabledEffects[MAX_EFFECTS];
+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);
+}
+effect_exception::~effect_exception() = default;
 
 namespace {
 
-constexpr struct FactoryItem {
+struct EffectPropsItem {
     ALenum Type;
-    EffectStateFactory* (&GetFactory)(void);
-} FactoryList[] = {
-    { AL_EFFECT_NULL, NullStateFactory_getFactory },
-    { AL_EFFECT_EAXREVERB, ReverbStateFactory_getFactory },
-    { AL_EFFECT_REVERB, StdReverbStateFactory_getFactory },
-    { AL_EFFECT_AUTOWAH, AutowahStateFactory_getFactory },
-    { AL_EFFECT_CHORUS, ChorusStateFactory_getFactory },
-    { AL_EFFECT_COMPRESSOR, CompressorStateFactory_getFactory },
-    { AL_EFFECT_DISTORTION, DistortionStateFactory_getFactory },
-    { AL_EFFECT_ECHO, EchoStateFactory_getFactory },
-    { AL_EFFECT_EQUALIZER, EqualizerStateFactory_getFactory },
-    { AL_EFFECT_FLANGER, FlangerStateFactory_getFactory },
-    { AL_EFFECT_FREQUENCY_SHIFTER, FshifterStateFactory_getFactory },
-    { AL_EFFECT_RING_MODULATOR, ModulatorStateFactory_getFactory },
-    { AL_EFFECT_PITCH_SHIFTER, PshifterStateFactory_getFactory},
-    { AL_EFFECT_VOCAL_MORPHER, VmorpherStateFactory_getFactory},
-    { AL_EFFECT_DEDICATED_DIALOGUE, DedicatedStateFactory_getFactory },
-    { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedStateFactory_getFactory }
+    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 },
 };
 
 
-template<typename... T>
-void ALeffect_setParami(ALeffect *effect, T&& ...args)
-{ effect->vtab->setParami(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_setParamiv(ALeffect *effect, T&& ...args)
-{ effect->vtab->setParamiv(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_setParamf(ALeffect *effect, T&& ...args)
-{ effect->vtab->setParamf(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_setParamfv(ALeffect *effect, T&& ...args)
-{ effect->vtab->setParamfv(&effect->Props, std::forward<T>(args)...); }
-
-template<typename... T>
-void ALeffect_getParami(const ALeffect *effect, T&& ...args)
-{ effect->vtab->getParami(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_getParamiv(const ALeffect *effect, T&& ...args)
-{ effect->vtab->getParamiv(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_getParamf(const ALeffect *effect, T&& ...args)
-{ effect->vtab->getParamf(&effect->Props, std::forward<T>(args)...); }
-template<typename... T>
-void ALeffect_getParamfv(const ALeffect *effect, T&& ...args)
-{ effect->vtab->getParamfv(&effect->Props, std::forward<T>(args)...); }
+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)) ? al::to_address(iter) : nullptr;
+}
+
 void InitEffectParams(ALeffect *effect, ALenum type)
 {
-    EffectStateFactory *factory = getFactoryByType(type);
-    if(factory)
+    const EffectPropsItem *item{getEffectPropsItemByType(type)};
+    if(item)
     {
-        effect->Props = factory->getDefaultProps();
-        effect->vtab = factory->getEffectVtable();
+        effect->Props = item->DefaultProps;
+        effect->vtab = &item->Vtable;
     }
     else
     {
         effect->Props = EffectProps{};
-        effect->vtab = nullptr;
+        effect->vtab = &NullEffectVtable;
     }
     effect->type = type;
 }
@@ -142,19 +163,18 @@ 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>(POPCNT64(sublist.FreeMask)); }
-    )};
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 
     while(needed > count)
     {
-        if UNLIKELY(device->EffectList.size() >= 1<<25)
+        if(device->EffectList.size() >= 1<<25) UNLIKELY
             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)
+        if(!sublist->Effects) UNLIKELY
         {
             device->EffectList.pop_back();
             return false;
@@ -168,12 +188,12 @@ ALeffect *AllocEffect(ALCdevice *device)
 {
     auto sublist = std::find_if(device->EffectList.begin(), device->EffectList.end(),
         [](const EffectSubList &entry) noexcept -> bool
-        { return entry.FreeMask != 0; }
-    );
+        { return entry.FreeMask != 0; });
     auto lidx = static_cast<ALuint>(std::distance(device->EffectList.begin(), sublist));
-    auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+    ASSUME(slidx < 64);
 
-    ALeffect *effect{::new (sublist->Effects + slidx) ALeffect{}};
+    ALeffect *effect{al::construct_at(sublist->Effects + slidx)};
     InitEffectParams(effect, AL_EFFECT_NULL);
 
     /* Add 1 to avoid effect ID 0. */
@@ -200,27 +220,27 @@ 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())
+    if(lidx >= device->EffectList.size()) UNLIKELY
         return nullptr;
     EffectSubList &sublist = device->EffectList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Effects + slidx;
 }
 
 } // namespace
 
-AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
+AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Generating %d effects", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
     if(!EnsureEffects(device, static_cast<ALuint>(n)))
     {
@@ -228,7 +248,7 @@ START_API_FUNC
         return;
     }
 
-    if LIKELY(n == 1)
+    if(n == 1) LIKELY
     {
         /* Special handling for the easy and normal case. */
         ALeffect *effect{AllocEffect(device)};
@@ -250,17 +270,17 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
+AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Deleting %d effects", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     /* First try to find any effects that are invalid. */
@@ -269,7 +289,7 @@ START_API_FUNC
 
     const ALuint *effects_end = effects + n;
     auto inveffect = std::find_if_not(effects, effects_end, validate_effect);
-    if UNLIKELY(inveffect != effects_end)
+    if(inveffect != effects_end) UNLIKELY
     {
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", *inveffect);
         return;
@@ -289,9 +309,9 @@ AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if LIKELY(context)
+    if(context) LIKELY
     {
-        ALCdevice *device{context->mDevice.get()};
+        ALCdevice *device{context->mALDevice.get()};
         std::lock_guard<std::mutex> _{device->EffectLock};
         if(!effect || LookupEffect(device, effect))
             return AL_TRUE;
@@ -300,204 +320,222 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
+AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else if(param == AL_EFFECT_TYPE)
     {
-        if(param == AL_EFFECT_TYPE)
+        bool isOk{value == AL_EFFECT_NULL};
+        if(!isOk)
         {
-            ALboolean isOk{value == AL_EFFECT_NULL};
-            if(!isOk)
+            for(const EffectList &effectitem : gEffectList)
             {
-                for(const EffectList &effectitem : gEffectList)
+                if(value == effectitem.val && !DisabledEffects[effectitem.type])
                 {
-                    if(value == effectitem.val && !DisabledEffects[effectitem.type])
-                    {
-                        isOk = AL_TRUE;
-                        break;
-                    }
+                    isOk = true;
+                    break;
                 }
             }
-
-            if(isOk)
-                InitEffectParams(aleffect, value);
-            else
-                context->setError(AL_INVALID_VALUE, "Effect type 0x%04x not supported", value);
         }
+
+        if(isOk)
+            InitEffectParams(aleffect, value);
         else
-        {
-            /* Call the appropriate handler */
-            ALeffect_setParami(aleffect, context.get(), param, value);
-        }
+            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 ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *values)
+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;
+    case AL_EFFECT_TYPE:
+        alEffecti(effect, param, values[0]);
+        return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_setParamiv(aleffect, context.get(), param, values);
+        ALeffect_setParamiv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value)
+AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_setParamf(aleffect, context.get(), param, value);
+        ALeffect_setParamf(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *values)
+AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_setParamfv(aleffect, context.get(), param, values);
+        ALeffect_setParamfv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     const ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else if(param == AL_EFFECT_TYPE)
+        *value = aleffect->type;
+    else try
     {
-        if(param == AL_EFFECT_TYPE)
-            *value = aleffect->type;
-        else
-        {
-            /* Call the appropriate handler */
-            ALeffect_getParami(aleffect, context.get(), param, value);
-        }
+        /* 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 ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *values)
+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;
+    case AL_EFFECT_TYPE:
+        alGetEffecti(effect, param, values);
+        return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     const ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_getParamiv(aleffect, context.get(), param, values);
+        ALeffect_getParamiv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     const ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_getParamf(aleffect, context.get(), param, value);
+        ALeffect_getParamf(aleffect, param, value);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *values)
+AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->EffectLock};
 
     const ALeffect *aleffect{LookupEffect(device, effect)};
-    if UNLIKELY(!aleffect)
+    if(!aleffect) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid effect ID %u", effect);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALeffect_getParamfv(aleffect, context.get(), param, values);
+        ALeffect_getParamfv(aleffect, param, values);
+    }
+    catch(effect_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
@@ -513,7 +551,7 @@ EffectSubList::~EffectSubList()
     uint64_t usemask{~FreeMask};
     while(usemask)
     {
-        ALsizei idx = CTZ64(usemask);
+        const int idx{al::countr_zero(usemask)};
         al::destroy_at(Effects+idx);
         usemask &= ~(1_u64 << idx);
     }
@@ -523,16 +561,6 @@ EffectSubList::~EffectSubList()
 }
 
 
-EffectStateFactory *getFactoryByType(ALenum type)
-{
-    auto iter = std::find_if(std::begin(FactoryList), std::end(FactoryList),
-        [type](const FactoryItem &item) noexcept -> bool
-        { return item.Type == type; }
-    );
-    return (iter != std::end(FactoryList)) ? iter->GetFactory() : nullptr;
-}
-
-
 #define DECL(x) { #x, EFX_REVERB_PRESET_##x }
 static const struct {
     const char name[32];
@@ -723,3 +751,16 @@ void LoadReverbPreset(const char *name, ALeffect *effect)
 
     WARN("Reverb preset '%s' not found\n", name);
 }
+
+bool IsValidEffectType(ALenum type) noexcept
+{
+    if(type == AL_EFFECT_NULL)
+        return true;
+
+    for(const auto &effect_item : gEffectList)
+    {
+        if(type == effect_item.val && !DisabledEffects[effect_item.type])
+            return true;
+    }
+    return false;
+}
diff --git a/al/effect.h b/al/effect.h
index 270b8e20..a1d43313 100644
--- a/al/effect.h
+++ b/al/effect.h
@@ -4,7 +4,8 @@
 #include "AL/al.h"
 #include "AL/efx.h"
 
-#include "effects/base.h"
+#include "al/effects/effects.h"
+#include "alc/effects/base.h"
 
 
 enum {
@@ -22,19 +23,20 @@ enum {
     PSHIFTER_EFFECT,
     VMORPHER_EFFECT,
     DEDICATED_EFFECT,
+    CONVOLUTION_EFFECT,
 
     MAX_EFFECTS
 };
-extern ALboolean DisabledEffects[MAX_EFFECTS];
+extern bool DisabledEffects[MAX_EFFECTS];
 
-extern ALfloat ReverbBoost;
+extern float ReverbBoost;
 
 struct EffectList {
     const char name[16];
     int type;
     ALenum val;
 };
-extern const EffectList gEffectList[15];
+extern const EffectList gEffectList[16];
 
 
 struct ALeffect {
@@ -47,15 +49,14 @@ struct ALeffect {
 
     /* Self ID */
     ALuint id{0u};
-};
-
-inline ALboolean IsReverbEffect(ALenum type)
-{ return type == AL_EFFECT_REVERB || type == AL_EFFECT_EAXREVERB; }
 
-EffectStateFactory *getFactoryByType(ALenum type);
+    DISABLE_ALLOC()
+};
 
 void InitEffect(ALeffect *effect);
 
 void LoadReverbPreset(const char *name, ALeffect *effect);
 
+bool IsValidEffectType(ALenum type) noexcept;
+
 #endif
diff --git a/al/effects/autowah.cpp b/al/effects/autowah.cpp
new file mode 100644
index 00000000..129318f4
--- /dev/null
+++ b/al/effects/autowah.cpp
@@ -0,0 +1,252 @@
+
+#include "config.h"
+
+#include <cmath>
+#include <cstdlib>
+
+#include <algorithm>
+
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using AutowahCommitter = EaxCommitter<EaxAutowahCommitter>;
+
+struct AttackTimeValidator {
+    void operator()(float flAttackTime) const
+    {
+        eax_validate_range<AutowahCommitter::Exception>(
+            "Attack Time",
+            flAttackTime,
+            EAXAUTOWAH_MINATTACKTIME,
+            EAXAUTOWAH_MAXATTACKTIME);
+    }
+}; // AttackTimeValidator
+
+struct ReleaseTimeValidator {
+    void operator()(float flReleaseTime) const
+    {
+        eax_validate_range<AutowahCommitter::Exception>(
+            "Release Time",
+            flReleaseTime,
+            EAXAUTOWAH_MINRELEASETIME,
+            EAXAUTOWAH_MAXRELEASETIME);
+    }
+}; // ReleaseTimeValidator
+
+struct ResonanceValidator {
+    void operator()(long lResonance) const
+    {
+        eax_validate_range<AutowahCommitter::Exception>(
+            "Resonance",
+            lResonance,
+            EAXAUTOWAH_MINRESONANCE,
+            EAXAUTOWAH_MAXRESONANCE);
+    }
+}; // ResonanceValidator
+
+struct PeakLevelValidator {
+    void operator()(long lPeakLevel) const
+    {
+        eax_validate_range<AutowahCommitter::Exception>(
+            "Peak Level",
+            lPeakLevel,
+            EAXAUTOWAH_MINPEAKLEVEL,
+            EAXAUTOWAH_MAXPEAKLEVEL);
+    }
+}; // PeakLevelValidator
+
+struct AllValidator {
+    void operator()(const EAXAUTOWAHPROPERTIES& all) const
+    {
+        AttackTimeValidator{}(all.flAttackTime);
+        ReleaseTimeValidator{}(all.flReleaseTime);
+        ResonanceValidator{}(all.lResonance);
+        PeakLevelValidator{}(all.lPeakLevel);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct AutowahCommitter::Exception : public EaxException
+{
+    explicit Exception(const char *message) : EaxException{"EAX_AUTOWAH_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void AutowahCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool AutowahCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && mEaxProps.mAutowah.flAttackTime == props.mAutowah.flAttackTime
+        && mEaxProps.mAutowah.flReleaseTime == props.mAutowah.flReleaseTime
+        && mEaxProps.mAutowah.lResonance == props.mAutowah.lResonance
+        && mEaxProps.mAutowah.lPeakLevel == props.mAutowah.lPeakLevel)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Autowah.AttackTime = props.mAutowah.flAttackTime;
+    mAlProps.Autowah.ReleaseTime = props.mAutowah.flReleaseTime;
+    mAlProps.Autowah.Resonance = level_mb_to_gain(static_cast<float>(props.mAutowah.lResonance));
+    mAlProps.Autowah.PeakGain = level_mb_to_gain(static_cast<float>(props.mAutowah.lPeakLevel));
+
+    return true;
+}
+
+template<>
+void AutowahCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Autowah;
+    props.mAutowah.flAttackTime = EAXAUTOWAH_DEFAULTATTACKTIME;
+    props.mAutowah.flReleaseTime = EAXAUTOWAH_DEFAULTRELEASETIME;
+    props.mAutowah.lResonance = EAXAUTOWAH_DEFAULTRESONANCE;
+    props.mAutowah.lPeakLevel = EAXAUTOWAH_DEFAULTPEAKLEVEL;
+}
+
+template<>
+void AutowahCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXAUTOWAH_NONE: break;
+    case EAXAUTOWAH_ALLPARAMETERS: call.set_value<Exception>(props.mAutowah); break;
+    case EAXAUTOWAH_ATTACKTIME: call.set_value<Exception>(props.mAutowah.flAttackTime); break;
+    case EAXAUTOWAH_RELEASETIME: call.set_value<Exception>(props.mAutowah.flReleaseTime); break;
+    case EAXAUTOWAH_RESONANCE: call.set_value<Exception>(props.mAutowah.lResonance); break;
+    case EAXAUTOWAH_PEAKLEVEL: call.set_value<Exception>(props.mAutowah.lPeakLevel); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void AutowahCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXAUTOWAH_NONE: break;
+    case EAXAUTOWAH_ALLPARAMETERS: defer<AllValidator>(call, props.mAutowah); break;
+    case EAXAUTOWAH_ATTACKTIME: defer<AttackTimeValidator>(call, props.mAutowah.flAttackTime); break;
+    case EAXAUTOWAH_RELEASETIME: defer<ReleaseTimeValidator>(call, props.mAutowah.flReleaseTime); break;
+    case EAXAUTOWAH_RESONANCE: defer<ResonanceValidator>(call, props.mAutowah.lResonance); break;
+    case EAXAUTOWAH_PEAKLEVEL: defer<PeakLevelValidator>(call, props.mAutowah.lPeakLevel); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/chorus.cpp b/al/effects/chorus.cpp
new file mode 100644
index 00000000..305259a4
--- /dev/null
+++ b/al/effects/chorus.cpp
@@ -0,0 +1,724 @@
+
+#include "config.h"
+
+#include <stdexcept>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "aloptional.h"
+#include "core/logging.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include <cassert>
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+namespace {
+
+static_assert(ChorusMaxDelay >= AL_CHORUS_MAX_DELAY, "Chorus max delay too small");
+static_assert(FlangerMaxDelay >= AL_FLANGER_MAX_DELAY, "Flanger max delay too small");
+
+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 ChorusWaveform::Sinusoid;
+    case AL_CHORUS_WAVEFORM_TRIANGLE: return 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); }
+
+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()};
+
+
+#ifdef ALSOFT_EAX
+namespace {
+
+struct EaxChorusTraits {
+    using Props = EAXCHORUSPROPERTIES;
+    using Committer = EaxChorusCommitter;
+    static constexpr auto Field = &EaxEffectProps::mChorus;
+
+    static constexpr auto eax_effect_type() { return EaxEffectType::Chorus; }
+    static constexpr auto efx_effect() { return AL_EFFECT_CHORUS; }
+
+    static constexpr auto eax_none_param_id() { return EAXCHORUS_NONE; }
+    static constexpr auto eax_allparameters_param_id() { return EAXCHORUS_ALLPARAMETERS; }
+    static constexpr auto eax_waveform_param_id() { return EAXCHORUS_WAVEFORM; }
+    static constexpr auto eax_phase_param_id() { return EAXCHORUS_PHASE; }
+    static constexpr auto eax_rate_param_id() { return EAXCHORUS_RATE; }
+    static constexpr auto eax_depth_param_id() { return EAXCHORUS_DEPTH; }
+    static constexpr auto eax_feedback_param_id() { return EAXCHORUS_FEEDBACK; }
+    static constexpr auto eax_delay_param_id() { return EAXCHORUS_DELAY; }
+
+    static constexpr auto eax_min_waveform() { return EAXCHORUS_MINWAVEFORM; }
+    static constexpr auto eax_min_phase() { return EAXCHORUS_MINPHASE; }
+    static constexpr auto eax_min_rate() { return EAXCHORUS_MINRATE; }
+    static constexpr auto eax_min_depth() { return EAXCHORUS_MINDEPTH; }
+    static constexpr auto eax_min_feedback() { return EAXCHORUS_MINFEEDBACK; }
+    static constexpr auto eax_min_delay() { return EAXCHORUS_MINDELAY; }
+
+    static constexpr auto eax_max_waveform() { return EAXCHORUS_MAXWAVEFORM; }
+    static constexpr auto eax_max_phase() { return EAXCHORUS_MAXPHASE; }
+    static constexpr auto eax_max_rate() { return EAXCHORUS_MAXRATE; }
+    static constexpr auto eax_max_depth() { return EAXCHORUS_MAXDEPTH; }
+    static constexpr auto eax_max_feedback() { return EAXCHORUS_MAXFEEDBACK; }
+    static constexpr auto eax_max_delay() { return EAXCHORUS_MAXDELAY; }
+
+    static constexpr auto eax_default_waveform() { return EAXCHORUS_DEFAULTWAVEFORM; }
+    static constexpr auto eax_default_phase() { return EAXCHORUS_DEFAULTPHASE; }
+    static constexpr auto eax_default_rate() { return EAXCHORUS_DEFAULTRATE; }
+    static constexpr auto eax_default_depth() { return EAXCHORUS_DEFAULTDEPTH; }
+    static constexpr auto eax_default_feedback() { return EAXCHORUS_DEFAULTFEEDBACK; }
+    static constexpr auto eax_default_delay() { return EAXCHORUS_DEFAULTDELAY; }
+
+    static constexpr auto efx_min_waveform() { return AL_CHORUS_MIN_WAVEFORM; }
+    static constexpr auto efx_min_phase() { return AL_CHORUS_MIN_PHASE; }
+    static constexpr auto efx_min_rate() { return AL_CHORUS_MIN_RATE; }
+    static constexpr auto efx_min_depth() { return AL_CHORUS_MIN_DEPTH; }
+    static constexpr auto efx_min_feedback() { return AL_CHORUS_MIN_FEEDBACK; }
+    static constexpr auto efx_min_delay() { return AL_CHORUS_MIN_DELAY; }
+
+    static constexpr auto efx_max_waveform() { return AL_CHORUS_MAX_WAVEFORM; }
+    static constexpr auto efx_max_phase() { return AL_CHORUS_MAX_PHASE; }
+    static constexpr auto efx_max_rate() { return AL_CHORUS_MAX_RATE; }
+    static constexpr auto efx_max_depth() { return AL_CHORUS_MAX_DEPTH; }
+    static constexpr auto efx_max_feedback() { return AL_CHORUS_MAX_FEEDBACK; }
+    static constexpr auto efx_max_delay() { return AL_CHORUS_MAX_DELAY; }
+
+    static constexpr auto efx_default_waveform() { return AL_CHORUS_DEFAULT_WAVEFORM; }
+    static constexpr auto efx_default_phase() { return AL_CHORUS_DEFAULT_PHASE; }
+    static constexpr auto efx_default_rate() { return AL_CHORUS_DEFAULT_RATE; }
+    static constexpr auto efx_default_depth() { return AL_CHORUS_DEFAULT_DEPTH; }
+    static constexpr auto efx_default_feedback() { return AL_CHORUS_DEFAULT_FEEDBACK; }
+    static constexpr auto efx_default_delay() { return AL_CHORUS_DEFAULT_DELAY; }
+
+    static ChorusWaveform eax_waveform(unsigned long type)
+    {
+        if(type == EAX_CHORUS_SINUSOID) return ChorusWaveform::Sinusoid;
+        if(type == EAX_CHORUS_TRIANGLE) return ChorusWaveform::Triangle;
+        return ChorusWaveform::Sinusoid;
+    }
+}; // EaxChorusTraits
+
+struct EaxFlangerTraits {
+    using Props = EAXFLANGERPROPERTIES;
+    using Committer = EaxFlangerCommitter;
+    static constexpr auto Field = &EaxEffectProps::mFlanger;
+
+    static constexpr auto eax_effect_type() { return EaxEffectType::Flanger; }
+    static constexpr auto efx_effect() { return AL_EFFECT_FLANGER; }
+
+    static constexpr auto eax_none_param_id() { return EAXFLANGER_NONE; }
+    static constexpr auto eax_allparameters_param_id() { return EAXFLANGER_ALLPARAMETERS; }
+    static constexpr auto eax_waveform_param_id() { return EAXFLANGER_WAVEFORM; }
+    static constexpr auto eax_phase_param_id() { return EAXFLANGER_PHASE; }
+    static constexpr auto eax_rate_param_id() { return EAXFLANGER_RATE; }
+    static constexpr auto eax_depth_param_id() { return EAXFLANGER_DEPTH; }
+    static constexpr auto eax_feedback_param_id() { return EAXFLANGER_FEEDBACK; }
+    static constexpr auto eax_delay_param_id() { return EAXFLANGER_DELAY; }
+
+    static constexpr auto eax_min_waveform() { return EAXFLANGER_MINWAVEFORM; }
+    static constexpr auto eax_min_phase() { return EAXFLANGER_MINPHASE; }
+    static constexpr auto eax_min_rate() { return EAXFLANGER_MINRATE; }
+    static constexpr auto eax_min_depth() { return EAXFLANGER_MINDEPTH; }
+    static constexpr auto eax_min_feedback() { return EAXFLANGER_MINFEEDBACK; }
+    static constexpr auto eax_min_delay() { return EAXFLANGER_MINDELAY; }
+
+    static constexpr auto eax_max_waveform() { return EAXFLANGER_MAXWAVEFORM; }
+    static constexpr auto eax_max_phase() { return EAXFLANGER_MAXPHASE; }
+    static constexpr auto eax_max_rate() { return EAXFLANGER_MAXRATE; }
+    static constexpr auto eax_max_depth() { return EAXFLANGER_MAXDEPTH; }
+    static constexpr auto eax_max_feedback() { return EAXFLANGER_MAXFEEDBACK; }
+    static constexpr auto eax_max_delay() { return EAXFLANGER_MAXDELAY; }
+
+    static constexpr auto eax_default_waveform() { return EAXFLANGER_DEFAULTWAVEFORM; }
+    static constexpr auto eax_default_phase() { return EAXFLANGER_DEFAULTPHASE; }
+    static constexpr auto eax_default_rate() { return EAXFLANGER_DEFAULTRATE; }
+    static constexpr auto eax_default_depth() { return EAXFLANGER_DEFAULTDEPTH; }
+    static constexpr auto eax_default_feedback() { return EAXFLANGER_DEFAULTFEEDBACK; }
+    static constexpr auto eax_default_delay() { return EAXFLANGER_DEFAULTDELAY; }
+
+    static constexpr auto efx_min_waveform() { return AL_FLANGER_MIN_WAVEFORM; }
+    static constexpr auto efx_min_phase() { return AL_FLANGER_MIN_PHASE; }
+    static constexpr auto efx_min_rate() { return AL_FLANGER_MIN_RATE; }
+    static constexpr auto efx_min_depth() { return AL_FLANGER_MIN_DEPTH; }
+    static constexpr auto efx_min_feedback() { return AL_FLANGER_MIN_FEEDBACK; }
+    static constexpr auto efx_min_delay() { return AL_FLANGER_MIN_DELAY; }
+
+    static constexpr auto efx_max_waveform() { return AL_FLANGER_MAX_WAVEFORM; }
+    static constexpr auto efx_max_phase() { return AL_FLANGER_MAX_PHASE; }
+    static constexpr auto efx_max_rate() { return AL_FLANGER_MAX_RATE; }
+    static constexpr auto efx_max_depth() { return AL_FLANGER_MAX_DEPTH; }
+    static constexpr auto efx_max_feedback() { return AL_FLANGER_MAX_FEEDBACK; }
+    static constexpr auto efx_max_delay() { return AL_FLANGER_MAX_DELAY; }
+
+    static constexpr auto efx_default_waveform() { return AL_FLANGER_DEFAULT_WAVEFORM; }
+    static constexpr auto efx_default_phase() { return AL_FLANGER_DEFAULT_PHASE; }
+    static constexpr auto efx_default_rate() { return AL_FLANGER_DEFAULT_RATE; }
+    static constexpr auto efx_default_depth() { return AL_FLANGER_DEFAULT_DEPTH; }
+    static constexpr auto efx_default_feedback() { return AL_FLANGER_DEFAULT_FEEDBACK; }
+    static constexpr auto efx_default_delay() { return AL_FLANGER_DEFAULT_DELAY; }
+
+    static ChorusWaveform eax_waveform(unsigned long type)
+    {
+        if(type == EAX_FLANGER_SINUSOID) return ChorusWaveform::Sinusoid;
+        if(type == EAX_FLANGER_TRIANGLE) return ChorusWaveform::Triangle;
+        return ChorusWaveform::Sinusoid;
+    }
+}; // EaxFlangerTraits
+
+template<typename TTraits>
+struct ChorusFlangerEffect {
+    using Traits = TTraits;
+    using Committer = typename Traits::Committer;
+    using Exception = typename Committer::Exception;
+
+    static constexpr auto Field = Traits::Field;
+
+    struct WaveformValidator {
+        void operator()(unsigned long ulWaveform) const
+        {
+            eax_validate_range<Exception>(
+                "Waveform",
+                ulWaveform,
+                Traits::eax_min_waveform(),
+                Traits::eax_max_waveform());
+        }
+    }; // WaveformValidator
+
+    struct PhaseValidator {
+        void operator()(long lPhase) const
+        {
+            eax_validate_range<Exception>(
+                "Phase",
+                lPhase,
+                Traits::eax_min_phase(),
+                Traits::eax_max_phase());
+        }
+    }; // PhaseValidator
+
+    struct RateValidator {
+        void operator()(float flRate) const
+        {
+            eax_validate_range<Exception>(
+                "Rate",
+                flRate,
+                Traits::eax_min_rate(),
+                Traits::eax_max_rate());
+        }
+    }; // RateValidator
+
+    struct DepthValidator {
+        void operator()(float flDepth) const
+        {
+            eax_validate_range<Exception>(
+                "Depth",
+                flDepth,
+                Traits::eax_min_depth(),
+                Traits::eax_max_depth());
+        }
+    }; // DepthValidator
+
+    struct FeedbackValidator {
+        void operator()(float flFeedback) const
+        {
+            eax_validate_range<Exception>(
+                "Feedback",
+                flFeedback,
+                Traits::eax_min_feedback(),
+                Traits::eax_max_feedback());
+        }
+    }; // FeedbackValidator
+
+    struct DelayValidator {
+        void operator()(float flDelay) const
+        {
+            eax_validate_range<Exception>(
+                "Delay",
+                flDelay,
+                Traits::eax_min_delay(),
+                Traits::eax_max_delay());
+        }
+    }; // DelayValidator
+
+    struct AllValidator {
+        void operator()(const typename Traits::Props& all) const
+        {
+            WaveformValidator{}(all.ulWaveform);
+            PhaseValidator{}(all.lPhase);
+            RateValidator{}(all.flRate);
+            DepthValidator{}(all.flDepth);
+            FeedbackValidator{}(all.flFeedback);
+            DelayValidator{}(all.flDelay);
+        }
+    }; // AllValidator
+
+public:
+    static void SetDefaults(EaxEffectProps &props)
+    {
+        auto&& all = props.*Field;
+        props.mType = Traits::eax_effect_type();
+        all.ulWaveform = Traits::eax_default_waveform();
+        all.lPhase = Traits::eax_default_phase();
+        all.flRate = Traits::eax_default_rate();
+        all.flDepth = Traits::eax_default_depth();
+        all.flFeedback = Traits::eax_default_feedback();
+        all.flDelay = Traits::eax_default_delay();
+    }
+
+
+    static void Get(const EaxCall &call, const EaxEffectProps &props)
+    {
+        auto&& all = props.*Field;
+        switch(call.get_property_id())
+        {
+        case Traits::eax_none_param_id():
+            break;
+
+        case Traits::eax_allparameters_param_id():
+            call.template set_value<Exception>(all);
+            break;
+
+        case Traits::eax_waveform_param_id():
+            call.template set_value<Exception>(all.ulWaveform);
+            break;
+
+        case Traits::eax_phase_param_id():
+            call.template set_value<Exception>(all.lPhase);
+            break;
+
+        case Traits::eax_rate_param_id():
+            call.template set_value<Exception>(all.flRate);
+            break;
+
+        case Traits::eax_depth_param_id():
+            call.template set_value<Exception>(all.flDepth);
+            break;
+
+        case Traits::eax_feedback_param_id():
+            call.template set_value<Exception>(all.flFeedback);
+            break;
+
+        case Traits::eax_delay_param_id():
+            call.template set_value<Exception>(all.flDelay);
+            break;
+
+        default:
+            Committer::fail_unknown_property_id();
+        }
+    }
+
+    static void Set(const EaxCall &call, EaxEffectProps &props)
+    {
+        auto&& all = props.*Field;
+        switch(call.get_property_id())
+        {
+        case Traits::eax_none_param_id():
+            break;
+
+        case Traits::eax_allparameters_param_id():
+            Committer::template defer<AllValidator>(call, all);
+            break;
+
+        case Traits::eax_waveform_param_id():
+            Committer::template defer<WaveformValidator>(call, all.ulWaveform);
+            break;
+
+        case Traits::eax_phase_param_id():
+            Committer::template defer<PhaseValidator>(call, all.lPhase);
+            break;
+
+        case Traits::eax_rate_param_id():
+            Committer::template defer<RateValidator>(call, all.flRate);
+            break;
+
+        case Traits::eax_depth_param_id():
+            Committer::template defer<DepthValidator>(call, all.flDepth);
+            break;
+
+        case Traits::eax_feedback_param_id():
+            Committer::template defer<FeedbackValidator>(call, all.flFeedback);
+            break;
+
+        case Traits::eax_delay_param_id():
+            Committer::template defer<DelayValidator>(call, all.flDelay);
+            break;
+
+        default:
+            Committer::fail_unknown_property_id();
+        }
+    }
+
+    static bool Commit(const EaxEffectProps &props, EaxEffectProps &props_, EffectProps &al_props_)
+    {
+        if(props.mType == props_.mType)
+        {
+            auto&& src = props_.*Field;
+            auto&& dst = props.*Field;
+            if(dst.ulWaveform == src.ulWaveform && dst.lPhase == src.lPhase
+                && dst.flRate == src.flRate && dst.flDepth == src.flDepth
+                && dst.flFeedback == src.flFeedback && dst.flDelay == src.flDelay)
+                return false;
+        }
+
+        props_ = props;
+        auto&& dst = props.*Field;
+
+        al_props_.Chorus.Waveform = Traits::eax_waveform(dst.ulWaveform);
+        al_props_.Chorus.Phase = static_cast<int>(dst.lPhase);
+        al_props_.Chorus.Rate = dst.flRate;
+        al_props_.Chorus.Depth = dst.flDepth;
+        al_props_.Chorus.Feedback = dst.flFeedback;
+        al_props_.Chorus.Delay = dst.flDelay;
+
+        return true;
+    }
+}; // EaxChorusFlangerEffect
+
+
+using ChorusCommitter = EaxCommitter<EaxChorusCommitter>;
+using FlangerCommitter = EaxCommitter<EaxFlangerCommitter>;
+
+} // namespace
+
+template<>
+struct ChorusCommitter::Exception : public EaxException
+{
+    explicit Exception(const char *message) : EaxException{"EAX_CHORUS_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void ChorusCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool ChorusCommitter::commit(const EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxChorusTraits>;
+    return Committer::Commit(props, mEaxProps, mAlProps);
+}
+
+template<>
+void ChorusCommitter::SetDefaults(EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxChorusTraits>;
+    Committer::SetDefaults(props);
+}
+
+template<>
+void ChorusCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxChorusTraits>;
+    Committer::Get(call, props);
+}
+
+template<>
+void ChorusCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxChorusTraits>;
+    Committer::Set(call, props);
+}
+
+template<>
+struct FlangerCommitter::Exception : public EaxException
+{
+    explicit Exception(const char *message) : EaxException{"EAX_FLANGER_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void FlangerCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool FlangerCommitter::commit(const EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxFlangerTraits>;
+    return Committer::Commit(props, mEaxProps, mAlProps);
+}
+
+template<>
+void FlangerCommitter::SetDefaults(EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxFlangerTraits>;
+    Committer::SetDefaults(props);
+}
+
+template<>
+void FlangerCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxFlangerTraits>;
+    Committer::Get(call, props);
+}
+
+template<>
+void FlangerCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    using Committer = ChorusFlangerEffect<EaxFlangerTraits>;
+    Committer::Set(call, props);
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/compressor.cpp b/al/effects/compressor.cpp
new file mode 100644
index 00000000..a4aa8e77
--- /dev/null
+++ b/al/effects/compressor.cpp
@@ -0,0 +1,162 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using CompressorCommitter = EaxCommitter<EaxCompressorCommitter>;
+
+struct OnOffValidator {
+    void operator()(unsigned long ulOnOff) const
+    {
+        eax_validate_range<CompressorCommitter::Exception>(
+            "On-Off",
+            ulOnOff,
+            EAXAGCCOMPRESSOR_MINONOFF,
+            EAXAGCCOMPRESSOR_MAXONOFF);
+    }
+}; // OnOffValidator
+
+struct AllValidator {
+    void operator()(const EAXAGCCOMPRESSORPROPERTIES& all) const
+    {
+        OnOffValidator{}(all.ulOnOff);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct CompressorCommitter::Exception : public EaxException
+{
+    explicit Exception(const char *message) : EaxException{"EAX_CHORUS_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void CompressorCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool CompressorCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && props.mCompressor.ulOnOff == mEaxProps.mCompressor.ulOnOff)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Compressor.OnOff = (props.mCompressor.ulOnOff != 0);
+    return true;
+}
+
+template<>
+void CompressorCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Compressor;
+    props.mCompressor.ulOnOff = EAXAGCCOMPRESSOR_DEFAULTONOFF;
+}
+
+template<>
+void CompressorCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXAGCCOMPRESSOR_NONE: break;
+    case EAXAGCCOMPRESSOR_ALLPARAMETERS: call.set_value<Exception>(props.mCompressor); break;
+    case EAXAGCCOMPRESSOR_ONOFF: call.set_value<Exception>(props.mCompressor.ulOnOff); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void CompressorCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXAGCCOMPRESSOR_NONE: break;
+    case EAXAGCCOMPRESSOR_ALLPARAMETERS: defer<AllValidator>(call, props.mCompressor); break;
+    case EAXAGCCOMPRESSOR_ONOFF: defer<OnOffValidator>(call, props.mCompressor.ulOnOff); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/convolution.cpp b/al/effects/convolution.cpp
new file mode 100644
index 00000000..8e850fd3
--- /dev/null
+++ b/al/effects/convolution.cpp
@@ -0,0 +1,93 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "alc/inprogext.h"
+
+#include "alc/effects/base.h"
+#include "effects.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()};
diff --git a/al/effects/dedicated.cpp b/al/effects/dedicated.cpp
new file mode 100644
index 00000000..db57003c
--- /dev/null
+++ b/al/effects/dedicated.cpp
@@ -0,0 +1,72 @@
+
+#include "config.h"
+
+#include <cmath>
+
+#include "AL/al.h"
+#include "AL/alext.h"
+
+#include "alc/effects/base.h"
+#include "effects.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()};
diff --git a/al/effects/distortion.cpp b/al/effects/distortion.cpp
new file mode 100644
index 00000000..ee298ddf
--- /dev/null
+++ b/al/effects/distortion.cpp
@@ -0,0 +1,271 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using DistortionCommitter = EaxCommitter<EaxDistortionCommitter>;
+
+struct EdgeValidator {
+    void operator()(float flEdge) const
+    {
+        eax_validate_range<DistortionCommitter::Exception>(
+            "Edge",
+            flEdge,
+            EAXDISTORTION_MINEDGE,
+            EAXDISTORTION_MAXEDGE);
+    }
+}; // EdgeValidator
+
+struct GainValidator {
+    void operator()(long lGain) const
+    {
+        eax_validate_range<DistortionCommitter::Exception>(
+            "Gain",
+            lGain,
+            EAXDISTORTION_MINGAIN,
+            EAXDISTORTION_MAXGAIN);
+    }
+}; // GainValidator
+
+struct LowPassCutOffValidator {
+    void operator()(float flLowPassCutOff) const
+    {
+        eax_validate_range<DistortionCommitter::Exception>(
+            "Low-pass Cut-off",
+            flLowPassCutOff,
+            EAXDISTORTION_MINLOWPASSCUTOFF,
+            EAXDISTORTION_MAXLOWPASSCUTOFF);
+    }
+}; // LowPassCutOffValidator
+
+struct EqCenterValidator {
+    void operator()(float flEQCenter) const
+    {
+        eax_validate_range<DistortionCommitter::Exception>(
+            "EQ Center",
+            flEQCenter,
+            EAXDISTORTION_MINEQCENTER,
+            EAXDISTORTION_MAXEQCENTER);
+    }
+}; // EqCenterValidator
+
+struct EqBandwidthValidator {
+    void operator()(float flEQBandwidth) const
+    {
+        eax_validate_range<DistortionCommitter::Exception>(
+            "EQ Bandwidth",
+            flEQBandwidth,
+            EAXDISTORTION_MINEQBANDWIDTH,
+            EAXDISTORTION_MAXEQBANDWIDTH);
+    }
+}; // EqBandwidthValidator
+
+struct AllValidator {
+    void operator()(const EAXDISTORTIONPROPERTIES& all) const
+    {
+        EdgeValidator{}(all.flEdge);
+        GainValidator{}(all.lGain);
+        LowPassCutOffValidator{}(all.flLowPassCutOff);
+        EqCenterValidator{}(all.flEQCenter);
+        EqBandwidthValidator{}(all.flEQBandwidth);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct DistortionCommitter::Exception : public EaxException {
+    explicit Exception(const char *message) : EaxException{"EAX_DISTORTION_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void DistortionCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool DistortionCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType && mEaxProps.mDistortion.flEdge == props.mDistortion.flEdge
+        && mEaxProps.mDistortion.lGain == props.mDistortion.lGain
+        && mEaxProps.mDistortion.flLowPassCutOff == props.mDistortion.flLowPassCutOff
+        && mEaxProps.mDistortion.flEQCenter == props.mDistortion.flEQCenter
+        && mEaxProps.mDistortion.flEQBandwidth == props.mDistortion.flEQBandwidth)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Distortion.Edge = props.mDistortion.flEdge;
+    mAlProps.Distortion.Gain = level_mb_to_gain(static_cast<float>(props.mDistortion.lGain));
+    mAlProps.Distortion.LowpassCutoff = props.mDistortion.flLowPassCutOff;
+    mAlProps.Distortion.EQCenter = props.mDistortion.flEQCenter;
+    mAlProps.Distortion.EQBandwidth = props.mDistortion.flEdge;
+
+    return true;
+}
+
+template<>
+void DistortionCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Distortion;
+    props.mDistortion.flEdge = EAXDISTORTION_DEFAULTEDGE;
+    props.mDistortion.lGain = EAXDISTORTION_DEFAULTGAIN;
+    props.mDistortion.flLowPassCutOff = EAXDISTORTION_DEFAULTLOWPASSCUTOFF;
+    props.mDistortion.flEQCenter = EAXDISTORTION_DEFAULTEQCENTER;
+    props.mDistortion.flEQBandwidth = EAXDISTORTION_DEFAULTEQBANDWIDTH;
+}
+
+template<>
+void DistortionCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXDISTORTION_NONE: break;
+    case EAXDISTORTION_ALLPARAMETERS: call.set_value<Exception>(props.mDistortion); break;
+    case EAXDISTORTION_EDGE: call.set_value<Exception>(props.mDistortion.flEdge); break;
+    case EAXDISTORTION_GAIN: call.set_value<Exception>(props.mDistortion.lGain); break;
+    case EAXDISTORTION_LOWPASSCUTOFF: call.set_value<Exception>(props.mDistortion.flLowPassCutOff); break;
+    case EAXDISTORTION_EQCENTER: call.set_value<Exception>(props.mDistortion.flEQCenter); break;
+    case EAXDISTORTION_EQBANDWIDTH: call.set_value<Exception>(props.mDistortion.flEQBandwidth); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void DistortionCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXDISTORTION_NONE: break;
+    case EAXDISTORTION_ALLPARAMETERS: defer<AllValidator>(call, props.mDistortion); break;
+    case EAXDISTORTION_EDGE: defer<EdgeValidator>(call, props.mDistortion.flEdge); break;
+    case EAXDISTORTION_GAIN: defer<GainValidator>(call, props.mDistortion.lGain); break;
+    case EAXDISTORTION_LOWPASSCUTOFF: defer<LowPassCutOffValidator>(call, props.mDistortion.flLowPassCutOff); break;
+    case EAXDISTORTION_EQCENTER: defer<EqCenterValidator>(call, props.mDistortion.flEQCenter); break;
+    case EAXDISTORTION_EQBANDWIDTH: defer<EqBandwidthValidator>(call, props.mDistortion.flEQBandwidth); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/echo.cpp b/al/effects/echo.cpp
new file mode 100644
index 00000000..2eb37603
--- /dev/null
+++ b/al/effects/echo.cpp
@@ -0,0 +1,268 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using EchoCommitter = EaxCommitter<EaxEchoCommitter>;
+
+struct DelayValidator {
+    void operator()(float flDelay) const
+    {
+        eax_validate_range<EchoCommitter::Exception>(
+            "Delay",
+            flDelay,
+            EAXECHO_MINDELAY,
+            EAXECHO_MAXDELAY);
+    }
+}; // DelayValidator
+
+struct LrDelayValidator {
+    void operator()(float flLRDelay) const
+    {
+        eax_validate_range<EchoCommitter::Exception>(
+            "LR Delay",
+            flLRDelay,
+            EAXECHO_MINLRDELAY,
+            EAXECHO_MAXLRDELAY);
+    }
+}; // LrDelayValidator
+
+struct DampingValidator {
+    void operator()(float flDamping) const
+    {
+        eax_validate_range<EchoCommitter::Exception>(
+            "Damping",
+            flDamping,
+            EAXECHO_MINDAMPING,
+            EAXECHO_MAXDAMPING);
+    }
+}; // DampingValidator
+
+struct FeedbackValidator {
+    void operator()(float flFeedback) const
+    {
+        eax_validate_range<EchoCommitter::Exception>(
+            "Feedback",
+            flFeedback,
+            EAXECHO_MINFEEDBACK,
+            EAXECHO_MAXFEEDBACK);
+    }
+}; // FeedbackValidator
+
+struct SpreadValidator {
+    void operator()(float flSpread) const
+    {
+        eax_validate_range<EchoCommitter::Exception>(
+            "Spread",
+            flSpread,
+            EAXECHO_MINSPREAD,
+            EAXECHO_MAXSPREAD);
+    }
+}; // SpreadValidator
+
+struct AllValidator {
+    void operator()(const EAXECHOPROPERTIES& all) const
+    {
+        DelayValidator{}(all.flDelay);
+        LrDelayValidator{}(all.flLRDelay);
+        DampingValidator{}(all.flDamping);
+        FeedbackValidator{}(all.flFeedback);
+        SpreadValidator{}(all.flSpread);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct EchoCommitter::Exception : public EaxException {
+    explicit Exception(const char* message) : EaxException{"EAX_ECHO_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void EchoCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool EchoCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType && mEaxProps.mEcho.flDelay == props.mEcho.flDelay
+        && mEaxProps.mEcho.flLRDelay == props.mEcho.flLRDelay
+        && mEaxProps.mEcho.flDamping == props.mEcho.flDamping
+        && mEaxProps.mEcho.flFeedback == props.mEcho.flFeedback
+        && mEaxProps.mEcho.flSpread == props.mEcho.flSpread)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Echo.Delay = props.mEcho.flDelay;
+    mAlProps.Echo.LRDelay = props.mEcho.flLRDelay;
+    mAlProps.Echo.Damping = props.mEcho.flDamping;
+    mAlProps.Echo.Feedback = props.mEcho.flFeedback;
+    mAlProps.Echo.Spread = props.mEcho.flSpread;
+
+    return true;
+}
+
+template<>
+void EchoCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Echo;
+    props.mEcho.flDelay = EAXECHO_DEFAULTDELAY;
+    props.mEcho.flLRDelay = EAXECHO_DEFAULTLRDELAY;
+    props.mEcho.flDamping = EAXECHO_DEFAULTDAMPING;
+    props.mEcho.flFeedback = EAXECHO_DEFAULTFEEDBACK;
+    props.mEcho.flSpread = EAXECHO_DEFAULTSPREAD;
+}
+
+template<>
+void EchoCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXECHO_NONE: break;
+    case EAXECHO_ALLPARAMETERS: call.set_value<Exception>(props.mEcho); break;
+    case EAXECHO_DELAY: call.set_value<Exception>(props.mEcho.flDelay); break;
+    case EAXECHO_LRDELAY: call.set_value<Exception>(props.mEcho.flLRDelay); break;
+    case EAXECHO_DAMPING: call.set_value<Exception>(props.mEcho.flDamping); break;
+    case EAXECHO_FEEDBACK: call.set_value<Exception>(props.mEcho.flFeedback); break;
+    case EAXECHO_SPREAD: call.set_value<Exception>(props.mEcho.flSpread); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void EchoCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXECHO_NONE: break;
+    case EAXECHO_ALLPARAMETERS: defer<AllValidator>(call, props.mEcho); break;
+    case EAXECHO_DELAY: defer<DelayValidator>(call, props.mEcho.flDelay); break;
+    case EAXECHO_LRDELAY: defer<LrDelayValidator>(call, props.mEcho.flLRDelay); break;
+    case EAXECHO_DAMPING: defer<DampingValidator>(call, props.mEcho.flDamping); break;
+    case EAXECHO_FEEDBACK: defer<FeedbackValidator>(call, props.mEcho.flFeedback); break;
+    case EAXECHO_SPREAD: defer<SpreadValidator>(call, props.mEcho.flSpread); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/effects.cpp b/al/effects/effects.cpp
new file mode 100644
index 00000000..4a67b5ff
--- /dev/null
+++ b/al/effects/effects.cpp
@@ -0,0 +1,9 @@
+#include "config.h"
+
+#ifdef ALSOFT_EAX
+
+#include <cassert>
+#include "AL/efx.h"
+#include "effects.h"
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/effects.h b/al/effects/effects.h
new file mode 100644
index 00000000..9d57dd82
--- /dev/null
+++ b/al/effects/effects.h
@@ -0,0 +1,88 @@
+#ifndef AL_EFFECTS_EFFECTS_H
+#define AL_EFFECTS_EFFECTS_H
+
+#include "AL/al.h"
+
+#include "core/except.h"
+
+#ifdef ALSOFT_EAX
+#include "al/eax/effect.h"
+#endif // ALSOFT_EAX
+
+union EffectProps;
+
+
+class effect_exception final : public al::base_exception {
+    ALenum mErrorCode;
+
+public:
+#ifdef __USE_MINGW_ANSI_STDIO
+    [[gnu::format(gnu_printf, 3, 4)]]
+#else
+    [[gnu::format(printf, 3, 4)]]
+#endif
+    effect_exception(ALenum code, const char *msg, ...);
+    ~effect_exception() override;
+
+    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 */
diff --git a/al/effects/equalizer.cpp b/al/effects/equalizer.cpp
new file mode 100644
index 00000000..7dc703db
--- /dev/null
+++ b/al/effects/equalizer.cpp
@@ -0,0 +1,411 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using EqualizerCommitter = EaxCommitter<EaxEqualizerCommitter>;
+
+struct LowGainValidator {
+    void operator()(long lLowGain) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Low Gain",
+            lLowGain,
+            EAXEQUALIZER_MINLOWGAIN,
+            EAXEQUALIZER_MAXLOWGAIN);
+    }
+}; // LowGainValidator
+
+struct LowCutOffValidator {
+    void operator()(float flLowCutOff) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Low Cutoff",
+            flLowCutOff,
+            EAXEQUALIZER_MINLOWCUTOFF,
+            EAXEQUALIZER_MAXLOWCUTOFF);
+    }
+}; // LowCutOffValidator
+
+struct Mid1GainValidator {
+    void operator()(long lMid1Gain) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid1 Gain",
+            lMid1Gain,
+            EAXEQUALIZER_MINMID1GAIN,
+            EAXEQUALIZER_MAXMID1GAIN);
+    }
+}; // Mid1GainValidator
+
+struct Mid1CenterValidator {
+    void operator()(float flMid1Center) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid1 Center",
+            flMid1Center,
+            EAXEQUALIZER_MINMID1CENTER,
+            EAXEQUALIZER_MAXMID1CENTER);
+    }
+}; // Mid1CenterValidator
+
+struct Mid1WidthValidator {
+    void operator()(float flMid1Width) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid1 Width",
+            flMid1Width,
+            EAXEQUALIZER_MINMID1WIDTH,
+            EAXEQUALIZER_MAXMID1WIDTH);
+    }
+}; // Mid1WidthValidator
+
+struct Mid2GainValidator {
+    void operator()(long lMid2Gain) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid2 Gain",
+            lMid2Gain,
+            EAXEQUALIZER_MINMID2GAIN,
+            EAXEQUALIZER_MAXMID2GAIN);
+    }
+}; // Mid2GainValidator
+
+struct Mid2CenterValidator {
+    void operator()(float flMid2Center) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid2 Center",
+            flMid2Center,
+            EAXEQUALIZER_MINMID2CENTER,
+            EAXEQUALIZER_MAXMID2CENTER);
+    }
+}; // Mid2CenterValidator
+
+struct Mid2WidthValidator {
+    void operator()(float flMid2Width) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "Mid2 Width",
+            flMid2Width,
+            EAXEQUALIZER_MINMID2WIDTH,
+            EAXEQUALIZER_MAXMID2WIDTH);
+    }
+}; // Mid2WidthValidator
+
+struct HighGainValidator {
+    void operator()(long lHighGain) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "High Gain",
+            lHighGain,
+            EAXEQUALIZER_MINHIGHGAIN,
+            EAXEQUALIZER_MAXHIGHGAIN);
+    }
+}; // HighGainValidator
+
+struct HighCutOffValidator {
+    void operator()(float flHighCutOff) const
+    {
+        eax_validate_range<EqualizerCommitter::Exception>(
+            "High Cutoff",
+            flHighCutOff,
+            EAXEQUALIZER_MINHIGHCUTOFF,
+            EAXEQUALIZER_MAXHIGHCUTOFF);
+    }
+}; // HighCutOffValidator
+
+struct AllValidator {
+    void operator()(const EAXEQUALIZERPROPERTIES& all) const
+    {
+        LowGainValidator{}(all.lLowGain);
+        LowCutOffValidator{}(all.flLowCutOff);
+        Mid1GainValidator{}(all.lMid1Gain);
+        Mid1CenterValidator{}(all.flMid1Center);
+        Mid1WidthValidator{}(all.flMid1Width);
+        Mid2GainValidator{}(all.lMid2Gain);
+        Mid2CenterValidator{}(all.flMid2Center);
+        Mid2WidthValidator{}(all.flMid2Width);
+        HighGainValidator{}(all.lHighGain);
+        HighCutOffValidator{}(all.flHighCutOff);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct EqualizerCommitter::Exception : public EaxException {
+    explicit Exception(const char* message) : EaxException{"EAX_EQUALIZER_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void EqualizerCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool EqualizerCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType && mEaxProps.mEqualizer.lLowGain == props.mEqualizer.lLowGain
+        && mEaxProps.mEqualizer.flLowCutOff == props.mEqualizer.flLowCutOff
+        && mEaxProps.mEqualizer.lMid1Gain == props.mEqualizer.lMid1Gain
+        && mEaxProps.mEqualizer.flMid1Center == props.mEqualizer.flMid1Center
+        && mEaxProps.mEqualizer.flMid1Width == props.mEqualizer.flMid1Width
+        && mEaxProps.mEqualizer.lMid2Gain == props.mEqualizer.lMid2Gain
+        && mEaxProps.mEqualizer.flMid2Center == props.mEqualizer.flMid2Center
+        && mEaxProps.mEqualizer.flMid2Width == props.mEqualizer.flMid2Width
+        && mEaxProps.mEqualizer.lHighGain == props.mEqualizer.lHighGain
+        && mEaxProps.mEqualizer.flHighCutOff == props.mEqualizer.flHighCutOff)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Equalizer.LowGain = level_mb_to_gain(static_cast<float>(props.mEqualizer.lLowGain));
+    mAlProps.Equalizer.LowCutoff = props.mEqualizer.flLowCutOff;
+    mAlProps.Equalizer.Mid1Gain = level_mb_to_gain(static_cast<float>(props.mEqualizer.lMid1Gain));
+    mAlProps.Equalizer.Mid1Center = props.mEqualizer.flMid1Center;
+    mAlProps.Equalizer.Mid1Width = props.mEqualizer.flMid1Width;
+    mAlProps.Equalizer.Mid2Gain = level_mb_to_gain(static_cast<float>(props.mEqualizer.lMid2Gain));
+    mAlProps.Equalizer.Mid2Center = props.mEqualizer.flMid2Center;
+    mAlProps.Equalizer.Mid2Width = props.mEqualizer.flMid2Width;
+    mAlProps.Equalizer.HighGain = level_mb_to_gain(static_cast<float>(props.mEqualizer.lHighGain));
+    mAlProps.Equalizer.HighCutoff = props.mEqualizer.flHighCutOff;
+
+    return true;
+}
+
+template<>
+void EqualizerCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Equalizer;
+    props.mEqualizer.lLowGain = EAXEQUALIZER_DEFAULTLOWGAIN;
+    props.mEqualizer.flLowCutOff = EAXEQUALIZER_DEFAULTLOWCUTOFF;
+    props.mEqualizer.lMid1Gain = EAXEQUALIZER_DEFAULTMID1GAIN;
+    props.mEqualizer.flMid1Center = EAXEQUALIZER_DEFAULTMID1CENTER;
+    props.mEqualizer.flMid1Width = EAXEQUALIZER_DEFAULTMID1WIDTH;
+    props.mEqualizer.lMid2Gain = EAXEQUALIZER_DEFAULTMID2GAIN;
+    props.mEqualizer.flMid2Center = EAXEQUALIZER_DEFAULTMID2CENTER;
+    props.mEqualizer.flMid2Width = EAXEQUALIZER_DEFAULTMID2WIDTH;
+    props.mEqualizer.lHighGain = EAXEQUALIZER_DEFAULTHIGHGAIN;
+    props.mEqualizer.flHighCutOff = EAXEQUALIZER_DEFAULTHIGHCUTOFF;
+}
+
+template<>
+void EqualizerCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXEQUALIZER_NONE: break;
+    case EAXEQUALIZER_ALLPARAMETERS: call.set_value<Exception>(props.mEqualizer); break;
+    case EAXEQUALIZER_LOWGAIN: call.set_value<Exception>(props.mEqualizer.lLowGain); break;
+    case EAXEQUALIZER_LOWCUTOFF: call.set_value<Exception>(props.mEqualizer.flLowCutOff); break;
+    case EAXEQUALIZER_MID1GAIN: call.set_value<Exception>(props.mEqualizer.lMid1Gain); break;
+    case EAXEQUALIZER_MID1CENTER: call.set_value<Exception>(props.mEqualizer.flMid1Center); break;
+    case EAXEQUALIZER_MID1WIDTH: call.set_value<Exception>(props.mEqualizer.flMid1Width); break;
+    case EAXEQUALIZER_MID2GAIN: call.set_value<Exception>(props.mEqualizer.lMid2Gain); break;
+    case EAXEQUALIZER_MID2CENTER: call.set_value<Exception>(props.mEqualizer.flMid2Center); break;
+    case EAXEQUALIZER_MID2WIDTH: call.set_value<Exception>(props.mEqualizer.flMid2Width); break;
+    case EAXEQUALIZER_HIGHGAIN: call.set_value<Exception>(props.mEqualizer.lHighGain); break;
+    case EAXEQUALIZER_HIGHCUTOFF: call.set_value<Exception>(props.mEqualizer.flHighCutOff); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void EqualizerCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXEQUALIZER_NONE: break;
+    case EAXEQUALIZER_ALLPARAMETERS: defer<AllValidator>(call, props.mEqualizer); break;
+    case EAXEQUALIZER_LOWGAIN: defer<LowGainValidator>(call, props.mEqualizer.lLowGain); break;
+    case EAXEQUALIZER_LOWCUTOFF: defer<LowCutOffValidator>(call, props.mEqualizer.flLowCutOff); break;
+    case EAXEQUALIZER_MID1GAIN: defer<Mid1GainValidator>(call, props.mEqualizer.lMid1Gain); break;
+    case EAXEQUALIZER_MID1CENTER: defer<Mid1CenterValidator>(call, props.mEqualizer.flMid1Center); break;
+    case EAXEQUALIZER_MID1WIDTH: defer<Mid1WidthValidator>(call, props.mEqualizer.flMid1Width); break;
+    case EAXEQUALIZER_MID2GAIN: defer<Mid2GainValidator>(call, props.mEqualizer.lMid2Gain); break;
+    case EAXEQUALIZER_MID2CENTER: defer<Mid2CenterValidator>(call, props.mEqualizer.flMid2Center); break;
+    case EAXEQUALIZER_MID2WIDTH: defer<Mid2WidthValidator>(call, props.mEqualizer.flMid2Width); break;
+    case EAXEQUALIZER_HIGHGAIN: defer<HighGainValidator>(call, props.mEqualizer.lHighGain); break;
+    case EAXEQUALIZER_HIGHCUTOFF: defer<HighCutOffValidator>(call, props.mEqualizer.flHighCutOff); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/fshifter.cpp b/al/effects/fshifter.cpp
new file mode 100644
index 00000000..949db203
--- /dev/null
+++ b/al/effects/fshifter.cpp
@@ -0,0 +1,264 @@
+
+#include "config.h"
+
+#include <stdexcept>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "aloptional.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include <cassert>
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+namespace {
+
+al::optional<FShifterDirection> DirectionFromEmum(ALenum value)
+{
+    switch(value)
+    {
+    case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN: return FShifterDirection::Down;
+    case AL_FREQUENCY_SHIFTER_DIRECTION_UP: return FShifterDirection::Up;
+    case AL_FREQUENCY_SHIFTER_DIRECTION_OFF: return 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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using FrequencyShifterCommitter = EaxCommitter<EaxFrequencyShifterCommitter>;
+
+struct FrequencyValidator {
+    void operator()(float flFrequency) const
+    {
+        eax_validate_range<FrequencyShifterCommitter::Exception>(
+            "Frequency",
+            flFrequency,
+            EAXFREQUENCYSHIFTER_MINFREQUENCY,
+            EAXFREQUENCYSHIFTER_MAXFREQUENCY);
+    }
+}; // FrequencyValidator
+
+struct LeftDirectionValidator {
+    void operator()(unsigned long ulLeftDirection) const
+    {
+        eax_validate_range<FrequencyShifterCommitter::Exception>(
+            "Left Direction",
+            ulLeftDirection,
+            EAXFREQUENCYSHIFTER_MINLEFTDIRECTION,
+            EAXFREQUENCYSHIFTER_MAXLEFTDIRECTION);
+    }
+}; // LeftDirectionValidator
+
+struct RightDirectionValidator {
+    void operator()(unsigned long ulRightDirection) const
+    {
+        eax_validate_range<FrequencyShifterCommitter::Exception>(
+            "Right Direction",
+            ulRightDirection,
+            EAXFREQUENCYSHIFTER_MINRIGHTDIRECTION,
+            EAXFREQUENCYSHIFTER_MAXRIGHTDIRECTION);
+    }
+}; // RightDirectionValidator
+
+struct AllValidator {
+    void operator()(const EAXFREQUENCYSHIFTERPROPERTIES& all) const
+    {
+        FrequencyValidator{}(all.flFrequency);
+        LeftDirectionValidator{}(all.ulLeftDirection);
+        RightDirectionValidator{}(all.ulRightDirection);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct FrequencyShifterCommitter::Exception : public EaxException {
+    explicit Exception(const char *message) : EaxException{"EAX_FREQUENCY_SHIFTER_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void FrequencyShifterCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool FrequencyShifterCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && mEaxProps.mFrequencyShifter.flFrequency == props.mFrequencyShifter.flFrequency
+        && mEaxProps.mFrequencyShifter.ulLeftDirection == props.mFrequencyShifter.ulLeftDirection
+        && mEaxProps.mFrequencyShifter.ulRightDirection == props.mFrequencyShifter.ulRightDirection)
+        return false;
+
+    mEaxProps = props;
+
+    auto get_direction = [](unsigned long dir) noexcept
+    {
+        if(dir == EAX_FREQUENCYSHIFTER_DOWN)
+            return FShifterDirection::Down;
+        if(dir == EAX_FREQUENCYSHIFTER_UP)
+            return FShifterDirection::Up;
+        return FShifterDirection::Off;
+    };
+
+    mAlProps.Fshifter.Frequency = props.mFrequencyShifter.flFrequency;
+    mAlProps.Fshifter.LeftDirection = get_direction(props.mFrequencyShifter.ulLeftDirection);
+    mAlProps.Fshifter.RightDirection = get_direction(props.mFrequencyShifter.ulRightDirection);
+
+    return true;
+}
+
+template<>
+void FrequencyShifterCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::FrequencyShifter;
+    props.mFrequencyShifter.flFrequency = EAXFREQUENCYSHIFTER_DEFAULTFREQUENCY;
+    props.mFrequencyShifter.ulLeftDirection = EAXFREQUENCYSHIFTER_DEFAULTLEFTDIRECTION;
+    props.mFrequencyShifter.ulRightDirection = EAXFREQUENCYSHIFTER_DEFAULTRIGHTDIRECTION;
+}
+
+template<>
+void FrequencyShifterCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXFREQUENCYSHIFTER_NONE: break;
+    case EAXFREQUENCYSHIFTER_ALLPARAMETERS: call.set_value<Exception>(props.mFrequencyShifter); break;
+    case EAXFREQUENCYSHIFTER_FREQUENCY: call.set_value<Exception>(props.mFrequencyShifter.flFrequency); break;
+    case EAXFREQUENCYSHIFTER_LEFTDIRECTION: call.set_value<Exception>(props.mFrequencyShifter.ulLeftDirection); break;
+    case EAXFREQUENCYSHIFTER_RIGHTDIRECTION: call.set_value<Exception>(props.mFrequencyShifter.ulRightDirection); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void FrequencyShifterCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXFREQUENCYSHIFTER_NONE: break;
+    case EAXFREQUENCYSHIFTER_ALLPARAMETERS: defer<AllValidator>(call, props.mFrequencyShifter); break;
+    case EAXFREQUENCYSHIFTER_FREQUENCY: defer<FrequencyValidator>(call, props.mFrequencyShifter.flFrequency); break;
+    case EAXFREQUENCYSHIFTER_LEFTDIRECTION: defer<LeftDirectionValidator>(call, props.mFrequencyShifter.ulLeftDirection); break;
+    case EAXFREQUENCYSHIFTER_RIGHTDIRECTION: defer<RightDirectionValidator>(call, props.mFrequencyShifter.ulRightDirection); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/modulator.cpp b/al/effects/modulator.cpp
new file mode 100644
index 00000000..5f37d08f
--- /dev/null
+++ b/al/effects/modulator.cpp
@@ -0,0 +1,272 @@
+
+#include "config.h"
+
+#include <stdexcept>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "aloptional.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include <cassert>
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+namespace {
+
+al::optional<ModulatorWaveform> WaveformFromEmum(ALenum value)
+{
+    switch(value)
+    {
+    case AL_RING_MODULATOR_SINUSOID: return ModulatorWaveform::Sinusoid;
+    case AL_RING_MODULATOR_SAWTOOTH: return ModulatorWaveform::Sawtooth;
+    case AL_RING_MODULATOR_SQUARE: return 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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using ModulatorCommitter = EaxCommitter<EaxModulatorCommitter>;
+
+struct FrequencyValidator {
+    void operator()(float flFrequency) const
+    {
+        eax_validate_range<ModulatorCommitter::Exception>(
+            "Frequency",
+            flFrequency,
+            EAXRINGMODULATOR_MINFREQUENCY,
+            EAXRINGMODULATOR_MAXFREQUENCY);
+    }
+}; // FrequencyValidator
+
+struct HighPassCutOffValidator {
+    void operator()(float flHighPassCutOff) const
+    {
+        eax_validate_range<ModulatorCommitter::Exception>(
+            "High-Pass Cutoff",
+            flHighPassCutOff,
+            EAXRINGMODULATOR_MINHIGHPASSCUTOFF,
+            EAXRINGMODULATOR_MAXHIGHPASSCUTOFF);
+    }
+}; // HighPassCutOffValidator
+
+struct WaveformValidator {
+    void operator()(unsigned long ulWaveform) const
+    {
+        eax_validate_range<ModulatorCommitter::Exception>(
+            "Waveform",
+            ulWaveform,
+            EAXRINGMODULATOR_MINWAVEFORM,
+            EAXRINGMODULATOR_MAXWAVEFORM);
+    }
+}; // WaveformValidator
+
+struct AllValidator {
+    void operator()(const EAXRINGMODULATORPROPERTIES& all) const
+    {
+        FrequencyValidator{}(all.flFrequency);
+        HighPassCutOffValidator{}(all.flHighPassCutOff);
+        WaveformValidator{}(all.ulWaveform);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct ModulatorCommitter::Exception : public EaxException {
+    explicit Exception(const char *message) : EaxException{"EAX_RING_MODULATOR_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void ModulatorCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool ModulatorCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && mEaxProps.mModulator.flFrequency == props.mModulator.flFrequency
+        && mEaxProps.mModulator.flHighPassCutOff == props.mModulator.flHighPassCutOff
+        && mEaxProps.mModulator.ulWaveform == props.mModulator.ulWaveform)
+        return false;
+
+    mEaxProps = props;
+
+    auto get_waveform = [](unsigned long form)
+    {
+        if(form == EAX_RINGMODULATOR_SINUSOID)
+            return ModulatorWaveform::Sinusoid;
+        if(form == EAX_RINGMODULATOR_SAWTOOTH)
+            return ModulatorWaveform::Sawtooth;
+        if(form == EAX_RINGMODULATOR_SQUARE)
+            return ModulatorWaveform::Square;
+        return ModulatorWaveform::Sinusoid;
+    };
+
+    mAlProps.Modulator.Frequency = props.mModulator.flFrequency;
+    mAlProps.Modulator.HighPassCutoff = props.mModulator.flHighPassCutOff;
+    mAlProps.Modulator.Waveform = get_waveform(props.mModulator.ulWaveform);
+
+    return true;
+}
+
+template<>
+void ModulatorCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Modulator;
+    props.mModulator.flFrequency = EAXRINGMODULATOR_DEFAULTFREQUENCY;
+    props.mModulator.flHighPassCutOff = EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF;
+    props.mModulator.ulWaveform = EAXRINGMODULATOR_DEFAULTWAVEFORM;
+}
+
+template<>
+void ModulatorCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXRINGMODULATOR_NONE: break;
+    case EAXRINGMODULATOR_ALLPARAMETERS: call.set_value<Exception>(props.mModulator); break;
+    case EAXRINGMODULATOR_FREQUENCY: call.set_value<Exception>(props.mModulator.flFrequency); break;
+    case EAXRINGMODULATOR_HIGHPASSCUTOFF: call.set_value<Exception>(props.mModulator.flHighPassCutOff); break;
+    case EAXRINGMODULATOR_WAVEFORM: call.set_value<Exception>(props.mModulator.ulWaveform); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void ModulatorCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch (call.get_property_id())
+    {
+    case EAXRINGMODULATOR_NONE: break;
+    case EAXRINGMODULATOR_ALLPARAMETERS: defer<AllValidator>(call, props.mModulator); break;
+    case EAXRINGMODULATOR_FREQUENCY: defer<FrequencyValidator>(call, props.mModulator.flFrequency); break;
+    case EAXRINGMODULATOR_HIGHPASSCUTOFF: defer<HighPassCutOffValidator>(call, props.mModulator.flHighPassCutOff); break;
+    case EAXRINGMODULATOR_WAVEFORM: defer<WaveformValidator>(call, props.mModulator.ulWaveform); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/null.cpp b/al/effects/null.cpp
new file mode 100644
index 00000000..0bbc183a
--- /dev/null
+++ b/al/effects/null.cpp
@@ -0,0 +1,149 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "al/eax/exception.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using NullCommitter = EaxCommitter<EaxNullCommitter>;
+
+} // namespace
+
+template<>
+struct NullCommitter::Exception : public EaxException
+{
+    explicit Exception(const char *message) : EaxException{"EAX_NULL_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void NullCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool NullCommitter::commit(const EaxEffectProps &props)
+{
+    const bool ret{props.mType != mEaxProps.mType};
+    mEaxProps = props;
+    return ret;
+}
+
+template<>
+void NullCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props = EaxEffectProps{};
+    props.mType = EaxEffectType::None;
+}
+
+template<>
+void NullCommitter::Get(const EaxCall &call, const EaxEffectProps&)
+{
+    if(call.get_property_id() != 0)
+        fail_unknown_property_id();
+}
+
+template<>
+void NullCommitter::Set(const EaxCall &call, EaxEffectProps&)
+{
+    if(call.get_property_id() != 0)
+        fail_unknown_property_id();
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/pshifter.cpp b/al/effects/pshifter.cpp
new file mode 100644
index 00000000..634eb186
--- /dev/null
+++ b/al/effects/pshifter.cpp
@@ -0,0 +1,191 @@
+
+#include "config.h"
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using PitchShifterCommitter = EaxCommitter<EaxPitchShifterCommitter>;
+
+struct CoarseTuneValidator {
+    void operator()(long lCoarseTune) const
+    {
+        eax_validate_range<PitchShifterCommitter::Exception>(
+            "Coarse Tune",
+            lCoarseTune,
+            EAXPITCHSHIFTER_MINCOARSETUNE,
+            EAXPITCHSHIFTER_MAXCOARSETUNE);
+    }
+}; // CoarseTuneValidator
+
+struct FineTuneValidator {
+    void operator()(long lFineTune) const
+    {
+        eax_validate_range<PitchShifterCommitter::Exception>(
+            "Fine Tune",
+            lFineTune,
+            EAXPITCHSHIFTER_MINFINETUNE,
+            EAXPITCHSHIFTER_MAXFINETUNE);
+    }
+}; // FineTuneValidator
+
+struct AllValidator {
+    void operator()(const EAXPITCHSHIFTERPROPERTIES& all) const
+    {
+        CoarseTuneValidator{}(all.lCoarseTune);
+        FineTuneValidator{}(all.lFineTune);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct PitchShifterCommitter::Exception : public EaxException {
+    explicit Exception(const char *message) : EaxException{"EAX_PITCH_SHIFTER_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void PitchShifterCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool PitchShifterCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && mEaxProps.mPitchShifter.lCoarseTune == props.mPitchShifter.lCoarseTune
+        && mEaxProps.mPitchShifter.lFineTune == props.mPitchShifter.lFineTune)
+        return false;
+
+    mEaxProps = props;
+
+    mAlProps.Pshifter.CoarseTune = static_cast<int>(mEaxProps.mPitchShifter.lCoarseTune);
+    mAlProps.Pshifter.FineTune = static_cast<int>(mEaxProps.mPitchShifter.lFineTune);
+
+    return true;
+}
+
+template<>
+void PitchShifterCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::PitchShifter;
+    props.mPitchShifter.lCoarseTune = EAXPITCHSHIFTER_DEFAULTCOARSETUNE;
+    props.mPitchShifter.lFineTune = EAXPITCHSHIFTER_DEFAULTFINETUNE;
+}
+
+template<>
+void PitchShifterCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXPITCHSHIFTER_NONE: break;
+    case EAXPITCHSHIFTER_ALLPARAMETERS: call.set_value<Exception>(props.mPitchShifter); break;
+    case EAXPITCHSHIFTER_COARSETUNE: call.set_value<Exception>(props.mPitchShifter.lCoarseTune); break;
+    case EAXPITCHSHIFTER_FINETUNE: call.set_value<Exception>(props.mPitchShifter.lFineTune); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+template<>
+void PitchShifterCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXPITCHSHIFTER_NONE: break;
+    case EAXPITCHSHIFTER_ALLPARAMETERS: defer<AllValidator>(call, props.mPitchShifter); break;
+    case EAXPITCHSHIFTER_COARSETUNE: defer<CoarseTuneValidator>(call, props.mPitchShifter.lCoarseTune); break;
+    case EAXPITCHSHIFTER_FINETUNE: defer<FineTuneValidator>(call, props.mPitchShifter.lFineTune); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/reverb.cpp b/al/effects/reverb.cpp
new file mode 100644
index 00000000..440d7b4e
--- /dev/null
+++ b/al/effects/reverb.cpp
@@ -0,0 +1,1499 @@
+
+#include "config.h"
+
+#include <cmath>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include <cassert>
+#include "alnumeric.h"
+#include "AL/efx-presets.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+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_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_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_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_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_AIR_ABSORPTION_GAINHF:
+        *val = props->Reverb.AirAbsorptionGainHF;
+        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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+class EaxReverbEffectException : public EaxException
+{
+public:
+    explicit EaxReverbEffectException(const char* message)
+        : EaxException{"EAX_REVERB_EFFECT", message}
+    {}
+}; // EaxReverbEffectException
+
+struct EnvironmentValidator1 {
+    void operator()(unsigned long ulEnvironment) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Environment",
+            ulEnvironment,
+            EAXREVERB_MINENVIRONMENT,
+            EAX1REVERB_MAXENVIRONMENT);
+    }
+}; // EnvironmentValidator1
+
+struct VolumeValidator {
+    void operator()(float volume) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Volume",
+            volume,
+            EAX1REVERB_MINVOLUME,
+            EAX1REVERB_MAXVOLUME);
+    }
+}; // VolumeValidator
+
+struct DecayTimeValidator {
+    void operator()(float flDecayTime) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Decay Time",
+            flDecayTime,
+            EAXREVERB_MINDECAYTIME,
+            EAXREVERB_MAXDECAYTIME);
+    }
+}; // DecayTimeValidator
+
+struct DampingValidator {
+    void operator()(float damping) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Damping",
+            damping,
+            EAX1REVERB_MINDAMPING,
+            EAX1REVERB_MAXDAMPING);
+    }
+}; // DampingValidator
+
+struct AllValidator1 {
+    void operator()(const EAX_REVERBPROPERTIES& all) const
+    {
+        EnvironmentValidator1{}(all.environment);
+        VolumeValidator{}(all.fVolume);
+        DecayTimeValidator{}(all.fDecayTime_sec);
+        DampingValidator{}(all.fDamping);
+    }
+}; // AllValidator1
+
+struct RoomValidator {
+    void operator()(long lRoom) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Room",
+            lRoom,
+            EAXREVERB_MINROOM,
+            EAXREVERB_MAXROOM);
+    }
+}; // RoomValidator
+
+struct RoomHFValidator {
+    void operator()(long lRoomHF) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Room HF",
+            lRoomHF,
+            EAXREVERB_MINROOMHF,
+            EAXREVERB_MAXROOMHF);
+    }
+}; // RoomHFValidator
+
+struct RoomRolloffFactorValidator {
+    void operator()(float flRoomRolloffFactor) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Room Rolloff Factor",
+            flRoomRolloffFactor,
+            EAXREVERB_MINROOMROLLOFFFACTOR,
+            EAXREVERB_MAXROOMROLLOFFFACTOR);
+    }
+}; // RoomRolloffFactorValidator
+
+struct DecayHFRatioValidator {
+    void operator()(float flDecayHFRatio) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Decay HF Ratio",
+            flDecayHFRatio,
+            EAXREVERB_MINDECAYHFRATIO,
+            EAXREVERB_MAXDECAYHFRATIO);
+    }
+}; // DecayHFRatioValidator
+
+struct ReflectionsValidator {
+    void operator()(long lReflections) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Reflections",
+            lReflections,
+            EAXREVERB_MINREFLECTIONS,
+            EAXREVERB_MAXREFLECTIONS);
+    }
+}; // ReflectionsValidator
+
+struct ReflectionsDelayValidator {
+    void operator()(float flReflectionsDelay) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Reflections Delay",
+            flReflectionsDelay,
+            EAXREVERB_MINREFLECTIONSDELAY,
+            EAXREVERB_MAXREFLECTIONSDELAY);
+    }
+}; // ReflectionsDelayValidator
+
+struct ReverbValidator {
+    void operator()(long lReverb) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Reverb",
+            lReverb,
+            EAXREVERB_MINREVERB,
+            EAXREVERB_MAXREVERB);
+    }
+}; // ReverbValidator
+
+struct ReverbDelayValidator {
+    void operator()(float flReverbDelay) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Reverb Delay",
+            flReverbDelay,
+            EAXREVERB_MINREVERBDELAY,
+            EAXREVERB_MAXREVERBDELAY);
+    }
+}; // ReverbDelayValidator
+
+struct EnvironmentSizeValidator {
+    void operator()(float flEnvironmentSize) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Environment Size",
+            flEnvironmentSize,
+            EAXREVERB_MINENVIRONMENTSIZE,
+            EAXREVERB_MAXENVIRONMENTSIZE);
+    }
+}; // EnvironmentSizeValidator
+
+struct EnvironmentDiffusionValidator {
+    void operator()(float flEnvironmentDiffusion) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Environment Diffusion",
+            flEnvironmentDiffusion,
+            EAXREVERB_MINENVIRONMENTDIFFUSION,
+            EAXREVERB_MAXENVIRONMENTDIFFUSION);
+    }
+}; // EnvironmentDiffusionValidator
+
+struct AirAbsorptionHFValidator {
+    void operator()(float flAirAbsorptionHF) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Air Absorbtion HF",
+            flAirAbsorptionHF,
+            EAXREVERB_MINAIRABSORPTIONHF,
+            EAXREVERB_MAXAIRABSORPTIONHF);
+    }
+}; // AirAbsorptionHFValidator
+
+struct FlagsValidator2 {
+    void operator()(unsigned long ulFlags) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Flags",
+            ulFlags,
+            0UL,
+            ~EAX2LISTENERFLAGS_RESERVED);
+    }
+}; // FlagsValidator2
+
+struct AllValidator2 {
+    void operator()(const EAX20LISTENERPROPERTIES& all) const
+    {
+        RoomValidator{}(all.lRoom);
+        RoomHFValidator{}(all.lRoomHF);
+        RoomRolloffFactorValidator{}(all.flRoomRolloffFactor);
+        DecayTimeValidator{}(all.flDecayTime);
+        DecayHFRatioValidator{}(all.flDecayHFRatio);
+        ReflectionsValidator{}(all.lReflections);
+        ReflectionsDelayValidator{}(all.flReflectionsDelay);
+        ReverbValidator{}(all.lReverb);
+        ReverbDelayValidator{}(all.flReverbDelay);
+        EnvironmentValidator1{}(all.dwEnvironment);
+        EnvironmentSizeValidator{}(all.flEnvironmentSize);
+        EnvironmentDiffusionValidator{}(all.flEnvironmentDiffusion);
+        AirAbsorptionHFValidator{}(all.flAirAbsorptionHF);
+        FlagsValidator2{}(all.dwFlags);
+    }
+}; // AllValidator2
+
+struct EnvironmentValidator3 {
+    void operator()(unsigned long ulEnvironment) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Environment",
+            ulEnvironment,
+            EAXREVERB_MINENVIRONMENT,
+            EAX30REVERB_MAXENVIRONMENT);
+    }
+}; // EnvironmentValidator1
+
+struct RoomLFValidator {
+    void operator()(long lRoomLF) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Room LF",
+            lRoomLF,
+            EAXREVERB_MINROOMLF,
+            EAXREVERB_MAXROOMLF);
+    }
+}; // RoomLFValidator
+
+struct DecayLFRatioValidator {
+    void operator()(float flDecayLFRatio) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Decay LF Ratio",
+            flDecayLFRatio,
+            EAXREVERB_MINDECAYLFRATIO,
+            EAXREVERB_MAXDECAYLFRATIO);
+    }
+}; // DecayLFRatioValidator
+
+struct VectorValidator {
+    void operator()(const EAXVECTOR&) const
+    {}
+}; // VectorValidator
+
+struct EchoTimeValidator {
+    void operator()(float flEchoTime) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Echo Time",
+            flEchoTime,
+            EAXREVERB_MINECHOTIME,
+            EAXREVERB_MAXECHOTIME);
+    }
+}; // EchoTimeValidator
+
+struct EchoDepthValidator {
+    void operator()(float flEchoDepth) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Echo Depth",
+            flEchoDepth,
+            EAXREVERB_MINECHODEPTH,
+            EAXREVERB_MAXECHODEPTH);
+    }
+}; // EchoDepthValidator
+
+struct ModulationTimeValidator {
+    void operator()(float flModulationTime) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Modulation Time",
+            flModulationTime,
+            EAXREVERB_MINMODULATIONTIME,
+            EAXREVERB_MAXMODULATIONTIME);
+    }
+}; // ModulationTimeValidator
+
+struct ModulationDepthValidator {
+    void operator()(float flModulationDepth) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Modulation Depth",
+            flModulationDepth,
+            EAXREVERB_MINMODULATIONDEPTH,
+            EAXREVERB_MAXMODULATIONDEPTH);
+    }
+}; // ModulationDepthValidator
+
+struct HFReferenceValidator {
+    void operator()(float flHFReference) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "HF Reference",
+            flHFReference,
+            EAXREVERB_MINHFREFERENCE,
+            EAXREVERB_MAXHFREFERENCE);
+    }
+}; // HFReferenceValidator
+
+struct LFReferenceValidator {
+    void operator()(float flLFReference) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "LF Reference",
+            flLFReference,
+            EAXREVERB_MINLFREFERENCE,
+            EAXREVERB_MAXLFREFERENCE);
+    }
+}; // LFReferenceValidator
+
+struct FlagsValidator3 {
+    void operator()(unsigned long ulFlags) const
+    {
+        eax_validate_range<EaxReverbEffectException>(
+            "Flags",
+            ulFlags,
+            0UL,
+            ~EAXREVERBFLAGS_RESERVED);
+    }
+}; // FlagsValidator3
+
+struct AllValidator3 {
+    void operator()(const EAXREVERBPROPERTIES& all) const
+    {
+        EnvironmentValidator3{}(all.ulEnvironment);
+        EnvironmentSizeValidator{}(all.flEnvironmentSize);
+        EnvironmentDiffusionValidator{}(all.flEnvironmentDiffusion);
+        RoomValidator{}(all.lRoom);
+        RoomHFValidator{}(all.lRoomHF);
+        RoomLFValidator{}(all.lRoomLF);
+        DecayTimeValidator{}(all.flDecayTime);
+        DecayHFRatioValidator{}(all.flDecayHFRatio);
+        DecayLFRatioValidator{}(all.flDecayLFRatio);
+        ReflectionsValidator{}(all.lReflections);
+        ReflectionsDelayValidator{}(all.flReflectionsDelay);
+        VectorValidator{}(all.vReflectionsPan);
+        ReverbValidator{}(all.lReverb);
+        ReverbDelayValidator{}(all.flReverbDelay);
+        VectorValidator{}(all.vReverbPan);
+        EchoTimeValidator{}(all.flEchoTime);
+        EchoDepthValidator{}(all.flEchoDepth);
+        ModulationTimeValidator{}(all.flModulationTime);
+        ModulationDepthValidator{}(all.flModulationDepth);
+        AirAbsorptionHFValidator{}(all.flAirAbsorptionHF);
+        HFReferenceValidator{}(all.flHFReference);
+        LFReferenceValidator{}(all.flLFReference);
+        RoomRolloffFactorValidator{}(all.flRoomRolloffFactor);
+        FlagsValidator3{}(all.ulFlags);
+    }
+}; // AllValidator3
+
+struct EnvironmentDeferrer2 {
+    void operator()(EAX20LISTENERPROPERTIES& props, unsigned long dwEnvironment) const
+    {
+        props = EAX2REVERB_PRESETS[dwEnvironment];
+    }
+}; // EnvironmentDeferrer2
+
+struct EnvironmentSizeDeferrer2 {
+    void operator()(EAX20LISTENERPROPERTIES& props, float flEnvironmentSize) const
+    {
+        if (props.flEnvironmentSize == flEnvironmentSize)
+        {
+            return;
+        }
+
+        const auto scale = flEnvironmentSize / props.flEnvironmentSize;
+        props.flEnvironmentSize = flEnvironmentSize;
+
+        if ((props.dwFlags & EAX2LISTENERFLAGS_DECAYTIMESCALE) != 0)
+        {
+            props.flDecayTime = clamp(
+                props.flDecayTime * scale,
+                EAXREVERB_MINDECAYTIME,
+                EAXREVERB_MAXDECAYTIME);
+        }
+
+        if ((props.dwFlags & EAX2LISTENERFLAGS_REFLECTIONSSCALE) != 0 &&
+            (props.dwFlags & EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE) != 0)
+        {
+            props.lReflections = clamp(
+                props.lReflections - static_cast<long>(gain_to_level_mb(scale)),
+                EAXREVERB_MINREFLECTIONS,
+                EAXREVERB_MAXREFLECTIONS);
+        }
+
+        if ((props.dwFlags & EAX2LISTENERFLAGS_REFLECTIONSDELAYSCALE) != 0)
+        {
+            props.flReflectionsDelay = clamp(
+                props.flReflectionsDelay * scale,
+                EAXREVERB_MINREFLECTIONSDELAY,
+                EAXREVERB_MAXREFLECTIONSDELAY);
+        }
+
+        if ((props.dwFlags & EAX2LISTENERFLAGS_REVERBSCALE) != 0)
+        {
+            const auto log_scalar = ((props.dwFlags & EAXREVERBFLAGS_DECAYTIMESCALE) != 0) ? 2'000.0F : 3'000.0F;
+
+            props.lReverb = clamp(
+                props.lReverb - static_cast<long>(std::log10(scale) * log_scalar),
+                EAXREVERB_MINREVERB,
+                EAXREVERB_MAXREVERB);
+        }
+
+        if ((props.dwFlags & EAX2LISTENERFLAGS_REVERBDELAYSCALE) != 0)
+        {
+            props.flReverbDelay = clamp(
+                props.flReverbDelay * scale,
+                EAXREVERB_MINREVERBDELAY,
+                EAXREVERB_MAXREVERBDELAY);
+        }
+    }
+}; // EnvironmentSizeDeferrer2
+
+struct EnvironmentDeferrer3 {
+    void operator()(EAXREVERBPROPERTIES& props, unsigned long ulEnvironment) const
+    {
+        if (ulEnvironment == EAX_ENVIRONMENT_UNDEFINED)
+        {
+            props.ulEnvironment = EAX_ENVIRONMENT_UNDEFINED;
+            return;
+        }
+
+        props = EAXREVERB_PRESETS[ulEnvironment];
+    }
+}; // EnvironmentDeferrer3
+
+struct EnvironmentSizeDeferrer3 {
+    void operator()(EAXREVERBPROPERTIES& props, float flEnvironmentSize) const
+    {
+        if (props.flEnvironmentSize == flEnvironmentSize)
+        {
+            return;
+        }
+
+        const auto scale = flEnvironmentSize / props.flEnvironmentSize;
+        props.ulEnvironment = EAX_ENVIRONMENT_UNDEFINED;
+        props.flEnvironmentSize = flEnvironmentSize;
+
+        if ((props.ulFlags & EAXREVERBFLAGS_DECAYTIMESCALE) != 0)
+        {
+            props.flDecayTime = clamp(
+                props.flDecayTime * scale,
+                EAXREVERB_MINDECAYTIME,
+                EAXREVERB_MAXDECAYTIME);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_REFLECTIONSSCALE) != 0 &&
+            (props.ulFlags & EAXREVERBFLAGS_REFLECTIONSDELAYSCALE) != 0)
+        {
+            props.lReflections = clamp(
+                props.lReflections - static_cast<long>(gain_to_level_mb(scale)),
+                EAXREVERB_MINREFLECTIONS,
+                EAXREVERB_MAXREFLECTIONS);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_REFLECTIONSDELAYSCALE) != 0)
+        {
+            props.flReflectionsDelay = clamp(
+                props.flReflectionsDelay * scale,
+                EAXREVERB_MINREFLECTIONSDELAY,
+                EAXREVERB_MAXREFLECTIONSDELAY);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_REVERBSCALE) != 0)
+        {
+            const auto log_scalar = ((props.ulFlags & EAXREVERBFLAGS_DECAYTIMESCALE) != 0) ? 2'000.0F : 3'000.0F;
+            props.lReverb = clamp(
+                props.lReverb - static_cast<long>(std::log10(scale) * log_scalar),
+                EAXREVERB_MINREVERB,
+                EAXREVERB_MAXREVERB);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_REVERBDELAYSCALE) != 0)
+        {
+            props.flReverbDelay = clamp(
+                props.flReverbDelay * scale,
+                EAXREVERB_MINREVERBDELAY,
+                EAXREVERB_MAXREVERBDELAY);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_ECHOTIMESCALE) != 0)
+        {
+            props.flEchoTime = clamp(
+                props.flEchoTime * scale,
+                EAXREVERB_MINECHOTIME,
+                EAXREVERB_MAXECHOTIME);
+        }
+
+        if ((props.ulFlags & EAXREVERBFLAGS_MODULATIONTIMESCALE) != 0)
+        {
+            props.flModulationTime = clamp(
+                props.flModulationTime * scale,
+                EAXREVERB_MINMODULATIONTIME,
+                EAXREVERB_MAXMODULATIONTIME);
+        }
+    }
+}; // EnvironmentSizeDeferrer3
+
+} // namespace
+
+
+struct EaxReverbCommitter::Exception : public EaxReverbEffectException
+{
+    using EaxReverbEffectException::EaxReverbEffectException;
+};
+
+[[noreturn]] void EaxReverbCommitter::fail(const char* message)
+{
+    throw Exception{message};
+}
+
+void EaxReverbCommitter::translate(const EAX_REVERBPROPERTIES& src, EaxEffectProps& dst) noexcept
+{
+    assert(src.environment <= EAX1REVERB_MAXENVIRONMENT);
+    dst.mType = EaxEffectType::Reverb;
+    dst.mReverb = EAXREVERB_PRESETS[src.environment];
+    dst.mReverb.flDecayTime = src.fDecayTime_sec;
+    dst.mReverb.flDecayHFRatio = src.fDamping;
+    dst.mReverb.lReverb = mini(static_cast<int>(gain_to_level_mb(src.fVolume)), 0);
+}
+
+void EaxReverbCommitter::translate(const EAX20LISTENERPROPERTIES& src, EaxEffectProps& dst) noexcept
+{
+    assert(src.dwEnvironment <= EAX1REVERB_MAXENVIRONMENT);
+    const auto& env = EAXREVERB_PRESETS[src.dwEnvironment];
+    dst.mType = EaxEffectType::Reverb;
+    dst.mReverb.ulEnvironment = src.dwEnvironment;
+    dst.mReverb.flEnvironmentSize = src.flEnvironmentSize;
+    dst.mReverb.flEnvironmentDiffusion = src.flEnvironmentDiffusion;
+    dst.mReverb.lRoom = src.lRoom;
+    dst.mReverb.lRoomHF = src.lRoomHF;
+    dst.mReverb.lRoomLF = env.lRoomLF;
+    dst.mReverb.flDecayTime = src.flDecayTime;
+    dst.mReverb.flDecayHFRatio = src.flDecayHFRatio;
+    dst.mReverb.flDecayLFRatio = env.flDecayLFRatio;
+    dst.mReverb.lReflections = src.lReflections;
+    dst.mReverb.flReflectionsDelay = src.flReflectionsDelay;
+    dst.mReverb.vReflectionsPan = env.vReflectionsPan;
+    dst.mReverb.lReverb = src.lReverb;
+    dst.mReverb.flReverbDelay = src.flReverbDelay;
+    dst.mReverb.vReverbPan = env.vReverbPan;
+    dst.mReverb.flEchoTime = env.flEchoTime;
+    dst.mReverb.flEchoDepth = env.flEchoDepth;
+    dst.mReverb.flModulationTime = env.flModulationTime;
+    dst.mReverb.flModulationDepth = env.flModulationDepth;
+    dst.mReverb.flAirAbsorptionHF = src.flAirAbsorptionHF;
+    dst.mReverb.flHFReference = env.flHFReference;
+    dst.mReverb.flLFReference = env.flLFReference;
+    dst.mReverb.flRoomRolloffFactor = src.flRoomRolloffFactor;
+    dst.mReverb.ulFlags = src.dwFlags;
+}
+
+void EaxReverbCommitter::translate(const EAXREVERBPROPERTIES& src, EaxEffectProps& dst) noexcept
+{
+    dst.mType = EaxEffectType::Reverb;
+    dst.mReverb = src;
+}
+
+bool EaxReverbCommitter::commit(const EAX_REVERBPROPERTIES &props)
+{
+    EaxEffectProps dst{};
+    translate(props, dst);
+    return commit(dst);
+}
+
+bool EaxReverbCommitter::commit(const EAX20LISTENERPROPERTIES &props)
+{
+    EaxEffectProps dst{};
+    translate(props, dst);
+    return commit(dst);
+}
+
+bool EaxReverbCommitter::commit(const EAXREVERBPROPERTIES &props)
+{
+    EaxEffectProps dst{};
+    translate(props, dst);
+    return commit(dst);
+}
+
+bool EaxReverbCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && memcmp(&props.mReverb, &mEaxProps.mReverb, sizeof(mEaxProps.mReverb)) == 0)
+        return false;
+
+    mEaxProps = props;
+
+    const auto size = props.mReverb.flEnvironmentSize;
+    const auto density = (size * size * size) / 16.0F;
+    mAlProps.Reverb.Density = std::min(density, AL_EAXREVERB_MAX_DENSITY);
+    mAlProps.Reverb.Diffusion = props.mReverb.flEnvironmentDiffusion;
+    mAlProps.Reverb.Gain = level_mb_to_gain(static_cast<float>(props.mReverb.lRoom));
+    mAlProps.Reverb.GainHF = level_mb_to_gain(static_cast<float>(props.mReverb.lRoomHF));
+    mAlProps.Reverb.GainLF = level_mb_to_gain(static_cast<float>(props.mReverb.lRoomLF));
+    mAlProps.Reverb.DecayTime = props.mReverb.flDecayTime;
+    mAlProps.Reverb.DecayHFRatio = props.mReverb.flDecayHFRatio;
+    mAlProps.Reverb.DecayLFRatio = mEaxProps.mReverb.flDecayLFRatio;
+    mAlProps.Reverb.ReflectionsGain = level_mb_to_gain(static_cast<float>(props.mReverb.lReflections));
+    mAlProps.Reverb.ReflectionsDelay = props.mReverb.flReflectionsDelay;
+    mAlProps.Reverb.ReflectionsPan[0] = props.mReverb.vReflectionsPan.x;
+    mAlProps.Reverb.ReflectionsPan[1] = props.mReverb.vReflectionsPan.y;
+    mAlProps.Reverb.ReflectionsPan[2] = props.mReverb.vReflectionsPan.z;
+    mAlProps.Reverb.LateReverbGain = level_mb_to_gain(static_cast<float>(props.mReverb.lReverb));
+    mAlProps.Reverb.LateReverbDelay = props.mReverb.flReverbDelay;
+    mAlProps.Reverb.LateReverbPan[0] = props.mReverb.vReverbPan.x;
+    mAlProps.Reverb.LateReverbPan[1] = props.mReverb.vReverbPan.y;
+    mAlProps.Reverb.LateReverbPan[2] = props.mReverb.vReverbPan.z;
+    mAlProps.Reverb.EchoTime = props.mReverb.flEchoTime;
+    mAlProps.Reverb.EchoDepth = props.mReverb.flEchoDepth;
+    mAlProps.Reverb.ModulationTime = props.mReverb.flModulationTime;
+    mAlProps.Reverb.ModulationDepth = props.mReverb.flModulationDepth;
+    mAlProps.Reverb.AirAbsorptionGainHF = level_mb_to_gain(props.mReverb.flAirAbsorptionHF);
+    mAlProps.Reverb.HFReference = props.mReverb.flHFReference;
+    mAlProps.Reverb.LFReference = props.mReverb.flLFReference;
+    mAlProps.Reverb.RoomRolloffFactor = props.mReverb.flRoomRolloffFactor;
+    mAlProps.Reverb.DecayHFLimit = ((props.mReverb.ulFlags & EAXREVERBFLAGS_DECAYHFLIMIT) != 0);
+    return true;
+}
+
+void EaxReverbCommitter::SetDefaults(EAX_REVERBPROPERTIES &props)
+{
+    props = EAX1REVERB_PRESETS[EAX_ENVIRONMENT_GENERIC];
+}
+
+void EaxReverbCommitter::SetDefaults(EAX20LISTENERPROPERTIES &props)
+{
+    props = EAX2REVERB_PRESETS[EAX2_ENVIRONMENT_GENERIC];
+    props.lRoom = -10'000L;
+}
+
+void EaxReverbCommitter::SetDefaults(EAXREVERBPROPERTIES &props)
+{
+    props = EAXREVERB_PRESETS[EAX_ENVIRONMENT_GENERIC];
+}
+
+void EaxReverbCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::Reverb;
+    SetDefaults(props.mReverb);
+}
+
+
+void EaxReverbCommitter::Get(const EaxCall &call, const EAX_REVERBPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case DSPROPERTY_EAX_ALL: call.set_value<Exception>(props); break;
+    case DSPROPERTY_EAX_ENVIRONMENT: call.set_value<Exception>(props.environment); break;
+    case DSPROPERTY_EAX_VOLUME: call.set_value<Exception>(props.fVolume); break;
+    case DSPROPERTY_EAX_DECAYTIME: call.set_value<Exception>(props.fDecayTime_sec); break;
+    case DSPROPERTY_EAX_DAMPING: call.set_value<Exception>(props.fDamping); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Get(const EaxCall &call, const EAX20LISTENERPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case DSPROPERTY_EAX20LISTENER_NONE: break;
+    case DSPROPERTY_EAX20LISTENER_ALLPARAMETERS: call.set_value<Exception>(props); break;
+    case DSPROPERTY_EAX20LISTENER_ROOM: call.set_value<Exception>(props.lRoom); break;
+    case DSPROPERTY_EAX20LISTENER_ROOMHF: call.set_value<Exception>(props.lRoomHF); break;
+    case DSPROPERTY_EAX20LISTENER_ROOMROLLOFFFACTOR: call.set_value<Exception>(props.flRoomRolloffFactor); break;
+    case DSPROPERTY_EAX20LISTENER_DECAYTIME: call.set_value<Exception>(props.flDecayTime); break;
+    case DSPROPERTY_EAX20LISTENER_DECAYHFRATIO: call.set_value<Exception>(props.flDecayHFRatio); break;
+    case DSPROPERTY_EAX20LISTENER_REFLECTIONS: call.set_value<Exception>(props.lReflections); break;
+    case DSPROPERTY_EAX20LISTENER_REFLECTIONSDELAY: call.set_value<Exception>(props.flReflectionsDelay); break;
+    case DSPROPERTY_EAX20LISTENER_REVERB: call.set_value<Exception>(props.lReverb); break;
+    case DSPROPERTY_EAX20LISTENER_REVERBDELAY: call.set_value<Exception>(props.flReverbDelay); break;
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENT: call.set_value<Exception>(props.dwEnvironment); break;
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENTSIZE: call.set_value<Exception>(props.flEnvironmentSize); break;
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENTDIFFUSION: call.set_value<Exception>(props.flEnvironmentDiffusion); break;
+    case DSPROPERTY_EAX20LISTENER_AIRABSORPTIONHF: call.set_value<Exception>(props.flAirAbsorptionHF); break;
+    case DSPROPERTY_EAX20LISTENER_FLAGS: call.set_value<Exception>(props.dwFlags); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Get(const EaxCall &call, const EAXREVERBPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXREVERB_NONE: break;
+    case EAXREVERB_ALLPARAMETERS: call.set_value<Exception>(props); break;
+    case EAXREVERB_ENVIRONMENT: call.set_value<Exception>(props.ulEnvironment); break;
+    case EAXREVERB_ENVIRONMENTSIZE: call.set_value<Exception>(props.flEnvironmentSize); break;
+    case EAXREVERB_ENVIRONMENTDIFFUSION: call.set_value<Exception>(props.flEnvironmentDiffusion); break;
+    case EAXREVERB_ROOM: call.set_value<Exception>(props.lRoom); break;
+    case EAXREVERB_ROOMHF: call.set_value<Exception>(props.lRoomHF); break;
+    case EAXREVERB_ROOMLF: call.set_value<Exception>(props.lRoomLF); break;
+    case EAXREVERB_DECAYTIME: call.set_value<Exception>(props.flDecayTime); break;
+    case EAXREVERB_DECAYHFRATIO: call.set_value<Exception>(props.flDecayHFRatio); break;
+    case EAXREVERB_DECAYLFRATIO: call.set_value<Exception>(props.flDecayLFRatio); break;
+    case EAXREVERB_REFLECTIONS: call.set_value<Exception>(props.lReflections); break;
+    case EAXREVERB_REFLECTIONSDELAY: call.set_value<Exception>(props.flReflectionsDelay); break;
+    case EAXREVERB_REFLECTIONSPAN: call.set_value<Exception>(props.vReflectionsPan); break;
+    case EAXREVERB_REVERB: call.set_value<Exception>(props.lReverb); break;
+    case EAXREVERB_REVERBDELAY: call.set_value<Exception>(props.flReverbDelay); break;
+    case EAXREVERB_REVERBPAN: call.set_value<Exception>(props.vReverbPan); break;
+    case EAXREVERB_ECHOTIME: call.set_value<Exception>(props.flEchoTime); break;
+    case EAXREVERB_ECHODEPTH: call.set_value<Exception>(props.flEchoDepth); break;
+    case EAXREVERB_MODULATIONTIME: call.set_value<Exception>(props.flModulationTime); break;
+    case EAXREVERB_MODULATIONDEPTH: call.set_value<Exception>(props.flModulationDepth); break;
+    case EAXREVERB_AIRABSORPTIONHF: call.set_value<Exception>(props.flAirAbsorptionHF); break;
+    case EAXREVERB_HFREFERENCE: call.set_value<Exception>(props.flHFReference); break;
+    case EAXREVERB_LFREFERENCE: call.set_value<Exception>(props.flLFReference); break;
+    case EAXREVERB_ROOMROLLOFFFACTOR: call.set_value<Exception>(props.flRoomRolloffFactor); break;
+    case EAXREVERB_FLAGS: call.set_value<Exception>(props.ulFlags); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    Get(call, props.mReverb);
+}
+
+
+void EaxReverbCommitter::Set(const EaxCall &call, EAX_REVERBPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case DSPROPERTY_EAX_ALL: defer<AllValidator1>(call, props); break;
+    case DSPROPERTY_EAX_ENVIRONMENT: defer<EnvironmentValidator1>(call, props.environment); break;
+    case DSPROPERTY_EAX_VOLUME: defer<VolumeValidator>(call, props.fVolume); break;
+    case DSPROPERTY_EAX_DECAYTIME: defer<DecayTimeValidator>(call, props.fDecayTime_sec); break;
+    case DSPROPERTY_EAX_DAMPING: defer<DampingValidator>(call, props.fDamping); break;
+    default: fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Set(const EaxCall &call, EAX20LISTENERPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case DSPROPERTY_EAX20LISTENER_NONE:
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ALLPARAMETERS:
+        defer<AllValidator2>(call, props);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ROOM:
+        defer<RoomValidator>(call, props.lRoom);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ROOMHF:
+        defer<RoomHFValidator>(call, props.lRoomHF);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ROOMROLLOFFFACTOR:
+        defer<RoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_DECAYTIME:
+        defer<DecayTimeValidator>(call, props.flDecayTime);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_DECAYHFRATIO:
+        defer<DecayHFRatioValidator>(call, props.flDecayHFRatio);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_REFLECTIONS:
+        defer<ReflectionsValidator>(call, props.lReflections);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_REFLECTIONSDELAY:
+        defer<ReflectionsDelayValidator>(call, props.flReverbDelay);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_REVERB:
+        defer<ReverbValidator>(call, props.lReverb);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_REVERBDELAY:
+        defer<ReverbDelayValidator>(call, props.flReverbDelay);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENT:
+        defer<EnvironmentValidator1, EnvironmentDeferrer2>(call, props, props.dwEnvironment);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENTSIZE:
+        defer<EnvironmentSizeValidator, EnvironmentSizeDeferrer2>(call, props, props.flEnvironmentSize);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_ENVIRONMENTDIFFUSION:
+        defer<EnvironmentDiffusionValidator>(call, props.flEnvironmentDiffusion);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_AIRABSORPTIONHF:
+        defer<AirAbsorptionHFValidator>(call, props.flAirAbsorptionHF);
+        break;
+
+    case DSPROPERTY_EAX20LISTENER_FLAGS:
+        defer<FlagsValidator2>(call, props.dwFlags);
+        break;
+
+    default:
+        fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Set(const EaxCall &call, EAXREVERBPROPERTIES &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXREVERB_NONE:
+        break;
+
+    case EAXREVERB_ALLPARAMETERS:
+        defer<AllValidator3>(call, props);
+        break;
+
+    case EAXREVERB_ENVIRONMENT:
+        defer<EnvironmentValidator3, EnvironmentDeferrer3>(call, props, props.ulEnvironment);
+        break;
+
+    case EAXREVERB_ENVIRONMENTSIZE:
+        defer<EnvironmentSizeValidator, EnvironmentSizeDeferrer3>(call, props, props.flEnvironmentSize);
+        break;
+
+    case EAXREVERB_ENVIRONMENTDIFFUSION:
+        defer3<EnvironmentDiffusionValidator>(call, props, props.flEnvironmentDiffusion);
+        break;
+
+    case EAXREVERB_ROOM:
+        defer3<RoomValidator>(call, props, props.lRoom);
+        break;
+
+    case EAXREVERB_ROOMHF:
+        defer3<RoomHFValidator>(call, props, props.lRoomHF);
+        break;
+
+    case EAXREVERB_ROOMLF:
+        defer3<RoomLFValidator>(call, props, props.lRoomLF);
+        break;
+
+    case EAXREVERB_DECAYTIME:
+        defer3<DecayTimeValidator>(call, props, props.flDecayTime);
+        break;
+
+    case EAXREVERB_DECAYHFRATIO:
+        defer3<DecayHFRatioValidator>(call, props, props.flDecayHFRatio);
+        break;
+
+    case EAXREVERB_DECAYLFRATIO:
+        defer3<DecayLFRatioValidator>(call, props, props.flDecayLFRatio);
+        break;
+
+    case EAXREVERB_REFLECTIONS:
+        defer3<ReflectionsValidator>(call, props, props.lReflections);
+        break;
+
+    case EAXREVERB_REFLECTIONSDELAY:
+        defer3<ReflectionsDelayValidator>(call, props, props.flReflectionsDelay);
+        break;
+
+    case EAXREVERB_REFLECTIONSPAN:
+        defer3<VectorValidator>(call, props, props.vReflectionsPan);
+        break;
+
+    case EAXREVERB_REVERB:
+        defer3<ReverbValidator>(call, props, props.lReverb);
+        break;
+
+    case EAXREVERB_REVERBDELAY:
+        defer3<ReverbDelayValidator>(call, props, props.flReverbDelay);
+        break;
+
+    case EAXREVERB_REVERBPAN:
+        defer3<VectorValidator>(call, props, props.vReverbPan);
+        break;
+
+    case EAXREVERB_ECHOTIME:
+        defer3<EchoTimeValidator>(call, props, props.flEchoTime);
+        break;
+
+    case EAXREVERB_ECHODEPTH:
+        defer3<EchoDepthValidator>(call, props, props.flEchoDepth);
+        break;
+
+    case EAXREVERB_MODULATIONTIME:
+        defer3<ModulationTimeValidator>(call, props, props.flModulationTime);
+        break;
+
+    case EAXREVERB_MODULATIONDEPTH:
+        defer3<ModulationDepthValidator>(call, props, props.flModulationDepth);
+        break;
+
+    case EAXREVERB_AIRABSORPTIONHF:
+        defer3<AirAbsorptionHFValidator>(call, props, props.flAirAbsorptionHF);
+        break;
+
+    case EAXREVERB_HFREFERENCE:
+        defer3<HFReferenceValidator>(call, props, props.flHFReference);
+        break;
+
+    case EAXREVERB_LFREFERENCE:
+        defer3<LFReferenceValidator>(call, props, props.flLFReference);
+        break;
+
+    case EAXREVERB_ROOMROLLOFFFACTOR:
+        defer3<RoomRolloffFactorValidator>(call, props, props.flRoomRolloffFactor);
+        break;
+
+    case EAXREVERB_FLAGS:
+        defer3<FlagsValidator3>(call, props, props.ulFlags);
+        break;
+
+    default:
+        fail_unknown_property_id();
+    }
+}
+
+void EaxReverbCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    Set(call, props.mReverb);
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/effects/vmorpher.cpp b/al/effects/vmorpher.cpp
new file mode 100644
index 00000000..21ea3680
--- /dev/null
+++ b/al/effects/vmorpher.cpp
@@ -0,0 +1,520 @@
+
+#include "config.h"
+
+#include <stdexcept>
+
+#include "AL/al.h"
+#include "AL/efx.h"
+
+#include "alc/effects/base.h"
+#include "aloptional.h"
+#include "effects.h"
+
+#ifdef ALSOFT_EAX
+#include <cassert>
+#include "alnumeric.h"
+#include "al/eax/exception.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+
+namespace {
+
+al::optional<VMorpherPhenome> PhenomeFromEnum(ALenum val)
+{
+#define HANDLE_PHENOME(x) case AL_VOCAL_MORPHER_PHONEME_ ## x:                \
+    return 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 VMorpherWaveform::Sinusoid;
+    case AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE: return VMorpherWaveform::Triangle;
+    case AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH: return 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()};
+
+#ifdef ALSOFT_EAX
+namespace {
+
+using VocalMorpherCommitter = EaxCommitter<EaxVocalMorpherCommitter>;
+
+struct PhonemeAValidator {
+    void operator()(unsigned long ulPhonemeA) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Phoneme A",
+            ulPhonemeA,
+            EAXVOCALMORPHER_MINPHONEMEA,
+            EAXVOCALMORPHER_MAXPHONEMEA);
+    }
+}; // PhonemeAValidator
+
+struct PhonemeACoarseTuningValidator {
+    void operator()(long lPhonemeACoarseTuning) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Phoneme A Coarse Tuning",
+            lPhonemeACoarseTuning,
+            EAXVOCALMORPHER_MINPHONEMEACOARSETUNING,
+            EAXVOCALMORPHER_MAXPHONEMEACOARSETUNING);
+    }
+}; // PhonemeACoarseTuningValidator
+
+struct PhonemeBValidator {
+    void operator()(unsigned long ulPhonemeB) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Phoneme B",
+            ulPhonemeB,
+            EAXVOCALMORPHER_MINPHONEMEB,
+            EAXVOCALMORPHER_MAXPHONEMEB);
+    }
+}; // PhonemeBValidator
+
+struct PhonemeBCoarseTuningValidator {
+    void operator()(long lPhonemeBCoarseTuning) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Phoneme B Coarse Tuning",
+            lPhonemeBCoarseTuning,
+            EAXVOCALMORPHER_MINPHONEMEBCOARSETUNING,
+            EAXVOCALMORPHER_MAXPHONEMEBCOARSETUNING);
+    }
+}; // PhonemeBCoarseTuningValidator
+
+struct WaveformValidator {
+    void operator()(unsigned long ulWaveform) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Waveform",
+            ulWaveform,
+            EAXVOCALMORPHER_MINWAVEFORM,
+            EAXVOCALMORPHER_MAXWAVEFORM);
+    }
+}; // WaveformValidator
+
+struct RateValidator {
+    void operator()(float flRate) const
+    {
+        eax_validate_range<VocalMorpherCommitter::Exception>(
+            "Rate",
+            flRate,
+            EAXVOCALMORPHER_MINRATE,
+            EAXVOCALMORPHER_MAXRATE);
+    }
+}; // RateValidator
+
+struct AllValidator {
+    void operator()(const EAXVOCALMORPHERPROPERTIES& all) const
+    {
+        PhonemeAValidator{}(all.ulPhonemeA);
+        PhonemeACoarseTuningValidator{}(all.lPhonemeACoarseTuning);
+        PhonemeBValidator{}(all.ulPhonemeB);
+        PhonemeBCoarseTuningValidator{}(all.lPhonemeBCoarseTuning);
+        WaveformValidator{}(all.ulWaveform);
+        RateValidator{}(all.flRate);
+    }
+}; // AllValidator
+
+} // namespace
+
+template<>
+struct VocalMorpherCommitter::Exception : public EaxException {
+    explicit Exception(const char *message) : EaxException{"EAX_VOCAL_MORPHER_EFFECT", message}
+    { }
+};
+
+template<>
+[[noreturn]] void VocalMorpherCommitter::fail(const char *message)
+{
+    throw Exception{message};
+}
+
+template<>
+bool VocalMorpherCommitter::commit(const EaxEffectProps &props)
+{
+    if(props.mType == mEaxProps.mType
+        && mEaxProps.mVocalMorpher.ulPhonemeA == props.mVocalMorpher.ulPhonemeA
+        && mEaxProps.mVocalMorpher.lPhonemeACoarseTuning == props.mVocalMorpher.lPhonemeACoarseTuning
+        && mEaxProps.mVocalMorpher.ulPhonemeB == props.mVocalMorpher.ulPhonemeB
+        && mEaxProps.mVocalMorpher.lPhonemeBCoarseTuning == props.mVocalMorpher.lPhonemeBCoarseTuning
+        && mEaxProps.mVocalMorpher.ulWaveform == props.mVocalMorpher.ulWaveform
+        && mEaxProps.mVocalMorpher.flRate == props.mVocalMorpher.flRate)
+        return false;
+
+    mEaxProps = props;
+
+    auto get_phoneme = [](unsigned long phoneme) noexcept
+    {
+#define HANDLE_PHENOME(x) case x: return VMorpherPhenome::x
+        switch(phoneme)
+        {
+        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 VMorpherPhenome::A;
+#undef HANDLE_PHENOME
+    };
+    auto get_waveform = [](unsigned long form) noexcept
+    {
+        if(form == EAX_VOCALMORPHER_SINUSOID) return VMorpherWaveform::Sinusoid;
+        if(form == EAX_VOCALMORPHER_TRIANGLE) return VMorpherWaveform::Triangle;
+        if(form == EAX_VOCALMORPHER_SAWTOOTH) return VMorpherWaveform::Sawtooth;
+        return VMorpherWaveform::Sinusoid;
+    };
+
+    mAlProps.Vmorpher.PhonemeA = get_phoneme(props.mVocalMorpher.ulPhonemeA);
+    mAlProps.Vmorpher.PhonemeACoarseTuning = static_cast<int>(props.mVocalMorpher.lPhonemeACoarseTuning);
+    mAlProps.Vmorpher.PhonemeB = get_phoneme(props.mVocalMorpher.ulPhonemeB);
+    mAlProps.Vmorpher.PhonemeBCoarseTuning = static_cast<int>(props.mVocalMorpher.lPhonemeBCoarseTuning);
+    mAlProps.Vmorpher.Waveform = get_waveform(props.mVocalMorpher.ulWaveform);
+    mAlProps.Vmorpher.Rate = props.mVocalMorpher.flRate;
+
+    return true;
+}
+
+template<>
+void VocalMorpherCommitter::SetDefaults(EaxEffectProps &props)
+{
+    props.mType = EaxEffectType::VocalMorpher;
+    props.mVocalMorpher.ulPhonemeA = EAXVOCALMORPHER_DEFAULTPHONEMEA;
+    props.mVocalMorpher.lPhonemeACoarseTuning = EAXVOCALMORPHER_DEFAULTPHONEMEACOARSETUNING;
+    props.mVocalMorpher.ulPhonemeB = EAXVOCALMORPHER_DEFAULTPHONEMEB;
+    props.mVocalMorpher.lPhonemeBCoarseTuning = EAXVOCALMORPHER_DEFAULTPHONEMEBCOARSETUNING;
+    props.mVocalMorpher.ulWaveform = EAXVOCALMORPHER_DEFAULTWAVEFORM;
+    props.mVocalMorpher.flRate = EAXVOCALMORPHER_DEFAULTRATE;
+}
+
+template<>
+void VocalMorpherCommitter::Get(const EaxCall &call, const EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXVOCALMORPHER_NONE:
+        break;
+
+    case EAXVOCALMORPHER_ALLPARAMETERS:
+        call.set_value<Exception>(props.mVocalMorpher);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEA:
+        call.set_value<Exception>(props.mVocalMorpher.ulPhonemeA);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEACOARSETUNING:
+        call.set_value<Exception>(props.mVocalMorpher.lPhonemeACoarseTuning);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEB:
+        call.set_value<Exception>(props.mVocalMorpher.ulPhonemeB);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEBCOARSETUNING:
+        call.set_value<Exception>(props.mVocalMorpher.lPhonemeBCoarseTuning);
+        break;
+
+    case EAXVOCALMORPHER_WAVEFORM:
+        call.set_value<Exception>(props.mVocalMorpher.ulWaveform);
+        break;
+
+    case EAXVOCALMORPHER_RATE:
+        call.set_value<Exception>(props.mVocalMorpher.flRate);
+        break;
+
+    default:
+        fail_unknown_property_id();
+    }
+}
+
+template<>
+void VocalMorpherCommitter::Set(const EaxCall &call, EaxEffectProps &props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXVOCALMORPHER_NONE:
+        break;
+
+    case EAXVOCALMORPHER_ALLPARAMETERS:
+        defer<AllValidator>(call, props.mVocalMorpher);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEA:
+        defer<PhonemeAValidator>(call, props.mVocalMorpher.ulPhonemeA);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEACOARSETUNING:
+        defer<PhonemeACoarseTuningValidator>(call, props.mVocalMorpher.lPhonemeACoarseTuning);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEB:
+        defer<PhonemeBValidator>(call, props.mVocalMorpher.ulPhonemeB);
+        break;
+
+    case EAXVOCALMORPHER_PHONEMEBCOARSETUNING:
+        defer<PhonemeBCoarseTuningValidator>(call, props.mVocalMorpher.lPhonemeBCoarseTuning);
+        break;
+
+    case EAXVOCALMORPHER_WAVEFORM:
+        defer<WaveformValidator>(call, props.mVocalMorpher.ulWaveform);
+        break;
+
+    case EAXVOCALMORPHER_RATE:
+        defer<RateValidator>(call, props.mVocalMorpher.flRate);
+        break;
+
+    default:
+        fail_unknown_property_id();
+    }
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/error.cpp b/al/error.cpp
index b667d14f..afa7019a 100644
--- a/al/error.cpp
+++ b/al/error.cpp
@@ -35,12 +35,10 @@
 #include "AL/al.h"
 #include "AL/alc.h"
 
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "alc/context.h"
 #include "almalloc.h"
-#include "event.h"
-#include "inprogext.h"
-#include "logging.h"
+#include "core/except.h"
+#include "core/logging.h"
 #include "opthelpers.h"
 #include "vector.h"
 
@@ -65,7 +63,6 @@ void ALCcontext::setError(ALenum errorCode, const char *msg, ...)
 
     if(msglen >= 0) msg = message.data();
     else msg = "<internal error constructing message>";
-    msglen = static_cast<int>(strlen(msg));
 
     WARN("Error generated on context %p, code 0x%04x, \"%s\"\n",
         decltype(std::declval<void*>()){this}, errorCode, msg);
@@ -82,23 +79,15 @@ void ALCcontext::setError(ALenum errorCode, const char *msg, ...)
 
     ALenum curerr{AL_NO_ERROR};
     mLastError.compare_exchange_strong(curerr, errorCode);
-    if((mEnabledEvts.load(std::memory_order_relaxed)&EventType_Error))
-    {
-        std::lock_guard<std::mutex> _{mEventCbLock};
-        ALbitfieldSOFT enabledevts{mEnabledEvts.load(std::memory_order_relaxed)};
-        if((enabledevts&EventType_Error) && mEventCb)
-            (*mEventCb)(AL_EVENT_TYPE_ERROR_SOFT, 0, static_cast<ALuint>(errorCode), msglen, msg,
-                mEventParam);
-    }
 }
 
 AL_API ALenum AL_APIENTRY alGetError(void)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context)
+    if(!context) UNLIKELY
     {
-        constexpr ALenum deferror{AL_INVALID_OPERATION};
+        static constexpr ALenum deferror{AL_INVALID_OPERATION};
         WARN("Querying error state on null context (implicitly 0x%04x)\n", deferror);
         if(TrapALError)
         {
diff --git a/al/event.cpp b/al/event.cpp
index 0da48cbf..1bc39d1e 100644
--- a/al/event.cpp
+++ b/al/event.cpp
@@ -18,12 +18,14 @@
 #include "AL/alc.h"
 
 #include "albyte.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "alc/context.h"
+#include "alc/effects/base.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
-#include "effects/base.h"
-#include "inprogext.h"
-#include "logging.h"
+#include "core/async_event.h"
+#include "core/except.h"
+#include "core/logging.h"
+#include "core/voice_change.h"
 #include "opthelpers.h"
 #include "ringbuffer.h"
 #include "threads.h"
@@ -33,7 +35,7 @@ static int EventThread(ALCcontext *context)
 {
     RingBuffer *ring{context->mAsyncEvents.get()};
     bool quitnow{false};
-    while LIKELY(!quitnow)
+    while(!quitnow)
     {
         auto evt_data = ring->getReadVector().first;
         if(evt_data.len == 0)
@@ -52,36 +54,48 @@ static int EventThread(ALCcontext *context)
             al::destroy_at(evt_ptr);
             ring->readAdvance(1);
 
-            quitnow = evt.EnumType == EventType_KillThread;
-            if UNLIKELY(quitnow) break;
+            quitnow = evt.EnumType == AsyncEvent::KillThread;
+            if(quitnow) UNLIKELY break;
 
-            if(evt.EnumType == EventType_ReleaseEffectState)
+            if(evt.EnumType == AsyncEvent::ReleaseEffectState)
             {
-                evt.u.mEffectState->release();
+                al::intrusive_ptr<EffectState>{evt.u.mEffectState};
                 continue;
             }
 
-            ALbitfieldSOFT enabledevts{context->mEnabledEvts.load(std::memory_order_acquire)};
-            if(!context->mEventCb) continue;
+            auto enabledevts = context->mEnabledEvts.load(std::memory_order_acquire);
+            if(!context->mEventCb || !enabledevts.test(evt.EnumType))
+                continue;
 
-            if(evt.EnumType == EventType_SourceStateChange)
+            if(evt.EnumType == AsyncEvent::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 ";
-                msg += (evt.u.srcstate.state==AL_INITIAL) ? "AL_INITIAL" :
-                    (evt.u.srcstate.state==AL_PLAYING) ? "AL_PLAYING" :
-                    (evt.u.srcstate.state==AL_PAUSED) ? "AL_PAUSED" :
-                    (evt.u.srcstate.state==AL_STOPPED) ? "AL_STOPPED" : "<unknown>";
+                switch(evt.u.srcstate.state)
+                {
+                case AsyncEvent::SrcState::Reset:
+                    msg += "AL_INITIAL";
+                    state = AL_INITIAL;
+                    break;
+                case AsyncEvent::SrcState::Stop:
+                    msg += "AL_STOPPED";
+                    state = AL_STOPPED;
+                    break;
+                case AsyncEvent::SrcState::Play:
+                    msg += "AL_PLAYING";
+                    state = AL_PLAYING;
+                    break;
+                case AsyncEvent::SrcState::Pause:
+                    msg += "AL_PAUSED";
+                    state = AL_PAUSED;
+                    break;
+                }
                 context->mEventCb(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT, evt.u.srcstate.id,
-                    static_cast<ALuint>(evt.u.srcstate.state), static_cast<ALsizei>(msg.length()),
-                    msg.c_str(), context->mEventParam);
+                    state, static_cast<ALsizei>(msg.length()), msg.c_str(), context->mEventParam);
             }
-            else if(evt.EnumType == EventType_BufferCompleted)
+            else if(evt.EnumType == AsyncEvent::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";
@@ -89,10 +103,12 @@ static int EventThread(ALCcontext *context)
                     evt.u.bufcomp.count, static_cast<ALsizei>(msg.length()), msg.c_str(),
                     context->mEventParam);
             }
-            else if((enabledevts&evt.EnumType) == evt.EnumType)
-                context->mEventCb(evt.u.user.type, evt.u.user.id, evt.u.user.param,
-                    static_cast<ALsizei>(strlen(evt.u.user.msg)), evt.u.user.msg,
+            else if(evt.EnumType == AsyncEvent::Disconnected)
+            {
+                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;
@@ -122,7 +138,7 @@ void StopEventThrd(ALCcontext *ctx)
             evt_data = ring->getWriteVector().first;
         } while(evt_data.len == 0);
     }
-    new (evt_data.buf) AsyncEvent{EventType_KillThread};
+    al::construct_at(reinterpret_cast<AsyncEvent*>(evt_data.buf), AsyncEvent::KillThread);
     ring->writeAdvance(1);
 
     ctx->mEventSem.post();
@@ -134,40 +150,34 @@ AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, A
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY 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");
+    if(!types) return context->setError(AL_INVALID_VALUE, "NULL pointer");
 
-    ALbitfieldSOFT flags{0};
+    ContextBase::AsyncEventBitset flags{};
     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;
+                flags.set(AsyncEvent::BufferCompleted);
             else if(type == AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT)
-                flags |= EventType_SourceStateChange;
-            else if(type == AL_EVENT_TYPE_ERROR_SOFT)
-                flags |= EventType_Error;
-            else if(type == AL_EVENT_TYPE_PERFORMANCE_SOFT)
-                flags |= EventType_Performance;
-            else if(type == AL_EVENT_TYPE_DEPRECATED_SOFT)
-                flags |= EventType_Deprecated;
+                flags.set(AsyncEvent::SourceStateChange);
             else if(type == AL_EVENT_TYPE_DISCONNECTED_SOFT)
-                flags |= EventType_Disconnected;
+                flags.set(AsyncEvent::Disconnected);
             else
                 return false;
             return true;
         }
     );
     if(bad_type != types_end)
-        SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid event type 0x%04x", *bad_type);
+        return context->setError(AL_INVALID_ENUM, "Invalid event type 0x%04x", *bad_type);
 
     if(enable)
     {
-        ALbitfieldSOFT enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)};
+        auto 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)
         {
@@ -178,7 +188,7 @@ START_API_FUNC
     }
     else
     {
-        ALbitfieldSOFT enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)};
+        auto 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)
         {
@@ -186,7 +196,7 @@ START_API_FUNC
         /* Wait to ensure the event handler sees the changed flags before
          * returning.
          */
-        std::lock_guard<std::mutex>{context->mEventCbLock};
+        std::lock_guard<std::mutex> _{context->mEventCbLock};
     }
 }
 END_API_FUNC
@@ -195,7 +205,7 @@ AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *user
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mEventCbLock};
diff --git a/al/event.h b/al/event.h
index 9056d577..83513c51 100644
--- a/al/event.h
+++ b/al/event.h
@@ -1,53 +1,7 @@
 #ifndef AL_EVENT_H
 #define AL_EVENT_H
 
-#include "AL/al.h"
-#include "AL/alc.h"
-
-struct EffectState;
-
-
-enum {
-    /* End event thread processing. */
-    EventType_KillThread = 0,
-
-    /* User event types. */
-    EventType_SourceStateChange = 1<<0,
-    EventType_BufferCompleted   = 1<<1,
-    EventType_Error             = 1<<2,
-    EventType_Performance       = 1<<3,
-    EventType_Deprecated        = 1<<4,
-    EventType_Disconnected      = 1<<5,
-
-    /* Internal events. */
-    EventType_ReleaseEffectState = 65536,
-};
-
-struct AsyncEvent {
-    unsigned int EnumType{0u};
-    union {
-        char dummy;
-        struct {
-            ALuint id;
-            ALenum state;
-        } srcstate;
-        struct {
-            ALuint id;
-            ALuint count;
-        } bufcomp;
-        struct {
-            ALenum type;
-            ALuint id;
-            ALuint param;
-            ALchar msg[232];
-        } user;
-        EffectState *mEffectState;
-    } u{};
-
-    AsyncEvent() noexcept = default;
-    constexpr AsyncEvent(unsigned int type) noexcept : EnumType{type} { }
-};
-
+struct ALCcontext;
 
 void StartEventThrd(ALCcontext *ctx);
 void StopEventThrd(ALCcontext *ctx);
diff --git a/al/extension.cpp b/al/extension.cpp
index 35c53136..3ead0af8 100644
--- a/al/extension.cpp
+++ b/al/extension.cpp
@@ -27,9 +27,9 @@
 #include "AL/al.h"
 #include "AL/alc.h"
 
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "alc/context.h"
 #include "alstring.h"
+#include "core/except.h"
 #include "opthelpers.h"
 
 
@@ -37,10 +37,13 @@ AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extName)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return AL_FALSE;
+    if(!context) UNLIKELY return AL_FALSE;
 
-    if(!extName)
-        SETERR_RETURN(context, AL_INVALID_VALUE, AL_FALSE, "NULL pointer");
+    if(!extName) UNLIKELY
+    {
+        context->setError(AL_INVALID_VALUE, "NULL pointer");
+        return AL_FALSE;
+    }
 
     size_t len{strlen(extName)};
     const char *ptr{context->mExtensionList};
diff --git a/al/filter.cpp b/al/filter.cpp
index 33887254..73efa01f 100644
--- a/al/filter.cpp
+++ b/al/filter.cpp
@@ -23,7 +23,9 @@
 #include "filter.h"
 
 #include <algorithm>
+#include <cstdarg>
 #include <cstdint>
+#include <cstdio>
 #include <iterator>
 #include <memory>
 #include <mutex>
@@ -34,206 +36,253 @@
 #include "AL/alc.h"
 #include "AL/efx.h"
 
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "albit.h"
+#include "alc/context.h"
+#include "alc/device.h"
 #include "almalloc.h"
 #include "alnumeric.h"
+#include "core/except.h"
 #include "opthelpers.h"
 #include "vector.h"
 
 
 namespace {
 
-#define FILTER_MIN_GAIN 0.0f
-#define FILTER_MAX_GAIN 4.0f /* +12dB */
+class filter_exception final : public al::base_exception {
+    ALenum mErrorCode;
 
-void ALlowpass_setParami(ALfilter*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param); }
-void ALlowpass_setParamiv(ALfilter*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x", param); }
-void ALlowpass_setParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+public:
+#ifdef __USE_MINGW_ANSI_STDIO
+    [[gnu::format(gnu_printf, 3, 4)]]
+#else
+    [[gnu::format(printf, 3, 4)]]
+#endif
+    filter_exception(ALenum code, const char *msg, ...);
+    ~filter_exception() override;
+
+    ALenum errorCode() const noexcept { return mErrorCode; }
+};
+
+filter_exception::filter_exception(ALenum code, const char* msg, ...) : mErrorCode{code}
 {
-    switch(param)
-    {
-        case AL_LOWPASS_GAIN:
-            if(!(val >= FILTER_MIN_GAIN && val <= FILTER_MAX_GAIN))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Low-pass gain %f out of range", val);
-            filter->Gain = val;
-            break;
+    std::va_list args;
+    va_start(args, msg);
+    setMessage(msg, args);
+    va_end(args);
+}
+filter_exception::~filter_exception() = default;
+
 
-        case AL_LOWPASS_GAINHF:
-            if(!(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Low-pass gainhf %f out of range", val);
-            filter->GainHF = val;
-            break;
+#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,  \
+}
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param);
+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 >= AL_LOWPASS_MIN_GAIN && val <= AL_LOWPASS_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, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALlowpass_setParamf(filter, context, param, vals[0]); }
-
-void ALlowpass_getParami(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid low-pass integer property 0x%04x", param); }
-void ALlowpass_getParamiv(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid low-pass integer-vector property 0x%04x", param); }
-void ALlowpass_getParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+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_GAIN:
+        *val = filter->Gain;
+        break;
 
-        case AL_LOWPASS_GAINHF:
-            *val = filter->GainHF;
-            break;
+    case AL_LOWPASS_GAINHF:
+        *val = filter->GainHF;
+        break;
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param);
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid low-pass float property 0x%04x", param};
     }
 }
-void ALlowpass_getParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALlowpass_getParamf(filter, context, param, vals); }
+void ALlowpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALlowpass_getParamf(filter, param, vals); }
 
 DEFINE_ALFILTER_VTABLE(ALlowpass);
 
 
-void ALhighpass_setParami(ALfilter*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param); }
-void ALhighpass_setParamiv(ALfilter*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x", param); }
-void ALhighpass_setParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "High-pass gain out of range");
-            filter->Gain = val;
-            break;
-
-        case AL_HIGHPASS_GAINLF:
-            if(!(val >= AL_HIGHPASS_MIN_GAINLF && val <= AL_HIGHPASS_MAX_GAINLF))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "High-pass gainlf out of range");
-            filter->GainLF = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param);
+    case AL_HIGHPASS_GAIN:
+        if(!(val >= AL_HIGHPASS_MIN_GAIN && val <= AL_HIGHPASS_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, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALhighpass_setParamf(filter, context, param, vals[0]); }
-
-void ALhighpass_getParami(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid high-pass integer property 0x%04x", param); }
-void ALhighpass_getParamiv(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid high-pass integer-vector property 0x%04x", param); }
-void ALhighpass_getParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+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_GAIN:
+        *val = filter->Gain;
+        break;
 
-        case AL_HIGHPASS_GAINLF:
-            *val = filter->GainLF;
-            break;
+    case AL_HIGHPASS_GAINLF:
+        *val = filter->GainLF;
+        break;
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param);
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid high-pass float property 0x%04x", param};
     }
 }
-void ALhighpass_getParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALhighpass_getParamf(filter, context, param, vals); }
+void ALhighpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALhighpass_getParamf(filter, param, vals); }
 
 DEFINE_ALFILTER_VTABLE(ALhighpass);
 
 
-void ALbandpass_setParami(ALfilter*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param); }
-void ALbandpass_setParamiv(ALfilter*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x", param); }
-void ALbandpass_setParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Band-pass gain out of range");
-            filter->Gain = val;
-            break;
-
-        case AL_BANDPASS_GAINHF:
-            if(!(val >= AL_BANDPASS_MIN_GAINHF && val <= AL_BANDPASS_MAX_GAINHF))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Band-pass gainhf out of range");
-            filter->GainHF = val;
-            break;
-
-        case AL_BANDPASS_GAINLF:
-            if(!(val >= AL_BANDPASS_MIN_GAINLF && val <= AL_BANDPASS_MAX_GAINLF))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Band-pass gainlf out of range");
-            filter->GainLF = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param);
+    case AL_BANDPASS_GAIN:
+        if(!(val >= AL_BANDPASS_MIN_GAIN && val <= AL_BANDPASS_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, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ ALbandpass_setParamf(filter, context, param, vals[0]); }
-
-void ALbandpass_getParami(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid band-pass integer property 0x%04x", param); }
-void ALbandpass_getParamiv(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid band-pass integer-vector property 0x%04x", param); }
-void ALbandpass_getParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+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_GAIN:
+        *val = filter->Gain;
+        break;
 
-        case AL_BANDPASS_GAINHF:
-            *val = filter->GainHF;
-            break;
+    case AL_BANDPASS_GAINHF:
+        *val = filter->GainHF;
+        break;
 
-        case AL_BANDPASS_GAINLF:
-            *val = filter->GainLF;
-            break;
+    case AL_BANDPASS_GAINLF:
+        *val = filter->GainLF;
+        break;
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param);
+    default:
+        throw filter_exception{AL_INVALID_ENUM, "Invalid band-pass float property 0x%04x", param};
     }
 }
-void ALbandpass_getParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
-{ ALbandpass_getParamf(filter, context, param, vals); }
+void ALbandpass_getParamfv(const ALfilter *filter, ALenum param, float *vals)
+{ ALbandpass_getParamf(filter, param, vals); }
 
 DEFINE_ALFILTER_VTABLE(ALbandpass);
 
 
-void ALnullfilter_setParami(ALfilter*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_setParamiv(ALfilter*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_setParamf(ALfilter*, ALCcontext *context, ALenum param, ALfloat)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_setParamfv(ALfilter*, ALCcontext *context, ALenum param, const ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-
-void ALnullfilter_getParami(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_getParamiv(ALfilter*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_getParamf(ALfilter*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
-void ALnullfilter_getParamfv(ALfilter*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid null filter property 0x%04x", param); }
+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);
 
@@ -283,19 +332,18 @@ 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>(POPCNT64(sublist.FreeMask)); }
-    )};
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 
     while(needed > count)
     {
-        if UNLIKELY(device->FilterList.size() >= 1<<25)
+        if(device->FilterList.size() >= 1<<25) UNLIKELY
             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)
+        if(!sublist->Filters) UNLIKELY
         {
             device->FilterList.pop_back();
             return false;
@@ -310,12 +358,12 @@ ALfilter *AllocFilter(ALCdevice *device)
 {
     auto sublist = std::find_if(device->FilterList.begin(), device->FilterList.end(),
         [](const FilterSubList &entry) noexcept -> bool
-        { return entry.FreeMask != 0; }
-    );
+        { return entry.FreeMask != 0; });
     auto lidx = static_cast<ALuint>(std::distance(device->FilterList.begin(), sublist));
-    auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+    ASSUME(slidx < 64);
 
-    ALfilter *filter{::new (sublist->Filters + slidx) ALfilter{}};
+    ALfilter *filter{al::construct_at(sublist->Filters + slidx)};
     InitFilterParams(filter, AL_FILTER_NULL);
 
     /* Add 1 to avoid filter ID 0. */
@@ -343,35 +391,35 @@ 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())
+    if(lidx >= device->FilterList.size()) UNLIKELY
         return nullptr;
     FilterSubList &sublist = device->FilterList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Filters + slidx;
 }
 
 } // namespace
 
-AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
+AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Generating %d filters", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
-    std::lock_guard<std::mutex> _{device->EffectLock};
+    ALCdevice *device{context->mALDevice.get()};
+    std::lock_guard<std::mutex> _{device->FilterLock};
     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)
+    if(n == 1) LIKELY
     {
         /* Special handling for the easy and normal case. */
         ALfilter *filter{AllocFilter(device)};
@@ -393,17 +441,17 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
+AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Deleting %d filters", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
     /* First try to find any filters that are invalid. */
@@ -412,7 +460,7 @@ START_API_FUNC
 
     const ALuint *filters_end = filters + n;
     auto invflt = std::find_if_not(filters, filters_end, validate_filter);
-    if UNLIKELY(invflt != filters_end)
+    if(invflt != filters_end) UNLIKELY
     {
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", *invflt);
         return;
@@ -432,9 +480,9 @@ AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if LIKELY(context)
+    if(context) LIKELY
     {
-        ALCdevice *device{context->mDevice.get()};
+        ALCdevice *device{context->mALDevice.get()};
         std::lock_guard<std::mutex> _{device->FilterLock};
         if(!filter || LookupFilter(device, filter))
             return AL_TRUE;
@@ -444,192 +492,216 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
+AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
     ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    if(!alfilt) UNLIKELY
         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)
+            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
+        else try
         {
             /* Call the appropriate handler */
-            ALfilter_setParami(alfilt, context.get(), param, value);
+            alfilt->setParami(param, value);
+        }
+        catch(filter_exception &e) {
+            context->setError(e.errorCode(), "%s", e.what());
         }
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *values)
+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;
+    case AL_FILTER_TYPE:
+        alFilteri(filter, param, values[0]);
+        return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
     ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_setParamiv(alfilt, context.get(), param, values);
+        alfilt->setParamiv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
+AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
     ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_setParamf(alfilt, context.get(), param, value);
+        alfilt->setParamf(param, value);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
+AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
     ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_setParamfv(alfilt, context.get(), param, values);
+        alfilt->setParamfv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
-    ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
     else
     {
         if(param == AL_FILTER_TYPE)
             *value = alfilt->type;
-        else
+        else try
         {
             /* Call the appropriate handler */
-            ALfilter_getParami(alfilt, context.get(), param, value);
+            alfilt->getParami(param, value);
+        }
+        catch(filter_exception &e) {
+            context->setError(e.errorCode(), "%s", e.what());
         }
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *values)
+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;
+    case AL_FILTER_TYPE:
+        alGetFilteri(filter, param, values);
+        return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
-    ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_getParamiv(alfilt, context.get(), param, values);
+        alfilt->getParamiv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
-    ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_getParamf(alfilt, context.get(), param, value);
+        alfilt->getParamf(param, value);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
+AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     std::lock_guard<std::mutex> _{device->FilterLock};
 
-    ALfilter *alfilt{LookupFilter(device, filter)};
-    if UNLIKELY(!alfilt)
+    const ALfilter *alfilt{LookupFilter(device, filter)};
+    if(!alfilt) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid filter ID %u", filter);
-    else
+    else try
     {
         /* Call the appropriate handler */
-        ALfilter_getParamfv(alfilt, context.get(), param, values);
+        alfilt->getParamfv(param, values);
+    }
+    catch(filter_exception &e) {
+        context->setError(e.errorCode(), "%s", e.what());
     }
 }
 END_API_FUNC
@@ -640,7 +712,7 @@ FilterSubList::~FilterSubList()
     uint64_t usemask{~FreeMask};
     while(usemask)
     {
-        ALsizei idx = CTZ64(usemask);
+        const int idx{al::countr_zero(usemask)};
         al::destroy_at(Filters+idx);
         usemask &= ~(1_u64 << idx);
     }
diff --git a/al/filter.h b/al/filter.h
index db098d70..65a9e30f 100644
--- a/al/filter.h
+++ b/al/filter.h
@@ -1,56 +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;
-
-struct ALfilterVtable {
-    void (*const setParami)(ALfilter *filter, ALCcontext *context, ALenum param, ALint val);
-    void (*const setParamiv)(ALfilter *filter, ALCcontext *context, ALenum param, const ALint *vals);
-    void (*const setParamf)(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val);
-    void (*const setParamfv)(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals);
+#define LOWPASSFREQREF  5000.0f
+#define HIGHPASSFREQREF  250.0f
 
-    void (*const getParami)(ALfilter *filter, ALCcontext *context, ALenum param, ALint *val);
-    void (*const getParamiv)(ALfilter *filter, ALCcontext *context, ALenum param, ALint *vals);
-    void (*const getParamf)(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val);
-    void (*const getParamfv)(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals);
-};
-
-#define DEFINE_ALFILTER_VTABLE(T)                                  \
-const ALfilterVtable T##_vtable = {                                \
-    T##_setParami, T##_setParamiv, T##_setParamf, T##_setParamfv,  \
-    T##_getParami, T##_getParamiv, T##_getParamf, T##_getParamfv,  \
-}
 
 struct ALfilter {
-    // Filter type (AL_FILTER_NULL, ...)
-    ALenum type;
-
-    ALfloat Gain;
-    ALfloat GainHF;
-    ALfloat HFReference;
-    ALfloat GainLF;
-    ALfloat LFReference;
-
-    const ALfilterVtable *vtab;
+    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;
+    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()
 };
-#define ALfilter_setParami(o, c, p, v)   ((o)->vtab->setParami(o, c, p, v))
-#define ALfilter_setParamf(o, c, p, v)   ((o)->vtab->setParamf(o, c, p, v))
-#define ALfilter_setParamiv(o, c, p, v)  ((o)->vtab->setParamiv(o, c, p, v))
-#define ALfilter_setParamfv(o, c, p, v)  ((o)->vtab->setParamfv(o, c, p, v))
-#define ALfilter_getParami(o, c, p, v)   ((o)->vtab->getParami(o, c, p, v))
-#define ALfilter_getParamf(o, c, p, v)   ((o)->vtab->getParamf(o, c, p, v))
-#define ALfilter_getParamiv(o, c, p, v)  ((o)->vtab->getParamiv(o, c, p, v))
-#define ALfilter_getParamfv(o, c, p, v)  ((o)->vtab->getParamfv(o, c, p, v))
 
 #endif
diff --git a/al/listener.cpp b/al/listener.cpp
index 7a14a9ba..06d7c370 100644
--- a/al/listener.cpp
+++ b/al/listener.cpp
@@ -29,26 +29,50 @@
 #include "AL/alc.h"
 #include "AL/efx.h"
 
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "alc/context.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)
+namespace {
 
+inline void UpdateProps(ALCcontext *context)
+{
+    if(!context->mDeferUpdates)
+    {
+        UpdateContextProps(context);
+        return;
+    }
+    context->mPropsDirty = true;
+}
+
+inline void CommitAndUpdateProps(ALCcontext *context)
+{
+    if(!context->mDeferUpdates)
+    {
+#ifdef ALSOFT_EAX
+        if(context->eaxNeedsCommit())
+        {
+            context->mPropsDirty = true;
+            context->applyAllUpdates();
+            return;
+        }
+#endif
+        UpdateContextProps(context);
+        return;
+    }
+    context->mPropsDirty = true;
+}
 
-AL_API ALvoid AL_APIENTRY alListenerf(ALenum param, ALfloat value)
+} // namespace
+
+AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -56,16 +80,16 @@ START_API_FUNC
     {
     case AL_GAIN:
         if(!(value >= 0.0f && std::isfinite(value)))
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener gain out of range");
+            return context->setError(AL_INVALID_VALUE, "Listener gain out of range");
         listener.Gain = value;
-        DO_UPDATEPROPS();
+        UpdateProps(context.get());
         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");
+            return context->setError(AL_INVALID_VALUE, "Listener meters per unit out of range");
         listener.mMetersPerUnit = value;
-        DO_UPDATEPROPS();
+        UpdateProps(context.get());
         break;
 
     default:
@@ -74,11 +98,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -86,20 +110,20 @@ START_API_FUNC
     {
     case AL_POSITION:
         if(!(std::isfinite(value1) && std::isfinite(value2) && std::isfinite(value3)))
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Listener position out of range");
+            return context->setError(AL_INVALID_VALUE, "Listener position out of range");
         listener.Position[0] = value1;
         listener.Position[1] = value2;
         listener.Position[2] = value3;
-        DO_UPDATEPROPS();
+        CommitAndUpdateProps(context.get());
         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");
+            return context->setError(AL_INVALID_VALUE, "Listener velocity out of range");
         listener.Velocity[0] = value1;
         listener.Velocity[1] = value2;
         listener.Velocity[2] = value3;
-        DO_UPDATEPROPS();
+        CommitAndUpdateProps(context.get());
         break;
 
     default:
@@ -108,7 +132,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values)
+AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values)
 START_API_FUNC
 {
     if(values)
@@ -128,17 +152,19 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
+
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
 
     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");
+            return context->setError(AL_INVALID_VALUE, "Listener orientation out of range");
         /* AT then UP */
         listener.OrientAt[0] = values[0];
         listener.OrientAt[1] = values[1];
@@ -146,7 +172,7 @@ START_API_FUNC
         listener.OrientUp[0] = values[3];
         listener.OrientUp[1] = values[4];
         listener.OrientUp[2] = values[5];
-        DO_UPDATEPROPS();
+        CommitAndUpdateProps(context.get());
         break;
 
     default:
@@ -156,11 +182,11 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alListeneri(ALenum param, ALint /*value*/)
+AL_API void AL_APIENTRY alListeneri(ALenum param, ALint /*value*/)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     switch(param)
@@ -178,12 +204,13 @@ START_API_FUNC
     {
     case AL_POSITION:
     case AL_VELOCITY:
-        alListener3f(param, static_cast<ALfloat>(value1), static_cast<ALfloat>(value2), static_cast<ALfloat>(value3));
+        alListener3f(param, static_cast<ALfloat>(value1), static_cast<ALfloat>(value2),
+            static_cast<ALfloat>(value3));
         return;
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     switch(param)
@@ -204,7 +231,8 @@ START_API_FUNC
         {
         case AL_POSITION:
         case AL_VELOCITY:
-            alListener3f(param, static_cast<ALfloat>(values[0]), static_cast<ALfloat>(values[1]), static_cast<ALfloat>(values[2]));
+            alListener3f(param, static_cast<ALfloat>(values[0]), static_cast<ALfloat>(values[1]),
+                static_cast<ALfloat>(values[2]));
             return;
 
         case AL_ORIENTATION:
@@ -220,10 +248,10 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
-    if(!values)
+    if(!values) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else switch(param)
     {
@@ -234,11 +262,11 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -260,11 +288,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
+AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -290,7 +318,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
+AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
 START_API_FUNC
 {
     switch(param)
@@ -307,7 +335,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -332,11 +360,11 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     if(!value)
@@ -353,7 +381,7 @@ AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *valu
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -391,7 +419,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     ALlistener &listener = context->mListener;
     std::lock_guard<std::mutex> _{context->mPropLock};
@@ -414,39 +442,3 @@ START_API_FUNC
     }
 }
 END_API_FUNC
-
-
-void UpdateListenerProps(ALCcontext *context)
-{
-    /* Get an unused proprty container, or allocate a new one as needed. */
-    ALlistenerProps *props{context->mFreeListenerProps.load(std::memory_order_acquire)};
-    if(!props)
-        props = new ALlistenerProps{};
-    else
-    {
-        ALlistenerProps *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 = listener.Params.Update.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);
-    }
-}
diff --git a/al/listener.h b/al/listener.h
index 318ab024..81532877 100644
--- a/al/listener.h
+++ b/al/listener.h
@@ -2,63 +2,23 @@
 #define AL_LISTENER_H
 
 #include <array>
-#include <atomic>
 
 #include "AL/al.h"
 #include "AL/alc.h"
 #include "AL/efx.h"
 
 #include "almalloc.h"
-#include "vecmat.h"
 
-enum class DistanceModel;
-
-
-struct ALlistenerProps {
-    std::array<ALfloat,3> Position;
-    std::array<ALfloat,3> Velocity;
-    std::array<ALfloat,3> OrientAt;
-    std::array<ALfloat,3> OrientUp;
-    ALfloat Gain;
-    ALfloat MetersPerUnit;
-
-    std::atomic<ALlistenerProps*> next;
-
-    DEF_NEWDEL(ALlistenerProps)
-};
 
 struct ALlistener {
-    std::array<ALfloat,3> Position{{0.0f, 0.0f, 0.0f}};
-    std::array<ALfloat,3> Velocity{{0.0f, 0.0f, 0.0f}};
-    std::array<ALfloat,3> OrientAt{{0.0f, 0.0f, -1.0f}};
-    std::array<ALfloat,3> OrientUp{{0.0f, 1.0f, 0.0f}};
-    ALfloat Gain{1.0f};
-    ALfloat mMetersPerUnit{AL_DEFAULT_METERS_PER_UNIT};
-
-    std::atomic_flag PropsClean;
-
-    struct {
-        /* Pointer to the most recent property values that are awaiting an
-         * update.
-         */
-        std::atomic<ALlistenerProps*> Update{nullptr};
-
-        alu::Matrix Matrix;
-        alu::Vector Velocity;
-
-        ALfloat Gain;
-        ALfloat MetersPerUnit;
-
-        ALfloat DopplerFactor;
-        ALfloat SpeedOfSound; /* in units per sec! */
-
-        ALboolean SourceDistanceModel;
-        DistanceModel mDistanceModel;
-    } Params;
-
-    ALlistener() { PropsClean.test_and_set(std::memory_order_relaxed); }
+    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};
+
+    DISABLE_ALLOC()
 };
 
-void UpdateListenerProps(ALCcontext *context);
-
 #endif
diff --git a/al/source.cpp b/al/source.cpp
index 8b8e6382..cba33862 100644
--- a/al/source.cpp
+++ b/al/source.cpp
@@ -31,12 +31,14 @@
 #include <cmath>
 #include <cstdint>
 #include <functional>
+#include <inttypes.h>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <mutex>
 #include <new>
 #include <numeric>
+#include <stdexcept>
 #include <thread>
 #include <utility>
 
@@ -45,67 +47,74 @@
 #include "AL/alext.h"
 #include "AL/efx.h"
 
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alexcpt.h"
+#include "albit.h"
+#include "alc/alu.h"
+#include "alc/backends/base.h"
+#include "alc/context.h"
+#include "alc/device.h"
+#include "alc/inprogext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "aloptional.h"
 #include "alspan.h"
-#include "alu.h"
-#include "ambidefs.h"
 #include "atomic.h"
 #include "auxeffectslot.h"
-#include "backends/base.h"
-#include "bformatdec.h"
 #include "buffer.h"
+#include "core/ambidefs.h"
+#include "core/bformatdec.h"
+#include "core/except.h"
+#include "core/filters/nfc.h"
+#include "core/filters/splitter.h"
+#include "core/logging.h"
+#include "core/voice_change.h"
 #include "event.h"
 #include "filter.h"
-#include "filters/nfc.h"
-#include "filters/splitter.h"
-#include "inprogext.h"
-#include "logging.h"
-#include "math_defs.h"
 #include "opthelpers.h"
 #include "ringbuffer.h"
 #include "threads.h"
 
+#ifdef ALSOFT_EAX
+#include <cassert>
+#endif // ALSOFT_EAX
+
+bool sBufferSubDataCompat{false};
 
 namespace {
 
 using namespace std::placeholders;
 using std::chrono::nanoseconds;
 
-ALvoice *GetSourceVoice(ALsource *source, ALCcontext *context)
+Voice *GetSourceVoice(ALsource *source, ALCcontext *context)
 {
+    auto voicelist = context->getVoicesSpan();
     ALuint idx{source->VoiceIdx};
-    if(idx < context->mVoices.size())
+    if(idx < voicelist.size())
     {
         ALuint sid{source->id};
-        ALvoice &voice = context->mVoices[idx];
-        if(voice.mSourceID.load(std::memory_order_acquire) == sid)
-            return &voice;
+        Voice *voice = voicelist[idx];
+        if(voice->mSourceID.load(std::memory_order_acquire) == sid)
+            return voice;
     }
     source->VoiceIdx = INVALID_VOICE_IDX;
     return nullptr;
 }
 
-void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *context)
+
+void UpdateSourceProps(const ALsource *source, Voice *voice, ALCcontext *context)
 {
     /* Get an unused property container, or allocate a new one as needed. */
-    ALvoiceProps *props{context->mFreeVoiceProps.load(std::memory_order_acquire)};
+    VoicePropsItem *props{context->mFreeVoiceProps.load(std::memory_order_acquire)};
     if(!props)
-        props = new ALvoiceProps{};
-    else
     {
-        ALvoiceProps *next;
-        do {
-            next = props->next.load(std::memory_order_relaxed);
-        } while(context->mFreeVoiceProps.compare_exchange_weak(props, next,
-                std::memory_order_acq_rel, std::memory_order_acquire) == 0);
+        context->allocVoiceProps();
+        props = context->mFreeVoiceProps.load(std::memory_order_acquire);
     }
+    VoicePropsItem *next;
+    do {
+        next = props->next.load(std::memory_order_relaxed);
+    } while(context->mFreeVoiceProps.compare_exchange_weak(props, next,
+        std::memory_order_acq_rel, std::memory_order_acquire) == false);
 
-    /* Copy in current property values. */
     props->Pitch = source->Pitch;
     props->Gain = source->Gain;
     props->OuterGain = source->OuterGain;
@@ -115,7 +124,11 @@ void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *conte
     props->OuterAngle = source->OuterAngle;
     props->RefDistance = source->RefDistance;
     props->MaxDistance = source->MaxDistance;
-    props->RolloffFactor = source->RolloffFactor;
+    props->RolloffFactor = source->RolloffFactor
+#ifdef ALSOFT_EAX
+        + source->RolloffFactor2
+#endif
+    ;
     props->Position = source->Position;
     props->Velocity = source->Velocity;
     props->Direction = source->Direction;
@@ -139,6 +152,7 @@ void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *conte
     props->StereoPan = source->StereoPan;
 
     props->Radius = source->Radius;
+    props->EnhWidth = source->EnhWidth;
 
     props->Direct.Gain = source->Direct.Gain;
     props->Direct.GainHF = source->Direct.GainHF;
@@ -146,10 +160,10 @@ void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *conte
     props->Direct.GainLF = source->Direct.GainLF;
     props->Direct.LFReference = source->Direct.LFReference;
 
-    auto copy_send = [](const ALsource::SendData &srcsend) noexcept -> ALvoicePropsBase::SendData
+    auto copy_send = [](const ALsource::SendData &srcsend) noexcept -> VoiceProps::SendData
     {
-        ALvoicePropsBase::SendData ret;
-        ret.Slot = srcsend.Slot;
+        VoiceProps::SendData ret{};
+        ret.Slot = srcsend.Slot ? srcsend.Slot->mSlot : nullptr;
         ret.Gain = srcsend.Gain;
         ret.GainHF = srcsend.GainHF;
         ret.HFReference = srcsend.HFReference;
@@ -158,6 +172,8 @@ void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *conte
         return ret;
     };
     std::transform(source->Send.cbegin(), source->Send.cend(), props->Send, copy_send);
+    if(!props->Send[0].Slot && context->mDefaultSlot)
+        props->Send[0].Slot = context->mDefaultSlot->mSlot;
 
     /* Set the new container for updating internal parameters. */
     props = voice->mUpdate.exchange(props, std::memory_order_acq_rel);
@@ -178,43 +194,37 @@ void UpdateSourceProps(const ALsource *source, ALvoice *voice, ALCcontext *conte
  */
 int64_t GetSourceSampleOffset(ALsource *Source, ALCcontext *context, nanoseconds *clocktime)
 {
-    ALCdevice *device{context->mDevice.get()};
-    const ALbufferlistitem *Current;
-    uint64_t readPos;
-    ALuint refcount;
-    ALvoice *voice;
+    ALCdevice *device{context->mALDevice.get()};
+    const VoiceBufferItem *Current{};
+    int64_t readPos{};
+    uint refcount{};
+    Voice *voice{};
 
     do {
-        Current = nullptr;
-        readPos = 0;
-        while(((refcount=device->MixCount.load(std::memory_order_acquire))&1))
-            std::this_thread::yield();
+        refcount = device->waitForMix();
         *clocktime = GetDeviceClockTime(device);
-
         voice = GetSourceVoice(Source, context);
         if(voice)
         {
             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
 
-            readPos  = uint64_t{voice->mPosition.load(std::memory_order_relaxed)} << 32;
-            readPos |= uint64_t{voice->mPositionFrac.load(std::memory_order_relaxed)} <<
-                       (32-FRACTIONBITS);
+            readPos  = int64_t{voice->mPosition.load(std::memory_order_relaxed)} << MixerFracBits;
+            readPos += voice->mPositionFrac.load(std::memory_order_relaxed);
         }
         std::atomic_thread_fence(std::memory_order_acquire);
     } while(refcount != device->MixCount.load(std::memory_order_relaxed));
 
-    if(voice)
+    if(!voice)
+        return 0;
+
+    for(auto &item : Source->mQueue)
     {
-        const ALbufferlistitem *BufferList{Source->queue};
-        while(BufferList && BufferList != Current)
-        {
-            readPos += uint64_t{BufferList->mSampleLen} << 32;
-            BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-        }
-        readPos = minu64(readPos, 0x7fffffffffffffff_u64);
+        if(&item == Current) break;
+        readPos += int64_t{item.mSampleLen} << MixerFracBits;
     }
-
-    return static_cast<int64_t>(readPos);
+    if(readPos > std::numeric_limits<int64_t>::max() >> (32-MixerFracBits))
+        return std::numeric_limits<int64_t>::max();
+    return readPos << (32-MixerFracBits);
 }
 
 /* GetSourceSecOffset
@@ -222,55 +232,47 @@ int64_t GetSourceSampleOffset(ALsource *Source, ALCcontext *context, nanoseconds
  * Gets the current read offset for the given Source, in seconds. The offset is
  * relative to the start of the queue (not the start of the current buffer).
  */
-ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, nanoseconds *clocktime)
+double GetSourceSecOffset(ALsource *Source, ALCcontext *context, nanoseconds *clocktime)
 {
-    ALCdevice *device{context->mDevice.get()};
-    const ALbufferlistitem *Current;
-    uint64_t readPos;
-    ALuint refcount;
-    ALvoice *voice;
+    ALCdevice *device{context->mALDevice.get()};
+    const VoiceBufferItem *Current{};
+    int64_t readPos{};
+    uint refcount{};
+    Voice *voice{};
 
     do {
-        Current = nullptr;
-        readPos = 0;
-        while(((refcount=device->MixCount.load(std::memory_order_acquire))&1))
-            std::this_thread::yield();
+        refcount = device->waitForMix();
         *clocktime = GetDeviceClockTime(device);
-
         voice = GetSourceVoice(Source, context);
         if(voice)
         {
             Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
 
-            readPos  = uint64_t{voice->mPosition.load(std::memory_order_relaxed)} << FRACTIONBITS;
-            readPos |= voice->mPositionFrac.load(std::memory_order_relaxed);
+            readPos  = int64_t{voice->mPosition.load(std::memory_order_relaxed)} << MixerFracBits;
+            readPos += voice->mPositionFrac.load(std::memory_order_relaxed);
         }
         std::atomic_thread_fence(std::memory_order_acquire);
     } while(refcount != device->MixCount.load(std::memory_order_relaxed));
 
-    ALdouble offset{0.0};
-    if(voice)
-    {
-        const ALbufferlistitem *BufferList{Source->queue};
-        const ALbuffer *BufferFmt{nullptr};
-        while(BufferList && BufferList != Current)
-        {
-            if(!BufferFmt) BufferFmt = BufferList->mBuffer;
-            readPos += uint64_t{BufferList->mSampleLen} << FRACTIONBITS;
-            BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-        }
+    if(!voice)
+        return 0.0f;
 
-        while(BufferList && !BufferFmt)
-        {
-            BufferFmt = BufferList->mBuffer;
-            BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-        }
-        assert(BufferFmt != nullptr);
-
-        offset = static_cast<ALdouble>(readPos) / ALdouble{FRACTIONONE} / BufferFmt->Frequency;
+    const ALbuffer *BufferFmt{nullptr};
+    auto BufferList = Source->mQueue.cbegin();
+    while(BufferList != Source->mQueue.cend() && al::to_address(BufferList) != Current)
+    {
+        if(!BufferFmt) BufferFmt = BufferList->mBuffer;
+        readPos += int64_t{BufferList->mSampleLen} << MixerFracBits;
+        ++BufferList;
     }
+    while(BufferList != Source->mQueue.cend() && !BufferFmt)
+    {
+        BufferFmt = BufferList->mBuffer;
+        ++BufferList;
+    }
+    ASSUME(BufferFmt != nullptr);
 
-    return offset;
+    return static_cast<double>(readPos) / double{MixerFracOne} / BufferFmt->mSampleRate;
 }
 
 /* GetSourceOffset
@@ -279,20 +281,17 @@ ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, nanoseconds *
  * (Bytes, Samples or Seconds). The offset is relative to the start of the
  * queue (not the start of the current buffer).
  */
-ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
+double GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
 {
-    ALCdevice *device{context->mDevice.get()};
-    const ALbufferlistitem *Current;
-    ALuint readPos;
-    ALuint readPosFrac;
-    ALuint refcount;
-    ALvoice *voice;
+    ALCdevice *device{context->mALDevice.get()};
+    const VoiceBufferItem *Current{};
+    int64_t readPos{};
+    uint readPosFrac{};
+    uint refcount;
+    Voice *voice;
 
     do {
-        Current = nullptr;
-        readPos = readPosFrac = 0;
-        while(((refcount=device->MixCount.load(std::memory_order_acquire))&1))
-            std::this_thread::yield();
+        refcount = device->waitForMix();
         voice = GetSourceVoice(Source, context);
         if(voice)
         {
@@ -304,164 +303,355 @@ ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
         std::atomic_thread_fence(std::memory_order_acquire);
     } while(refcount != device->MixCount.load(std::memory_order_relaxed));
 
-    ALdouble offset{0.0};
-    if(!voice) return offset;
+    if(!voice)
+        return 0.0;
 
-    const ALbufferlistitem *BufferList{Source->queue};
     const ALbuffer *BufferFmt{nullptr};
-    ALuint totalBufferLen{0u};
-    bool readFin{false};
-
-    while(BufferList)
+    auto BufferList = Source->mQueue.cbegin();
+    while(BufferList != Source->mQueue.cend() && al::to_address(BufferList) != Current)
     {
         if(!BufferFmt) BufferFmt = BufferList->mBuffer;
-
-        readFin |= (BufferList == Current);
-        totalBufferLen += BufferList->mSampleLen;
-        if(!readFin) readPos += BufferList->mSampleLen;
-
-        BufferList = BufferList->mNext.load(std::memory_order_relaxed);
+        readPos += BufferList->mSampleLen;
+        ++BufferList;
     }
-    assert(BufferFmt != nullptr);
-
-    if(Source->Looping)
-        readPos %= totalBufferLen;
-    else
+    while(BufferList != Source->mQueue.cend() && !BufferFmt)
     {
-        /* Wrap back to 0 */
-        if(readPos >= totalBufferLen)
-            readPos = readPosFrac = 0;
+        BufferFmt = BufferList->mBuffer;
+        ++BufferList;
     }
+    ASSUME(BufferFmt != nullptr);
 
+    double offset{};
     switch(name)
     {
     case AL_SEC_OFFSET:
-        offset = (readPos + static_cast<ALdouble>(readPosFrac)/FRACTIONONE) / BufferFmt->Frequency;
+        offset  = static_cast<double>(readPos) + readPosFrac/double{MixerFracOne};
+        offset /= BufferFmt->mSampleRate;
         break;
 
     case AL_SAMPLE_OFFSET:
-        offset = readPos + static_cast<ALdouble>(readPosFrac)/FRACTIONONE;
+        offset = static_cast<double>(readPos) + readPosFrac/double{MixerFracOne};
         break;
 
     case AL_BYTE_OFFSET:
-        if(BufferFmt->OriginalType == UserFmtIMA4)
-        {
-            ALuint FrameBlockSize{BufferFmt->OriginalAlign};
-            ALuint align{(BufferFmt->OriginalAlign-1)/2 + 4};
-            ALuint BlockSize{align * ChannelsFromFmt(BufferFmt->mFmtChannels)};
+        const ALuint BlockSamples{BufferFmt->mBlockAlign};
+        const ALuint BlockSize{BufferFmt->blockSizeFromFmt()};
 
-            /* Round down to nearest ADPCM block */
-            offset = static_cast<ALdouble>(readPos / FrameBlockSize * BlockSize);
-        }
-        else if(BufferFmt->OriginalType == UserFmtMSADPCM)
-        {
-            ALuint FrameBlockSize{BufferFmt->OriginalAlign};
-            ALuint align{(FrameBlockSize-2)/2 + 7};
-            ALuint BlockSize{align * ChannelsFromFmt(BufferFmt->mFmtChannels)};
-
-            /* Round down to nearest ADPCM block */
-            offset = static_cast<ALdouble>(readPos / FrameBlockSize * BlockSize);
-        }
-        else
-        {
-            const ALuint FrameSize{FrameSizeFromFmt(BufferFmt->mFmtChannels, BufferFmt->mFmtType)};
-            offset = static_cast<ALdouble>(readPos * FrameSize);
-        }
+        /* Round down to the block boundary. */
+        offset = static_cast<double>(readPos / BlockSamples) * BlockSize;
         break;
     }
-
     return offset;
 }
 
+/* GetSourceLength
+ *
+ * Gets the length of the given Source's buffer queue, in the appropriate
+ * format (Bytes, Samples or Seconds).
+ */
+double GetSourceLength(const ALsource *source, ALenum name)
+{
+    uint64_t length{0};
+    const ALbuffer *BufferFmt{nullptr};
+    for(auto &listitem : source->mQueue)
+    {
+        if(!BufferFmt)
+            BufferFmt = listitem.mBuffer;
+        length += listitem.mSampleLen;
+    }
+    if(length == 0)
+        return 0.0;
+
+    ASSUME(BufferFmt != nullptr);
+    switch(name)
+    {
+    case AL_SEC_LENGTH_SOFT:
+        return static_cast<double>(length) / BufferFmt->mSampleRate;
+
+    case AL_SAMPLE_LENGTH_SOFT:
+        return static_cast<double>(length);
+
+    case AL_BYTE_LENGTH_SOFT:
+        const ALuint BlockSamples{BufferFmt->mBlockAlign};
+        const ALuint BlockSize{BufferFmt->blockSizeFromFmt()};
+
+        /* Round down to the block boundary. */
+        return static_cast<double>(length / BlockSamples) * BlockSize;
+    }
+    return 0.0;
+}
+
 
 struct VoicePos {
-    ALuint pos, frac;
-    ALbufferlistitem *bufferitem;
+    int pos;
+    uint frac;
+    ALbufferQueueItem *bufferitem;
 };
 
 /**
  * GetSampleOffset
  *
  * Retrieves the voice position, fixed-point fraction, and bufferlist item
- * using the source's stored offset and offset type. If the source has no
- * stored offset, or the offset is out of range, returns an empty optional.
+ * using the givem offset type and offset. If the offset is out of range,
+ * returns an empty optional.
  */
-al::optional<VoicePos> GetSampleOffset(ALsource *Source)
+al::optional<VoicePos> GetSampleOffset(al::deque<ALbufferQueueItem> &BufferList, ALenum OffsetType,
+    double Offset)
 {
-    al::optional<VoicePos> ret;
-
     /* Find the first valid Buffer in the Queue */
     const ALbuffer *BufferFmt{nullptr};
-    ALbufferlistitem *BufferList{Source->queue};
-    while(BufferList)
+    for(auto &item : BufferList)
     {
-        if((BufferFmt=BufferList->mBuffer) != nullptr) break;
-        BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-    }
-    if(!BufferList)
-    {
-        Source->OffsetType = AL_NONE;
-        Source->Offset = 0.0;
-        return ret;
+        BufferFmt = item.mBuffer;
+        if(BufferFmt) break;
     }
+    if(!BufferFmt) UNLIKELY
+        return al::nullopt;
 
     /* Get sample frame offset */
-    ALuint offset{0u}, frac{0u};
-    ALdouble dbloff, dblfrac;
-    switch(Source->OffsetType)
+    int64_t offset{};
+    uint frac{};
+    double dbloff, dblfrac;
+    switch(OffsetType)
     {
-    case AL_BYTE_OFFSET:
-        /* Determine the ByteOffset (and ensure it is block aligned) */
-        offset = static_cast<ALuint>(Source->Offset);
-        if(BufferFmt->OriginalType == UserFmtIMA4)
-        {
-            const ALuint align{(BufferFmt->OriginalAlign-1)/2 + 4};
-            offset /= align * ChannelsFromFmt(BufferFmt->mFmtChannels);
-            offset *= BufferFmt->OriginalAlign;
-        }
-        else if(BufferFmt->OriginalType == UserFmtMSADPCM)
+    case AL_SEC_OFFSET:
+        dblfrac = std::modf(Offset*BufferFmt->mSampleRate, &dbloff);
+        if(dblfrac < 0.0)
         {
-            const ALuint align{(BufferFmt->OriginalAlign-2)/2 + 7};
-            offset /= align * ChannelsFromFmt(BufferFmt->mFmtChannels);
-            offset *= BufferFmt->OriginalAlign;
+            /* If there's a negative fraction, reduce the offset to "floor" it,
+             * and convert the fraction to a percentage to the next value (e.g.
+             * -2.75 -> -3 + 0.25).
+             */
+            dbloff -= 1.0;
+            dblfrac += 1.0;
         }
-        else
-            offset /= FrameSizeFromFmt(BufferFmt->mFmtChannels, BufferFmt->mFmtType);
-        frac = 0;
+        offset = static_cast<int64_t>(dbloff);
+        frac = static_cast<uint>(mind(dblfrac*MixerFracOne, MixerFracOne-1.0));
         break;
 
     case AL_SAMPLE_OFFSET:
-        dblfrac = std::modf(Source->Offset, &dbloff);
-        offset = static_cast<ALuint>(mind(dbloff, std::numeric_limits<ALuint>::max()));
-        frac = static_cast<ALuint>(mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0));
+        dblfrac = std::modf(Offset, &dbloff);
+        if(dblfrac < 0.0)
+        {
+            dbloff -= 1.0;
+            dblfrac += 1.0;
+        }
+        offset = static_cast<int64_t>(dbloff);
+        frac = static_cast<uint>(mind(dblfrac*MixerFracOne, MixerFracOne-1.0));
         break;
 
-    case AL_SEC_OFFSET:
-        dblfrac = std::modf(Source->Offset*BufferFmt->Frequency, &dbloff);
-        offset = static_cast<ALuint>(mind(dbloff, std::numeric_limits<ALuint>::max()));
-        frac = static_cast<ALuint>(mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0));
+    case AL_BYTE_OFFSET:
+        /* Determine the ByteOffset (and ensure it is block aligned) */
+        Offset = std::floor(Offset / BufferFmt->blockSizeFromFmt());
+        offset = static_cast<int64_t>(Offset) * BufferFmt->mBlockAlign;
+        frac = 0;
         break;
     }
-    Source->OffsetType = AL_NONE;
-    Source->Offset = 0.0;
 
     /* Find the bufferlist item this offset belongs to. */
-    ALuint totalBufferLen{0u};
-    while(BufferList && totalBufferLen <= offset)
+    if(offset < 0)
     {
-        if(BufferList->mSampleLen > offset-totalBufferLen)
+        if(offset < std::numeric_limits<int>::min())
+            return al::nullopt;
+        return VoicePos{static_cast<int>(offset), frac, &BufferList.front()};
+    }
+
+    if(BufferFmt->mCallback)
+        return al::nullopt;
+
+    int64_t totalBufferLen{0};
+    for(auto &item : BufferList)
+    {
+        if(totalBufferLen > offset)
+            break;
+        if(item.mSampleLen > offset-totalBufferLen)
         {
             /* Offset is in this buffer */
-            ret = {offset-totalBufferLen, frac, BufferList};
-            return ret;
+            return VoicePos{static_cast<int>(offset-totalBufferLen), frac, &item};
         }
-        totalBufferLen += BufferList->mSampleLen;
-
-        BufferList = BufferList->mNext.load(std::memory_order_relaxed);
+        totalBufferLen += item.mSampleLen;
     }
 
     /* Offset is out of range of the queue */
-    return ret;
+    return al::nullopt;
+}
+
+
+void InitVoice(Voice *voice, ALsource *source, ALbufferQueueItem *BufferList, ALCcontext *context,
+    ALCdevice *device)
+{
+    voice->mLoopBuffer.store(source->Looping ? &source->mQueue.front() : nullptr,
+        std::memory_order_relaxed);
+
+    ALbuffer *buffer{BufferList->mBuffer};
+    voice->mFrequency = buffer->mSampleRate;
+    voice->mFmtChannels =
+        (buffer->mChannels == FmtStereo && source->mStereoMode == SourceStereo::Enhanced) ?
+        FmtSuperStereo : buffer->mChannels;
+    voice->mFmtType = buffer->mType;
+    voice->mFrameStep = buffer->channelsFromFmt();
+    voice->mBytesPerBlock = buffer->blockSizeFromFmt();
+    voice->mSamplesPerBlock = buffer->mBlockAlign;
+    voice->mAmbiLayout = IsUHJ(voice->mFmtChannels) ? AmbiLayout::FuMa : buffer->mAmbiLayout;
+    voice->mAmbiScaling = IsUHJ(voice->mFmtChannels) ? AmbiScaling::UHJ : buffer->mAmbiScaling;
+    voice->mAmbiOrder = (voice->mFmtChannels == FmtSuperStereo) ? 1 : buffer->mAmbiOrder;
+
+    if(buffer->mCallback) voice->mFlags.set(VoiceIsCallback);
+    else if(source->SourceType == AL_STATIC) voice->mFlags.set(VoiceIsStatic);
+    voice->mNumCallbackBlocks = 0;
+    voice->mCallbackBlockBase = 0;
+
+    voice->prepare(device);
+
+    source->mPropsDirty = false;
+    UpdateSourceProps(source, voice, context);
+
+    voice->mSourceID.store(source->id, std::memory_order_release);
+}
+
+
+VoiceChange *GetVoiceChanger(ALCcontext *ctx)
+{
+    VoiceChange *vchg{ctx->mVoiceChangeTail};
+    if(vchg == ctx->mCurrentVoiceChange.load(std::memory_order_acquire)) UNLIKELY
+    {
+        ctx->allocVoiceChanges();
+        vchg = ctx->mVoiceChangeTail;
+    }
+
+    ctx->mVoiceChangeTail = vchg->mNext.exchange(nullptr, std::memory_order_relaxed);
+
+    return vchg;
+}
+
+void SendVoiceChanges(ALCcontext *ctx, VoiceChange *tail)
+{
+    ALCdevice *device{ctx->mALDevice.get()};
+
+    VoiceChange *oldhead{ctx->mCurrentVoiceChange.load(std::memory_order_acquire)};
+    while(VoiceChange *next{oldhead->mNext.load(std::memory_order_relaxed)})
+        oldhead = next;
+    oldhead->mNext.store(tail, std::memory_order_release);
+
+    const bool connected{device->Connected.load(std::memory_order_acquire)};
+    device->waitForMix();
+    if(!connected) UNLIKELY
+    {
+        if(ctx->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
+        {
+            /* If the device is disconnected and voices are stopped, just
+             * ignore all pending changes.
+             */
+            VoiceChange *cur{ctx->mCurrentVoiceChange.load(std::memory_order_acquire)};
+            while(VoiceChange *next{cur->mNext.load(std::memory_order_acquire)})
+            {
+                cur = next;
+                if(Voice *voice{cur->mVoice})
+                    voice->mSourceID.store(0, std::memory_order_relaxed);
+            }
+            ctx->mCurrentVoiceChange.store(cur, std::memory_order_release);
+        }
+    }
+}
+
+
+bool SetVoiceOffset(Voice *oldvoice, const VoicePos &vpos, ALsource *source, ALCcontext *context,
+    ALCdevice *device)
+{
+    /* First, get a free voice to start at the new offset. */
+    auto voicelist = context->getVoicesSpan();
+    Voice *newvoice{};
+    ALuint vidx{0};
+    for(Voice *voice : voicelist)
+    {
+        if(voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
+            && voice->mSourceID.load(std::memory_order_relaxed) == 0u
+            && voice->mPendingChange.load(std::memory_order_relaxed) == false)
+        {
+            newvoice = voice;
+            break;
+        }
+        ++vidx;
+    }
+    if(!newvoice) UNLIKELY
+    {
+        auto &allvoices = *context->mVoices.load(std::memory_order_relaxed);
+        if(allvoices.size() == voicelist.size())
+            context->allocVoices(1);
+        context->mActiveVoiceCount.fetch_add(1, std::memory_order_release);
+        voicelist = context->getVoicesSpan();
+
+        vidx = 0;
+        for(Voice *voice : voicelist)
+        {
+            if(voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
+                && voice->mSourceID.load(std::memory_order_relaxed) == 0u
+                && voice->mPendingChange.load(std::memory_order_relaxed) == false)
+            {
+                newvoice = voice;
+                break;
+            }
+            ++vidx;
+        }
+        ASSUME(newvoice != nullptr);
+    }
+
+    /* Initialize the new voice and set its starting offset.
+     * TODO: It might be better to have the VoiceChange processing copy the old
+     * voice's mixing parameters (and pending update) insead of initializing it
+     * all here. This would just need to set the minimum properties to link the
+     * voice to the source and its position-dependent properties (including the
+     * fading flag).
+     */
+    newvoice->mPlayState.store(Voice::Pending, std::memory_order_relaxed);
+    newvoice->mPosition.store(vpos.pos, std::memory_order_relaxed);
+    newvoice->mPositionFrac.store(vpos.frac, std::memory_order_relaxed);
+    newvoice->mCurrentBuffer.store(vpos.bufferitem, std::memory_order_relaxed);
+    newvoice->mStartTime = oldvoice->mStartTime;
+    newvoice->mFlags.reset();
+    if(vpos.pos > 0 || (vpos.pos == 0 && vpos.frac > 0)
+        || vpos.bufferitem != &source->mQueue.front())
+        newvoice->mFlags.set(VoiceIsFading);
+    InitVoice(newvoice, source, vpos.bufferitem, context, device);
+    source->VoiceIdx = vidx;
+
+    /* Set the old voice as having a pending change, and send it off with the
+     * new one with a new offset voice change.
+     */
+    oldvoice->mPendingChange.store(true, std::memory_order_relaxed);
+
+    VoiceChange *vchg{GetVoiceChanger(context)};
+    vchg->mOldVoice = oldvoice;
+    vchg->mVoice = newvoice;
+    vchg->mSourceID = source->id;
+    vchg->mState = VChangeState::Restart;
+    SendVoiceChanges(context, vchg);
+
+    /* If the old voice still has a sourceID, it's still active and the change-
+     * over will work on the next update.
+     */
+    if(oldvoice->mSourceID.load(std::memory_order_acquire) != 0u) LIKELY
+        return true;
+
+    /* Otherwise, if the new voice's state is not pending, the change-over
+     * already happened.
+     */
+    if(newvoice->mPlayState.load(std::memory_order_acquire) != Voice::Pending)
+        return true;
+
+    /* Otherwise, wait for any current mix to finish and check one last time. */
+    device->waitForMix();
+    if(newvoice->mPlayState.load(std::memory_order_acquire) != Voice::Pending)
+        return true;
+    /* The change-over failed because the old voice stopped before the new
+     * voice could start at the new offset. Let go of the new voice and have
+     * the caller store the source offset since it's stopped.
+     */
+    newvoice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
+    newvoice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+    newvoice->mSourceID.store(0u, std::memory_order_relaxed);
+    newvoice->mPlayState.store(Voice::Stopped, std::memory_order_relaxed);
+    return false;
 }
 
 
@@ -476,42 +666,31 @@ inline bool IsPlayingOrPaused(ALsource *source)
  * Returns an updated source state using the matching voice's status (or lack
  * thereof).
  */
-inline ALenum GetSourceState(ALsource *source, ALvoice *voice)
+inline ALenum GetSourceState(ALsource *source, Voice *voice)
 {
     if(!voice && source->state == AL_PLAYING)
         source->state = AL_STOPPED;
     return source->state;
 }
 
-/**
- * Returns if the source should specify an update, given the context's
- * deferring state and the source's last known state.
- */
-inline bool SourceShouldUpdate(ALsource *source, ALCcontext *context)
-{
-    return !context->mDeferUpdates.load(std::memory_order_acquire) &&
-           IsPlayingOrPaused(source);
-}
-
 
 bool EnsureSources(ALCcontext *context, size_t needed)
 {
     size_t count{std::accumulate(context->mSourceList.cbegin(), context->mSourceList.cend(),
         size_t{0},
         [](size_t cur, const SourceSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(sublist.FreeMask)); }
-    )};
+        { return cur + static_cast<ALuint>(al::popcount(sublist.FreeMask)); })};
 
     while(needed > count)
     {
-        if UNLIKELY(context->mSourceList.size() >= 1<<25)
+        if(context->mSourceList.size() >= 1<<25) UNLIKELY
             return false;
 
         context->mSourceList.emplace_back();
         auto sublist = context->mSourceList.end() - 1;
         sublist->FreeMask = ~0_u64;
         sublist->Sources = static_cast<ALsource*>(al_calloc(alignof(ALsource), sizeof(ALsource)*64));
-        if UNLIKELY(!sublist->Sources)
+        if(!sublist->Sources) UNLIKELY
         {
             context->mSourceList.pop_back();
             return false;
@@ -521,16 +700,16 @@ bool EnsureSources(ALCcontext *context, size_t needed)
     return true;
 }
 
-ALsource *AllocSource(ALCcontext *context, ALuint num_sends)
+ALsource *AllocSource(ALCcontext *context)
 {
     auto sublist = std::find_if(context->mSourceList.begin(), context->mSourceList.end(),
         [](const SourceSubList &entry) noexcept -> bool
-        { return entry.FreeMask != 0; }
-    );
+        { return entry.FreeMask != 0; });
     auto lidx = static_cast<ALuint>(std::distance(context->mSourceList.begin(), sublist));
-    auto slidx = static_cast<ALuint>(CTZ64(sublist->FreeMask));
+    auto slidx = static_cast<ALuint>(al::countr_zero(sublist->FreeMask));
+    ASSUME(slidx < 64);
 
-    ALsource *source{::new (sublist->Sources + slidx) ALsource{num_sends}};
+    ALsource *source{al::construct_at(sublist->Sources + slidx)};
 
     /* Add 1 to avoid source ID 0. */
     source->id = ((lidx<<6) | slidx) + 1;
@@ -547,23 +726,16 @@ void FreeSource(ALCcontext *context, ALsource *source)
     const size_t lidx{id >> 6};
     const ALuint slidx{id & 0x3f};
 
-    if(IsPlayingOrPaused(source))
+    if(Voice *voice{GetSourceVoice(source, context)})
     {
-        ALCdevice *device{context->mDevice.get()};
-        BackendLockGuard _{*device->Backend};
-        if(ALvoice *voice{GetSourceVoice(source, context)})
-        {
-            voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mSourceID.store(0u, std::memory_order_relaxed);
-            std::atomic_thread_fence(std::memory_order_release);
-            /* Don't set the voice to stopping if it was already stopped or
-             * stopping.
-             */
-            ALvoice::State oldvstate{ALvoice::Playing};
-            voice->mPlayState.compare_exchange_strong(oldvstate, ALvoice::Stopping,
-                std::memory_order_acq_rel, std::memory_order_acquire);
-        }
+        VoiceChange *vchg{GetVoiceChanger(context)};
+
+        voice->mPendingChange.store(true, std::memory_order_relaxed);
+        vchg->mVoice = voice;
+        vchg->mSourceID = source->id;
+        vchg->mState = VChangeState::Stop;
+
+        SendVoiceChanges(context, vchg);
     }
 
     al::destroy_at(source);
@@ -578,10 +750,10 @@ inline ALsource *LookupSource(ALCcontext *context, ALuint id) noexcept
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= context->mSourceList.size())
+    if(lidx >= context->mSourceList.size()) UNLIKELY
         return nullptr;
     SourceSubList &sublist{context->mSourceList[lidx]};
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Sources + slidx;
 }
@@ -591,10 +763,10 @@ inline ALbuffer *LookupBuffer(ALCdevice *device, ALuint id) noexcept
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= device->BufferList.size())
+    if(lidx >= device->BufferList.size()) UNLIKELY
         return nullptr;
     BufferSubList &sublist = device->BufferList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Buffers + slidx;
 }
@@ -604,10 +776,10 @@ inline ALfilter *LookupFilter(ALCdevice *device, ALuint id) noexcept
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= device->FilterList.size())
+    if(lidx >= device->FilterList.size()) UNLIKELY
         return nullptr;
     FilterSubList &sublist = device->FilterList[lidx];
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.Filters + slidx;
 }
@@ -617,15 +789,108 @@ inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id) noexcept
     const size_t lidx{(id-1) >> 6};
     const ALuint slidx{(id-1) & 0x3f};
 
-    if UNLIKELY(lidx >= context->mEffectSlotList.size())
+    if(lidx >= context->mEffectSlotList.size()) UNLIKELY
         return nullptr;
     EffectSlotSubList &sublist{context->mEffectSlotList[lidx]};
-    if UNLIKELY(sublist.FreeMask & (1_u64 << slidx))
+    if(sublist.FreeMask & (1_u64 << slidx)) UNLIKELY
         return nullptr;
     return sublist.EffectSlots + slidx;
 }
 
 
+al::optional<SourceStereo> StereoModeFromEnum(ALenum mode)
+{
+    switch(mode)
+    {
+    case AL_NORMAL_SOFT: return SourceStereo::Normal;
+    case AL_SUPER_STEREO_SOFT: return SourceStereo::Enhanced;
+    }
+    WARN("Unsupported stereo mode: 0x%04x\n", mode);
+    return al::nullopt;
+}
+ALenum EnumFromStereoMode(SourceStereo mode)
+{
+    switch(mode)
+    {
+    case SourceStereo::Normal: return AL_NORMAL_SOFT;
+    case SourceStereo::Enhanced: return AL_SUPER_STEREO_SOFT;
+    }
+    throw std::runtime_error{"Invalid SourceStereo: "+std::to_string(int(mode))};
+}
+
+al::optional<SpatializeMode> SpatializeModeFromEnum(ALenum mode)
+{
+    switch(mode)
+    {
+    case AL_FALSE: return SpatializeMode::Off;
+    case AL_TRUE: return SpatializeMode::On;
+    case AL_AUTO_SOFT: return SpatializeMode::Auto;
+    }
+    WARN("Unsupported spatialize mode: 0x%04x\n", mode);
+    return al::nullopt;
+}
+ALenum EnumFromSpatializeMode(SpatializeMode mode)
+{
+    switch(mode)
+    {
+    case SpatializeMode::Off: return AL_FALSE;
+    case SpatializeMode::On: return AL_TRUE;
+    case SpatializeMode::Auto: return AL_AUTO_SOFT;
+    }
+    throw std::runtime_error{"Invalid SpatializeMode: "+std::to_string(int(mode))};
+}
+
+al::optional<DirectMode> DirectModeFromEnum(ALenum mode)
+{
+    switch(mode)
+    {
+    case AL_FALSE: return DirectMode::Off;
+    case AL_DROP_UNMATCHED_SOFT: return DirectMode::DropMismatch;
+    case AL_REMIX_UNMATCHED_SOFT: return DirectMode::RemixMismatch;
+    }
+    WARN("Unsupported direct mode: 0x%04x\n", mode);
+    return al::nullopt;
+}
+ALenum EnumFromDirectMode(DirectMode mode)
+{
+    switch(mode)
+    {
+    case DirectMode::Off: return AL_FALSE;
+    case DirectMode::DropMismatch: return AL_DROP_UNMATCHED_SOFT;
+    case DirectMode::RemixMismatch: return AL_REMIX_UNMATCHED_SOFT;
+    }
+    throw std::runtime_error{"Invalid DirectMode: "+std::to_string(int(mode))};
+}
+
+al::optional<DistanceModel> DistanceModelFromALenum(ALenum model)
+{
+    switch(model)
+    {
+    case AL_NONE: return DistanceModel::Disable;
+    case AL_INVERSE_DISTANCE: return DistanceModel::Inverse;
+    case AL_INVERSE_DISTANCE_CLAMPED: return DistanceModel::InverseClamped;
+    case AL_LINEAR_DISTANCE: return DistanceModel::Linear;
+    case AL_LINEAR_DISTANCE_CLAMPED: return DistanceModel::LinearClamped;
+    case AL_EXPONENT_DISTANCE: return DistanceModel::Exponent;
+    case AL_EXPONENT_DISTANCE_CLAMPED: return 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))};
+}
+
 enum SourceProp : ALenum {
     srcPitch = AL_PITCH,
     srcGain = AL_GAIN,
@@ -683,6 +948,11 @@ enum SourceProp : ALenum {
     /* AL_EXT_BFORMAT */
     srcOrientation = AL_ORIENTATION,
 
+    /* AL_SOFT_source_length */
+    srcByteLength = AL_BYTE_LENGTH_SOFT,
+    srcSampleLength = AL_SAMPLE_LENGTH_SOFT,
+    srcSecLength = AL_SEC_LENGTH_SOFT,
+
     /* AL_SOFT_source_resampler */
     srcResampler = AL_SOURCE_RESAMPLER_SOFT,
 
@@ -692,34 +962,175 @@ enum SourceProp : ALenum {
     /* ALC_SOFT_device_clock */
     srcSampleOffsetClockSOFT = AL_SAMPLE_OFFSET_CLOCK_SOFT,
     srcSecOffsetClockSOFT = AL_SEC_OFFSET_CLOCK_SOFT,
+
+    /* AL_SOFT_UHJ */
+    srcStereoMode = AL_STEREO_MODE_SOFT,
+    srcSuperStereoWidth = AL_SUPER_STEREO_WIDTH_SOFT,
+
+    /* AL_SOFT_buffer_sub_data */
+    srcByteRWOffsetsSOFT = AL_BYTE_RW_OFFSETS_SOFT,
+    srcSampleRWOffsetsSOFT = AL_SAMPLE_RW_OFFSETS_SOFT,
 };
 
 
-/** Can only be called while the mixer is locked! */
-void SendStateChangeEvent(ALCcontext *context, ALuint id, ALenum state)
+constexpr size_t MaxValues{6u};
+
+constexpr ALuint IntValsByProp(ALenum prop)
 {
-    ALbitfieldSOFT enabledevt{context->mEnabledEvts.load(std::memory_order_acquire)};
-    if(!(enabledevt&EventType_SourceStateChange)) return;
+    switch(static_cast<SourceProp>(prop))
+    {
+    case AL_SOURCE_STATE:
+    case AL_SOURCE_TYPE:
+    case AL_BUFFERS_QUEUED:
+    case AL_BUFFERS_PROCESSED:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SOURCE_RELATIVE:
+    case AL_LOOPING:
+    case AL_BUFFER:
+    case AL_SAMPLE_OFFSET:
+    case AL_BYTE_OFFSET:
+    case AL_DIRECT_FILTER:
+    case AL_DIRECT_FILTER_GAINHF_AUTO:
+    case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
+    case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
+    case AL_DIRECT_CHANNELS_SOFT:
+    case AL_DISTANCE_MODEL:
+    case AL_SOURCE_RESAMPLER_SOFT:
+    case AL_SOURCE_SPATIALIZE_SOFT:
+    case AL_STEREO_MODE_SOFT:
+        return 1;
 
-    /* The mixer may have queued a state change that's not yet been processed,
-     * and we don't want state change messages to occur out of order, so send
-     * it through the async queue to ensure proper ordering.
-     */
-    RingBuffer *ring{context->mAsyncEvents.get()};
-    auto evt_vec = ring->getWriteVector();
-    if(evt_vec.first.len < 1) return;
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            return 2;
+        /*fall-through*/
+    case AL_CONE_INNER_ANGLE:
+    case AL_CONE_OUTER_ANGLE:
+    case AL_PITCH:
+    case AL_GAIN:
+    case AL_MIN_GAIN:
+    case AL_MAX_GAIN:
+    case AL_REFERENCE_DISTANCE:
+    case AL_ROLLOFF_FACTOR:
+    case AL_CONE_OUTER_GAIN:
+    case AL_MAX_DISTANCE:
+    case AL_SEC_OFFSET:
+    case AL_DOPPLER_FACTOR:
+    case AL_CONE_OUTER_GAINHF:
+    case AL_AIR_ABSORPTION_FACTOR:
+    case AL_ROOM_ROLLOFF_FACTOR:
+    case AL_SEC_LENGTH_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        return 1; /* 1x float */
+
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+            return 2;
+        break;
+
+    case AL_AUXILIARY_SEND_FILTER:
+        return 3;
+
+    case AL_POSITION:
+    case AL_VELOCITY:
+    case AL_DIRECTION:
+        return 3; /* 3x float */
+
+    case AL_ORIENTATION:
+        return 6; /* 6x float */
+
+    case AL_SAMPLE_OFFSET_LATENCY_SOFT:
+    case AL_SAMPLE_OFFSET_CLOCK_SOFT:
+    case AL_STEREO_ANGLES:
+        break; /* i64 only */
+    case AL_SEC_OFFSET_LATENCY_SOFT:
+    case AL_SEC_OFFSET_CLOCK_SOFT:
+        break; /* double only */
+    }
 
-    AsyncEvent *evt{::new (evt_vec.first.buf) AsyncEvent{EventType_SourceStateChange}};
-    evt->u.srcstate.id = id;
-    evt->u.srcstate.state = state;
-    ring->writeAdvance(1);
-    context->mEventSem.post();
+    return 0;
 }
 
+constexpr ALuint Int64ValsByProp(ALenum prop)
+{
+    switch(static_cast<SourceProp>(prop))
+    {
+    case AL_SOURCE_STATE:
+    case AL_SOURCE_TYPE:
+    case AL_BUFFERS_QUEUED:
+    case AL_BUFFERS_PROCESSED:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SOURCE_RELATIVE:
+    case AL_LOOPING:
+    case AL_BUFFER:
+    case AL_SAMPLE_OFFSET:
+    case AL_BYTE_OFFSET:
+    case AL_DIRECT_FILTER:
+    case AL_DIRECT_FILTER_GAINHF_AUTO:
+    case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
+    case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
+    case AL_DIRECT_CHANNELS_SOFT:
+    case AL_DISTANCE_MODEL:
+    case AL_SOURCE_RESAMPLER_SOFT:
+    case AL_SOURCE_SPATIALIZE_SOFT:
+    case AL_STEREO_MODE_SOFT:
+        return 1;
+
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            return 2;
+        /*fall-through*/
+    case AL_CONE_INNER_ANGLE:
+    case AL_CONE_OUTER_ANGLE:
+    case AL_PITCH:
+    case AL_GAIN:
+    case AL_MIN_GAIN:
+    case AL_MAX_GAIN:
+    case AL_REFERENCE_DISTANCE:
+    case AL_ROLLOFF_FACTOR:
+    case AL_CONE_OUTER_GAIN:
+    case AL_MAX_DISTANCE:
+    case AL_SEC_OFFSET:
+    case AL_DOPPLER_FACTOR:
+    case AL_CONE_OUTER_GAINHF:
+    case AL_AIR_ABSORPTION_FACTOR:
+    case AL_ROOM_ROLLOFF_FACTOR:
+    case AL_SEC_LENGTH_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        return 1; /* 1x float */
 
-constexpr size_t MaxValues{6u};
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+            return 2;
+        break;
 
-ALuint FloatValsByProp(ALenum prop)
+    case AL_SAMPLE_OFFSET_LATENCY_SOFT:
+    case AL_SAMPLE_OFFSET_CLOCK_SOFT:
+    case AL_STEREO_ANGLES:
+        return 2;
+
+    case AL_AUXILIARY_SEND_FILTER:
+        return 3;
+
+    case AL_POSITION:
+    case AL_VELOCITY:
+    case AL_DIRECTION:
+        return 3; /* 3x float */
+
+    case AL_ORIENTATION:
+        return 6; /* 6x float */
+
+    case AL_SEC_OFFSET_LATENCY_SOFT:
+    case AL_SEC_OFFSET_CLOCK_SOFT:
+        break; /* double only */
+    }
+
+    return 0;
+}
+
+constexpr ALuint FloatValsByProp(ALenum prop)
 {
     switch(static_cast<SourceProp>(prop))
     {
@@ -751,11 +1162,22 @@ ALuint FloatValsByProp(ALenum prop)
     case AL_BUFFERS_QUEUED:
     case AL_BUFFERS_PROCESSED:
     case AL_SOURCE_TYPE:
-    case AL_SOURCE_RADIUS:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SEC_LENGTH_SOFT:
+    case AL_STEREO_MODE_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
         return 1;
 
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(!sBufferSubDataCompat)
+            return 1;
+        /*fall-through*/
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        break;
+
     case AL_STEREO_ANGLES:
         return 2;
 
@@ -781,7 +1203,7 @@ ALuint FloatValsByProp(ALenum prop)
     }
     return 0;
 }
-ALuint DoubleValsByProp(ALenum prop)
+constexpr ALuint DoubleValsByProp(ALenum prop)
 {
     switch(static_cast<SourceProp>(prop))
     {
@@ -813,11 +1235,22 @@ ALuint DoubleValsByProp(ALenum prop)
     case AL_BUFFERS_QUEUED:
     case AL_BUFFERS_PROCESSED:
     case AL_SOURCE_TYPE:
-    case AL_SOURCE_RADIUS:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SEC_LENGTH_SOFT:
+    case AL_STEREO_MODE_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
         return 1;
 
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(!sBufferSubDataCompat)
+            return 1;
+        /*fall-through*/
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        break;
+
     case AL_SEC_OFFSET_LATENCY_SOFT:
     case AL_SEC_OFFSET_CLOCK_SOFT:
     case AL_STEREO_ANGLES:
@@ -843,139 +1276,199 @@ ALuint DoubleValsByProp(ALenum prop)
 }
 
 
-bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALfloat> values);
-bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALint> values);
-bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALint64SOFT> values);
+void SetSourcefv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<const float> values);
+void SetSourceiv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<const int> values);
+void SetSourcei64v(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<const int64_t> values);
 
-#define CHECKSIZE(v, s) do { \
-    if LIKELY((v).size() == (s) || (v).size() == MaxValues) break;            \
-    Context->setError(AL_INVALID_ENUM,                                        \
-        "Property 0x%04x expects %d value(s), got %zu", prop, (s),            \
-        (v).size());                                                          \
-    return false;                                                             \
-} while(0)
-#define CHECKVAL(x) do {                                                      \
-    if LIKELY(x) break;                                                       \
-    Context->setError(AL_INVALID_VALUE, "Value out of range");                \
-    return false;                                                             \
-} while(0)
+struct check_exception : std::exception {
+};
+struct check_size_exception final : check_exception {
+    const char *what() const noexcept override
+    { return "check_size_exception"; }
+};
+struct check_value_exception final : check_exception {
+    const char *what() const noexcept override
+    { return "check_value_exception"; }
+};
 
-bool UpdateSourceProps(ALsource *source, ALCcontext *context)
+
+void UpdateSourceProps(ALsource *source, ALCcontext *context)
 {
-    ALvoice *voice;
-    if(SourceShouldUpdate(source, context) && (voice=GetSourceVoice(source, context)) != nullptr)
-        UpdateSourceProps(source, voice, context);
-    else
-        source->PropsClean.clear(std::memory_order_release);
-    return true;
+    if(!context->mDeferUpdates)
+    {
+        if(Voice *voice{GetSourceVoice(source, context)})
+        {
+            UpdateSourceProps(source, voice, context);
+            return;
+        }
+    }
+    source->mPropsDirty = true;
+}
+#ifdef ALSOFT_EAX
+void CommitAndUpdateSourceProps(ALsource *source, ALCcontext *context)
+{
+    if(!context->mDeferUpdates)
+    {
+        if(context->hasEax())
+            source->eaxCommit();
+        if(Voice *voice{GetSourceVoice(source, context)})
+        {
+            UpdateSourceProps(source, voice, context);
+            return;
+        }
+    }
+    source->mPropsDirty = true;
 }
 
-bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALfloat> values)
+#else
+
+inline void CommitAndUpdateSourceProps(ALsource *source, ALCcontext *context)
+{ UpdateSourceProps(source, context); }
+#endif
+
+
+/**
+ * Returns a pair of lambdas to check the following setters and getters.
+ *
+ * The first lambda checks the size of the span is valid for its given size,
+ * setting the proper context error and throwing a check_size_exception if it
+ * fails.
+ *
+ * The second lambda tests the validity of the value check, setting the proper
+ * context error and throwing a check_value_exception if it failed.
+ */
+template<typename T, size_t N>
+auto GetCheckers(ALCcontext *const Context, const SourceProp prop, const al::span<T,N> values)
 {
-    ALint ival;
+    return std::make_pair(
+        [=](size_t expect) -> void
+        {
+            if(values.size() == expect) LIKELY return;
+            Context->setError(AL_INVALID_ENUM, "Property 0x%04x expects %zu value(s), got %zu",
+                prop, expect, values.size());
+            throw check_size_exception{};
+        },
+        [Context](bool passed) -> void
+        {
+            if(passed) LIKELY return;
+            Context->setError(AL_INVALID_VALUE, "Value out of range");
+            throw check_value_exception{};
+        }
+    );
+}
+
+void SetSourcefv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<const float> values)
+try {
+    /* Structured bindings would be nice (C++17). */
+    auto Checkers = GetCheckers(Context, prop, values);
+    auto &CheckSize = Checkers.first;
+    auto &CheckValue = Checkers.second;
+    int ival;
 
     switch(prop)
     {
+    case AL_SEC_LENGTH_SOFT:
     case AL_SEC_OFFSET_LATENCY_SOFT:
     case AL_SEC_OFFSET_CLOCK_SOFT:
         /* Query only */
-        SETERR_RETURN(Context, AL_INVALID_OPERATION, false,
+        return Context->setError(AL_INVALID_OPERATION,
             "Setting read-only source property 0x%04x", prop);
 
     case AL_PITCH:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->Pitch = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_CONE_INNER_ANGLE:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 360.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 360.0f);
 
         Source->InnerAngle = values[0];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_CONE_OUTER_ANGLE:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 360.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 360.0f);
 
         Source->OuterAngle = values[0];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_GAIN:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->Gain = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_MAX_DISTANCE:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->MaxDistance = values[0];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_ROLLOFF_FACTOR:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->RolloffFactor = values[0];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_REFERENCE_DISTANCE:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->RefDistance = values[0];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_MIN_GAIN:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->MinGain = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_MAX_GAIN:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f);
 
         Source->MaxGain = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_CONE_OUTER_GAIN:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 1.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 1.0f);
 
         Source->OuterGain = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_CONE_OUTER_GAINHF:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 1.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 1.0f);
 
         Source->OuterGainHF = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_AIR_ABSORPTION_FACTOR:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 10.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 10.0f);
 
         Source->AirAbsorptionFactor = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_ROOM_ROLLOFF_FACTOR:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 10.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 10.0f);
 
         Source->RoomRolloffFactor = values[0];
         return UpdateSourceProps(Source, Context);
 
     case AL_DOPPLER_FACTOR:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && values[0] <= 1.0f);
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 1.0f);
 
         Source->DopplerFactor = values[0];
         return UpdateSourceProps(Source, Context);
@@ -983,41 +1476,43 @@ bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_SEC_OFFSET:
     case AL_SAMPLE_OFFSET:
     case AL_BYTE_OFFSET:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f);
+        CheckSize(1);
+        CheckValue(std::isfinite(values[0]));
 
-        Source->OffsetType = prop;
-        Source->Offset = values[0];
-
-        if(IsPlayingOrPaused(Source))
+        if(Voice *voice{GetSourceVoice(Source, Context)})
         {
-            ALCdevice *device{Context->mDevice.get()};
-            BackendLockGuard _{*device->Backend};
-            /* Double-check that the source is still playing while we have the
-             * lock.
-             */
-            if(ALvoice *voice{GetSourceVoice(Source, Context)})
-            {
-                auto vpos = GetSampleOffset(Source);
-                if(!vpos) SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid offset");
+            auto vpos = GetSampleOffset(Source->mQueue, prop, values[0]);
+            if(!vpos) return Context->setError(AL_INVALID_VALUE, "Invalid offset");
 
-                voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
-                voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
-                voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_release);
-            }
+            if(SetVoiceOffset(voice, *vpos, Source, Context, Context->mALDevice.get()))
+                return;
         }
-        return true;
+        Source->OffsetType = prop;
+        Source->Offset = values[0];
+        return;
+
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        break;
 
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0.0f && std::isfinite(values[0]));
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            break;
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && std::isfinite(values[0]));
 
         Source->Radius = values[0];
         return UpdateSourceProps(Source, Context);
 
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
+        CheckValue(values[0] >= 0.0f && values[0] <= 1.0f);
+
+        Source->EnhWidth = values[0];
+        return UpdateSourceProps(Source, Context);
+
     case AL_STEREO_ANGLES:
-        CHECKSIZE(values, 2);
-        CHECKVAL(std::isfinite(values[0]) && std::isfinite(values[1]));
+        CheckSize(2);
+        CheckValue(std::isfinite(values[0]) && std::isfinite(values[1]));
 
         Source->StereoPan[0] = values[0];
         Source->StereoPan[1] = values[1];
@@ -1025,35 +1520,35 @@ bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
 
 
     case AL_POSITION:
-        CHECKSIZE(values, 3);
-        CHECKVAL(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
+        CheckSize(3);
+        CheckValue(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
 
         Source->Position[0] = values[0];
         Source->Position[1] = values[1];
         Source->Position[2] = values[2];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_VELOCITY:
-        CHECKSIZE(values, 3);
-        CHECKVAL(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
+        CheckSize(3);
+        CheckValue(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
 
         Source->Velocity[0] = values[0];
         Source->Velocity[1] = values[1];
         Source->Velocity[2] = values[2];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
-        CHECKVAL(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
+        CheckSize(3);
+        CheckValue(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2]));
 
         Source->Direction[0] = values[0];
         Source->Direction[1] = values[1];
         Source->Direction[2] = values[2];
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
-        CHECKVAL(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2])
+        CheckSize(6);
+        CheckValue(std::isfinite(values[0]) && std::isfinite(values[1]) && std::isfinite(values[2])
             && std::isfinite(values[3]) && std::isfinite(values[4]) && std::isfinite(values[5]));
 
         Source->OrientAt[0] = values[0];
@@ -1076,14 +1571,17 @@ bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_DIRECT_CHANNELS_SOFT:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
-        ival = static_cast<ALint>(values[0]);
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
+        ival = static_cast<int>(values[0]);
         return SetSourceiv(Source, Context, prop, {&ival, 1u});
 
     case AL_BUFFERS_QUEUED:
     case AL_BUFFERS_PROCESSED:
-        CHECKSIZE(values, 1);
-        ival = static_cast<ALint>(static_cast<ALuint>(values[0]));
+        CheckSize(1);
+        ival = static_cast<int>(static_cast<ALuint>(values[0]));
         return SetSourceiv(Source, Context, prop, {&ival, 1u});
 
     case AL_BUFFER:
@@ -1096,20 +1594,21 @@ bool SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
 
     ERR("Unexpected property: 0x%04x\n", prop);
     Context->setError(AL_INVALID_ENUM, "Invalid source float property 0x%04x", prop);
-    return false;
+}
+catch(check_exception&) {
 }
 
-bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALint> values)
-{
-    ALCdevice *device{Context->mDevice.get()};
-    ALbuffer *buffer{nullptr};
-    ALfilter *filter{nullptr};
+void SetSourceiv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<const int> values)
+try {
+    auto Checkers = GetCheckers(Context, prop, values);
+    auto &CheckSize = Checkers.first;
+    auto &CheckValue = Checkers.second;
+    ALCdevice *device{Context->mALDevice.get()};
     ALeffectslot *slot{nullptr};
-    ALbufferlistitem *oldlist{nullptr};
+    al::deque<ALbufferQueueItem> oldlist;
     std::unique_lock<std::mutex> slotlock;
-    std::unique_lock<std::mutex> filtlock;
-    std::unique_lock<std::mutex> buflock;
-    ALfloat fvals[6];
+    float fvals[6];
 
     switch(prop)
     {
@@ -1117,210 +1616,237 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_SOURCE_TYPE:
     case AL_BUFFERS_QUEUED:
     case AL_BUFFERS_PROCESSED:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
         /* Query only */
-        SETERR_RETURN(Context, AL_INVALID_OPERATION, false,
+        return Context->setError(AL_INVALID_OPERATION,
             "Setting read-only source property 0x%04x", prop);
 
     case AL_SOURCE_RELATIVE:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
+        CheckSize(1);
+        CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
 
         Source->HeadRelative = values[0] != AL_FALSE;
-        return UpdateSourceProps(Source, Context);
+        return CommitAndUpdateSourceProps(Source, Context);
 
     case AL_LOOPING:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
+        CheckSize(1);
+        CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
 
         Source->Looping = values[0] != AL_FALSE;
-        if(IsPlayingOrPaused(Source))
+        if(Voice *voice{GetSourceVoice(Source, Context)})
         {
-            if(ALvoice *voice{GetSourceVoice(Source, Context)})
-            {
-                if(Source->Looping)
-                    voice->mLoopBuffer.store(Source->queue, std::memory_order_release);
-                else
-                    voice->mLoopBuffer.store(nullptr, std::memory_order_release);
-
-                /* If the source is playing, wait for the current mix to finish
-                 * to ensure it isn't currently looping back or reaching the
-                 * end.
-                 */
-                while((device->MixCount.load(std::memory_order_acquire)&1))
-                    std::this_thread::yield();
-            }
+            if(Source->Looping)
+                voice->mLoopBuffer.store(&Source->mQueue.front(), std::memory_order_release);
+            else
+                voice->mLoopBuffer.store(nullptr, std::memory_order_release);
+
+            /* If the source is playing, wait for the current mix to finish to
+             * ensure it isn't currently looping back or reaching the end.
+             */
+            device->waitForMix();
         }
-        return true;
+        return;
 
     case AL_BUFFER:
-        CHECKSIZE(values, 1);
-        buflock = std::unique_lock<std::mutex>{device->BufferLock};
-        if(values[0] && (buffer=LookupBuffer(device, static_cast<ALuint>(values[0]))) == nullptr)
-            SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid buffer ID %u",
-                static_cast<ALuint>(values[0]));
-
-        if(buffer && buffer->MappedAccess != 0 &&
-            !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
-            SETERR_RETURN(Context, AL_INVALID_OPERATION, false,
-                "Setting non-persistently mapped buffer %u", buffer->id);
-        else
+        CheckSize(1);
         {
-            ALenum state = GetSourceState(Source, GetSourceVoice(Source, Context));
+            const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
             if(state == AL_PLAYING || state == AL_PAUSED)
-                SETERR_RETURN(Context, AL_INVALID_OPERATION, false,
+                return Context->setError(AL_INVALID_OPERATION,
                     "Setting buffer on playing or paused source %u", Source->id);
         }
-
-        oldlist = Source->queue;
-        if(buffer != nullptr)
+        if(values[0])
         {
+            std::lock_guard<std::mutex> _{device->BufferLock};
+            ALbuffer *buffer{LookupBuffer(device, static_cast<ALuint>(values[0]))};
+            if(!buffer)
+                return Context->setError(AL_INVALID_VALUE, "Invalid buffer ID %u",
+                    static_cast<ALuint>(values[0]));
+            if(buffer->MappedAccess && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
+                return Context->setError(AL_INVALID_OPERATION,
+                    "Setting non-persistently mapped buffer %u", buffer->id);
+            if(buffer->mCallback && ReadRef(buffer->ref) != 0)
+                return Context->setError(AL_INVALID_OPERATION,
+                    "Setting already-set callback buffer %u", buffer->id);
+
             /* Add the selected buffer to a one-item queue */
-            auto newlist = new ALbufferlistitem{};
-            newlist->mSampleLen = buffer->SampleLen;
-            newlist->mBuffer = buffer;
+            al::deque<ALbufferQueueItem> newlist;
+            newlist.emplace_back();
+            newlist.back().mCallback = buffer->mCallback;
+            newlist.back().mUserData = buffer->mUserData;
+            newlist.back().mBlockAlign = buffer->mBlockAlign;
+            newlist.back().mSampleLen = buffer->mSampleLen;
+            newlist.back().mLoopStart = buffer->mLoopStart;
+            newlist.back().mLoopEnd = buffer->mLoopEnd;
+            newlist.back().mSamples = buffer->mData.data();
+            newlist.back().mBuffer = buffer;
             IncrementRef(buffer->ref);
 
             /* Source is now Static */
             Source->SourceType = AL_STATIC;
-            Source->queue = newlist;
+            Source->mQueue.swap(oldlist);
+            Source->mQueue.swap(newlist);
         }
         else
         {
             /* Source is now Undetermined */
             Source->SourceType = AL_UNDETERMINED;
-            Source->queue = nullptr;
+            Source->mQueue.swap(oldlist);
         }
-        buflock.unlock();
 
         /* Delete all elements in the previous queue */
-        while(oldlist != nullptr)
+        for(auto &item : oldlist)
         {
-            std::unique_ptr<ALbufferlistitem> temp{oldlist};
-            oldlist = temp->mNext.load(std::memory_order_relaxed);
-
-            if((buffer=temp->mBuffer) != nullptr)
+            if(ALbuffer *buffer{item.mBuffer})
                 DecrementRef(buffer->ref);
         }
-        return true;
+        return;
 
     case AL_SEC_OFFSET:
     case AL_SAMPLE_OFFSET:
     case AL_BYTE_OFFSET:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0);
+        CheckSize(1);
 
-        Source->OffsetType = prop;
-        Source->Offset = values[0];
-
-        if(IsPlayingOrPaused(Source))
+        if(Voice *voice{GetSourceVoice(Source, Context)})
         {
-            BackendLockGuard _{*device->Backend};
-            if(ALvoice *voice{GetSourceVoice(Source, Context)})
-            {
-                auto vpos = GetSampleOffset(Source);
-                if(!vpos) SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid source offset");
+            auto vpos = GetSampleOffset(Source->mQueue, prop, values[0]);
+            if(!vpos) return Context->setError(AL_INVALID_VALUE, "Invalid source offset");
 
-                voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
-                voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
-                voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_release);
-            }
+            if(SetVoiceOffset(voice, *vpos, Source, Context, device))
+                return;
         }
-        return true;
+        Source->OffsetType = prop;
+        Source->Offset = values[0];
+        return;
 
     case AL_DIRECT_FILTER:
-        CHECKSIZE(values, 1);
-        filtlock = std::unique_lock<std::mutex>{device->FilterLock};
-        if(values[0] && (filter=LookupFilter(device, static_cast<ALuint>(values[0]))) == nullptr)
-            SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid filter ID %u",
-                static_cast<ALuint>(values[0]));
-
-        if(!filter)
-        {
-            Source->Direct.Gain = 1.0f;
-            Source->Direct.GainHF = 1.0f;
-            Source->Direct.HFReference = LOWPASSFREQREF;
-            Source->Direct.GainLF = 1.0f;
-            Source->Direct.LFReference = HIGHPASSFREQREF;
-        }
-        else
+        CheckSize(1);
+        if(values[0])
         {
+            std::lock_guard<std::mutex> _{device->FilterLock};
+            ALfilter *filter{LookupFilter(device, static_cast<ALuint>(values[0]))};
+            if(!filter)
+                return Context->setError(AL_INVALID_VALUE, "Invalid filter ID %u",
+                    static_cast<ALuint>(values[0]));
             Source->Direct.Gain = filter->Gain;
             Source->Direct.GainHF = filter->GainHF;
             Source->Direct.HFReference = filter->HFReference;
             Source->Direct.GainLF = filter->GainLF;
             Source->Direct.LFReference = filter->LFReference;
         }
-        filtlock.unlock();
+        else
+        {
+            Source->Direct.Gain = 1.0f;
+            Source->Direct.GainHF = 1.0f;
+            Source->Direct.HFReference = LOWPASSFREQREF;
+            Source->Direct.GainLF = 1.0f;
+            Source->Direct.LFReference = HIGHPASSFREQREF;
+        }
         return UpdateSourceProps(Source, Context);
 
     case AL_DIRECT_FILTER_GAINHF_AUTO:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
+        CheckSize(1);
+        CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
 
         Source->DryGainHFAuto = values[0] != AL_FALSE;
         return UpdateSourceProps(Source, Context);
 
     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
+        CheckSize(1);
+        CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
 
         Source->WetGainAuto = values[0] != AL_FALSE;
         return UpdateSourceProps(Source, Context);
 
     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
+        CheckSize(1);
+        CheckValue(values[0] == AL_FALSE || values[0] == AL_TRUE);
 
         Source->WetGainHFAuto = values[0] != AL_FALSE;
         return UpdateSourceProps(Source, Context);
 
     case AL_DIRECT_CHANNELS_SOFT:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_FALSE || values[0] == AL_TRUE);
-
-        Source->DirectChannels = values[0] != AL_FALSE;
-        return UpdateSourceProps(Source, Context);
+        CheckSize(1);
+        if(auto mode = DirectModeFromEnum(values[0]))
+        {
+            Source->DirectChannels = *mode;
+            return UpdateSourceProps(Source, Context);
+        }
+        Context->setError(AL_INVALID_VALUE, "Unsupported AL_DIRECT_CHANNELS_SOFT: 0x%04x\n",
+            values[0]);
+        return;
 
     case AL_DISTANCE_MODEL:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] == AL_NONE ||
-            values[0] == AL_INVERSE_DISTANCE || values[0] == AL_INVERSE_DISTANCE_CLAMPED ||
-            values[0] == AL_LINEAR_DISTANCE || values[0] == AL_LINEAR_DISTANCE_CLAMPED ||
-            values[0] == AL_EXPONENT_DISTANCE || values[0] == AL_EXPONENT_DISTANCE_CLAMPED);
-
-        Source->mDistanceModel = static_cast<DistanceModel>(values[0]);
-        if(Context->mSourceDistanceModel)
-            return UpdateSourceProps(Source, Context);
-        return true;
+        CheckSize(1);
+        if(auto model = DistanceModelFromALenum(values[0]))
+        {
+            Source->mDistanceModel = *model;
+            if(Context->mSourceDistanceModel)
+                UpdateSourceProps(Source, Context);
+            return;
+        }
+        Context->setError(AL_INVALID_VALUE, "Distance model out of range: 0x%04x", values[0]);
+        return;
 
     case AL_SOURCE_RESAMPLER_SOFT:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= 0 && values[0] <= static_cast<int>(Resampler::Max));
+        CheckSize(1);
+        CheckValue(values[0] >= 0 && values[0] <= static_cast<int>(Resampler::Max));
 
         Source->mResampler = static_cast<Resampler>(values[0]);
         return UpdateSourceProps(Source, Context);
 
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] >= AL_FALSE && values[0] <= AL_AUTO_SOFT);
-
-        Source->mSpatialize = static_cast<SpatializeMode>(values[0]);
-        return UpdateSourceProps(Source, Context);
+        CheckSize(1);
+        if(auto mode = SpatializeModeFromEnum(values[0]))
+        {
+            Source->mSpatialize = *mode;
+            return UpdateSourceProps(Source, Context);
+        }
+        Context->setError(AL_INVALID_VALUE, "Unsupported AL_SOURCE_SPATIALIZE_SOFT: 0x%04x\n",
+            values[0]);
+        return;
 
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
+        {
+            const ALenum state{GetSourceState(Source, GetSourceVoice(Source, Context))};
+            if(state == AL_PLAYING || state == AL_PAUSED)
+                return Context->setError(AL_INVALID_OPERATION,
+                    "Modifying stereo mode on playing or paused source %u", Source->id);
+        }
+        if(auto mode = StereoModeFromEnum(values[0]))
+        {
+            Source->mStereoMode = *mode;
+            return;
+        }
+        Context->setError(AL_INVALID_VALUE, "Unsupported AL_STEREO_MODE_SOFT: 0x%04x\n",
+            values[0]);
+        return;
 
     case AL_AUXILIARY_SEND_FILTER:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         slotlock = std::unique_lock<std::mutex>{Context->mEffectSlotLock};
         if(values[0] && (slot=LookupEffectSlot(Context, static_cast<ALuint>(values[0]))) == nullptr)
-            SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid effect ID %u", values[0]);
+            return Context->setError(AL_INVALID_VALUE, "Invalid effect ID %u", values[0]);
         if(static_cast<ALuint>(values[1]) >= device->NumAuxSends)
-            SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid send %u", values[1]);
+            return Context->setError(AL_INVALID_VALUE, "Invalid send %u", values[1]);
 
-        filtlock = std::unique_lock<std::mutex>{device->FilterLock};
-        if(values[2] && (filter=LookupFilter(device, static_cast<ALuint>(values[2]))) == nullptr)
-            SETERR_RETURN(Context, AL_INVALID_VALUE, false, "Invalid filter ID %u", values[2]);
+        if(values[2])
+        {
+            std::lock_guard<std::mutex> _{device->FilterLock};
+            ALfilter *filter{LookupFilter(device, static_cast<ALuint>(values[2]))};
+            if(!filter)
+                return Context->setError(AL_INVALID_VALUE, "Invalid filter ID %u", values[2]);
 
-        if(!filter)
+            auto &send = Source->Send[static_cast<ALuint>(values[1])];
+            send.Gain = filter->Gain;
+            send.GainHF = filter->GainHF;
+            send.HFReference = filter->HFReference;
+            send.GainLF = filter->GainLF;
+            send.LFReference = filter->LFReference;
+        }
+        else
         {
             /* Disable filter */
             auto &send = Source->Send[static_cast<ALuint>(values[1])];
@@ -1330,18 +1856,14 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
             send.GainLF = 1.0f;
             send.LFReference = HIGHPASSFREQREF;
         }
-        else
-        {
-            auto &send = Source->Send[static_cast<ALuint>(values[1])];
-            send.Gain = filter->Gain;
-            send.GainHF = filter->GainHF;
-            send.HFReference = filter->HFReference;
-            send.GainLF = filter->GainLF;
-            send.LFReference = filter->LFReference;
-        }
-        filtlock.unlock();
 
-        if(slot != Source->Send[static_cast<ALuint>(values[1])].Slot && IsPlayingOrPaused(Source))
+        /* We must force an update if the current auxiliary slot is valid and
+         * about to be changed on an active source, in case the old slot is
+         * about to be deleted.
+         */
+        if(Source->Send[static_cast<ALuint>(values[1])].Slot
+            && slot != Source->Send[static_cast<ALuint>(values[1])].Slot
+            && IsPlayingOrPaused(Source))
         {
             /* Add refcount on the new slot, and release the previous slot */
             if(slot) IncrementRef(slot->ref);
@@ -1349,12 +1871,9 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
                 DecrementRef(oldslot->ref);
             Source->Send[static_cast<ALuint>(values[1])].Slot = slot;
 
-            /* We must force an update if the auxiliary slot changed on an
-             * active source, in case the slot is about to be deleted.
-             */
-            ALvoice *voice{GetSourceVoice(Source, Context)};
+            Voice *voice{GetSourceVoice(Source, Context)};
             if(voice) UpdateSourceProps(Source, voice, Context);
-            else Source->PropsClean.clear(std::memory_order_release);
+            else Source->mPropsDirty = true;
         }
         else
         {
@@ -1364,9 +1883,22 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
             Source->Send[static_cast<ALuint>(values[1])].Slot = slot;
             UpdateSourceProps(Source, Context);
         }
-        return true;
+        return;
 
 
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+            /* Query only */
+            return Context->setError(AL_INVALID_OPERATION,
+                "Setting read-only source property 0x%04x", prop);
+        break;
+
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            return Context->setError(AL_INVALID_OPERATION,
+                "Setting read-only source property 0x%04x", prop);
+        /*fall-through*/
+
     /* 1x float */
     case AL_CONE_INNER_ANGLE:
     case AL_CONE_OUTER_ANGLE:
@@ -1382,30 +1914,31 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_CONE_OUTER_GAINHF:
     case AL_AIR_ABSORPTION_FACTOR:
     case AL_ROOM_ROLLOFF_FACTOR:
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
-        fvals[0] = static_cast<ALfloat>(values[0]);
+    case AL_SEC_LENGTH_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
+        fvals[0] = static_cast<float>(values[0]);
         return SetSourcefv(Source, Context, prop, {fvals, 1u});
 
     /* 3x float */
     case AL_POSITION:
     case AL_VELOCITY:
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
-        fvals[0] = static_cast<ALfloat>(values[0]);
-        fvals[1] = static_cast<ALfloat>(values[1]);
-        fvals[2] = static_cast<ALfloat>(values[2]);
+        CheckSize(3);
+        fvals[0] = static_cast<float>(values[0]);
+        fvals[1] = static_cast<float>(values[1]);
+        fvals[2] = static_cast<float>(values[2]);
         return SetSourcefv(Source, Context, prop, {fvals, 3u});
 
     /* 6x float */
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
-        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]);
+        CheckSize(6);
+        fvals[0] = static_cast<float>(values[0]);
+        fvals[1] = static_cast<float>(values[1]);
+        fvals[2] = static_cast<float>(values[2]);
+        fvals[3] = static_cast<float>(values[3]);
+        fvals[4] = static_cast<float>(values[4]);
+        fvals[5] = static_cast<float>(values[5]);
         return SetSourcefv(Source, Context, prop, {fvals, 6u});
 
     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
@@ -1418,13 +1951,18 @@ bool SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
 
     ERR("Unexpected property: 0x%04x\n", prop);
     Context->setError(AL_INVALID_ENUM, "Invalid source integer property 0x%04x", prop);
-    return false;
+}
+catch(check_exception&) {
 }
 
-bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<const ALint64SOFT> values)
-{
-    ALfloat fvals[MaxValues];
-    ALint   ivals[MaxValues];
+void SetSourcei64v(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<const int64_t> values)
+try {
+    auto Checkers = GetCheckers(Context, prop, values);
+    auto &CheckSize = Checkers.first;
+    auto &CheckValue = Checkers.second;
+    float fvals[MaxValues];
+    int   ivals[MaxValues];
 
     switch(prop)
     {
@@ -1432,10 +1970,12 @@ bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_BUFFERS_QUEUED:
     case AL_BUFFERS_PROCESSED:
     case AL_SOURCE_STATE:
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
         /* Query only */
-        SETERR_RETURN(Context, AL_INVALID_OPERATION, false,
+        return Context->setError(AL_INVALID_OPERATION,
             "Setting read-only source property 0x%04x", prop);
 
     /* 1x int */
@@ -1451,32 +1991,48 @@ bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_DISTANCE_MODEL:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] <= INT_MAX && values[0] >= INT_MIN);
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
+        CheckValue(values[0] <= INT_MAX && values[0] >= INT_MIN);
 
-        ivals[0] = static_cast<ALint>(values[0]);
+        ivals[0] = static_cast<int>(values[0]);
         return SetSourceiv(Source, Context, prop, {ivals, 1u});
 
     /* 1x uint */
     case AL_BUFFER:
     case AL_DIRECT_FILTER:
-        CHECKSIZE(values, 1);
-        CHECKVAL(values[0] <= UINT_MAX && values[0] >= 0);
+        CheckSize(1);
+        CheckValue(values[0] <= UINT_MAX && values[0] >= 0);
 
-        ivals[0] = static_cast<ALint>(values[0]);
+        ivals[0] = static_cast<int>(values[0]);
         return SetSourceiv(Source, Context, prop, {ivals, 1u});
 
     /* 3x uint */
     case AL_AUXILIARY_SEND_FILTER:
-        CHECKSIZE(values, 3);
-        CHECKVAL(values[0] <= UINT_MAX && values[0] >= 0 && values[1] <= UINT_MAX && values[1] >= 0
-            && values[2] <= UINT_MAX && values[2] >= 0);
+        CheckSize(3);
+        CheckValue(values[0] <= UINT_MAX && values[0] >= 0 && values[1] <= UINT_MAX
+            && values[1] >= 0 && values[2] <= UINT_MAX && values[2] >= 0);
 
-        ivals[0] = static_cast<ALint>(values[0]);
-        ivals[1] = static_cast<ALint>(values[1]);
-        ivals[2] = static_cast<ALint>(values[2]);
+        ivals[0] = static_cast<int>(values[0]);
+        ivals[1] = static_cast<int>(values[1]);
+        ivals[2] = static_cast<int>(values[2]);
         return SetSourceiv(Source, Context, prop, {ivals, 3u});
 
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+        {
+            /* Query only */
+            return Context->setError(AL_INVALID_OPERATION,
+                "Setting read-only source property 0x%04x", prop);
+        }
+        break;
+
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            return Context->setError(AL_INVALID_OPERATION,
+                "Setting read-only source property 0x%04x", prop);
+        /*fall-through*/
+
     /* 1x float */
     case AL_CONE_INNER_ANGLE:
     case AL_CONE_OUTER_ANGLE:
@@ -1492,30 +2048,31 @@ bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_CONE_OUTER_GAINHF:
     case AL_AIR_ABSORPTION_FACTOR:
     case AL_ROOM_ROLLOFF_FACTOR:
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
-        fvals[0] = static_cast<ALfloat>(values[0]);
+    case AL_SEC_LENGTH_SOFT:
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
+        fvals[0] = static_cast<float>(values[0]);
         return SetSourcefv(Source, Context, prop, {fvals, 1u});
 
     /* 3x float */
     case AL_POSITION:
     case AL_VELOCITY:
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
-        fvals[0] = static_cast<ALfloat>(values[0]);
-        fvals[1] = static_cast<ALfloat>(values[1]);
-        fvals[2] = static_cast<ALfloat>(values[2]);
+        CheckSize(3);
+        fvals[0] = static_cast<float>(values[0]);
+        fvals[1] = static_cast<float>(values[1]);
+        fvals[2] = static_cast<float>(values[2]);
         return SetSourcefv(Source, Context, prop, {fvals, 3u});
 
     /* 6x float */
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
-        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]);
+        CheckSize(6);
+        fvals[0] = static_cast<float>(values[0]);
+        fvals[1] = static_cast<float>(values[1]);
+        fvals[2] = static_cast<float>(values[2]);
+        fvals[3] = static_cast<float>(values[3]);
+        fvals[4] = static_cast<float>(values[4]);
+        fvals[5] = static_cast<float>(values[5]);
         return SetSourcefv(Source, Context, prop, {fvals, 6u});
 
     case AL_SEC_OFFSET_LATENCY_SOFT:
@@ -1526,126 +2083,156 @@ bool SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
 
     ERR("Unexpected property: 0x%04x\n", prop);
     Context->setError(AL_INVALID_ENUM, "Invalid source integer64 property 0x%04x", prop);
-    return false;
+}
+catch(check_exception&) {
 }
 
-#undef CHECKVAL
 
+template<typename T, size_t N>
+auto GetSizeChecker(ALCcontext *const Context, const SourceProp prop, const al::span<T,N> values)
+{
+    return [=](size_t expect) -> void
+    {
+        if(values.size() == expect) LIKELY return;
+        Context->setError(AL_INVALID_ENUM, "Property 0x%04x expects %zu value(s), got %zu",
+            prop, expect, values.size());
+        throw check_size_exception{};
+    };
+}
 
-bool GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALdouble> values);
-bool GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALint> values);
-bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALint64SOFT> values);
+bool GetSourcedv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<double> values);
+bool GetSourceiv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<int> values);
+bool GetSourcei64v(ALsource *const Source, ALCcontext *const Context, const SourceProp prop, const al::span<int64_t> values);
 
-bool GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALdouble> values)
-{
-    ALCdevice *device{Context->mDevice.get()};
+bool GetSourcedv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<double> values)
+try {
+    auto CheckSize = GetSizeChecker(Context, prop, values);
+    ALCdevice *device{Context->mALDevice.get()};
     ClockLatency clocktime;
     nanoseconds srcclock;
-    ALint ivals[MaxValues];
+    int ivals[MaxValues];
     bool err;
 
     switch(prop)
     {
     case AL_GAIN:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->Gain;
         return true;
 
     case AL_PITCH:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->Pitch;
         return true;
 
     case AL_MAX_DISTANCE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->MaxDistance;
         return true;
 
     case AL_ROLLOFF_FACTOR:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->RolloffFactor;
         return true;
 
     case AL_REFERENCE_DISTANCE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->RefDistance;
         return true;
 
     case AL_CONE_INNER_ANGLE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->InnerAngle;
         return true;
 
     case AL_CONE_OUTER_ANGLE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->OuterAngle;
         return true;
 
     case AL_MIN_GAIN:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->MinGain;
         return true;
 
     case AL_MAX_GAIN:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->MaxGain;
         return true;
 
     case AL_CONE_OUTER_GAIN:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->OuterGain;
         return true;
 
     case AL_SEC_OFFSET:
     case AL_SAMPLE_OFFSET:
     case AL_BYTE_OFFSET:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = GetSourceOffset(Source, prop, Context);
         return true;
 
     case AL_CONE_OUTER_GAINHF:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->OuterGainHF;
         return true;
 
     case AL_AIR_ABSORPTION_FACTOR:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->AirAbsorptionFactor;
         return true;
 
     case AL_ROOM_ROLLOFF_FACTOR:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->RoomRolloffFactor;
         return true;
 
     case AL_DOPPLER_FACTOR:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->DopplerFactor;
         return true;
 
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        break;
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+            break;
+
+        CheckSize(1);
         values[0] = Source->Radius;
         return true;
 
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
+        values[0] = Source->EnhWidth;
+        return true;
+
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SEC_LENGTH_SOFT:
+        CheckSize(1);
+        values[0] = GetSourceLength(Source, prop);
+        return true;
+
     case AL_STEREO_ANGLES:
-        CHECKSIZE(values, 2);
+        CheckSize(2);
         values[0] = Source->StereoPan[0];
         values[1] = Source->StereoPan[1];
         return true;
 
     case AL_SEC_OFFSET_LATENCY_SOFT:
-        CHECKSIZE(values, 2);
+        CheckSize(2);
         /* Get the source offset with the clock time first. Then get the clock
          * time with the device latency. Order is important.
          */
         values[0] = GetSourceSecOffset(Source, Context, &srcclock);
         {
             std::lock_guard<std::mutex> _{device->StateLock};
-            clocktime = GetClockLatency(device);
+            clocktime = GetClockLatency(device, device->Backend.get());
         }
         if(srcclock == clocktime.ClockTime)
-            values[1] = static_cast<ALdouble>(clocktime.Latency.count()) / 1000000000.0;
+            values[1] = static_cast<double>(clocktime.Latency.count()) / 1000000000.0;
         else
         {
             /* If the clock time incremented, reduce the latency by that much
@@ -1653,39 +2240,39 @@ bool GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
              */
             const nanoseconds diff{clocktime.ClockTime - srcclock};
             const nanoseconds latency{clocktime.Latency - std::min(clocktime.Latency, diff)};
-            values[1] = static_cast<ALdouble>(latency.count()) / 1000000000.0;
+            values[1] = static_cast<double>(latency.count()) / 1000000000.0;
         }
         return true;
 
     case AL_SEC_OFFSET_CLOCK_SOFT:
-        CHECKSIZE(values, 2);
+        CheckSize(2);
         values[0] = GetSourceSecOffset(Source, Context, &srcclock);
-        values[1] = static_cast<ALdouble>(srcclock.count()) / 1000000000.0;
+        values[1] = static_cast<double>(srcclock.count()) / 1000000000.0;
         return true;
 
     case AL_POSITION:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         values[0] = Source->Position[0];
         values[1] = Source->Position[1];
         values[2] = Source->Position[2];
         return true;
 
     case AL_VELOCITY:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         values[0] = Source->Velocity[0];
         values[1] = Source->Velocity[1];
         values[2] = Source->Velocity[2];
         return true;
 
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         values[0] = Source->Direction[0];
         values[1] = Source->Direction[1];
         values[2] = Source->Direction[2];
         return true;
 
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
+        CheckSize(6);
         values[0] = Source->OrientAt[0];
         values[1] = Source->OrientAt[1];
         values[2] = Source->OrientAt[2];
@@ -1708,9 +2295,10 @@ bool GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_DISTANCE_MODEL:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
         if((err=GetSourceiv(Source, Context, prop, {ivals, 1u})) != false)
-            values[0] = static_cast<ALdouble>(ivals[0]);
+            values[0] = static_cast<double>(ivals[0]);
         return err;
 
     case AL_BUFFER:
@@ -1725,57 +2313,65 @@ bool GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     Context->setError(AL_INVALID_ENUM, "Invalid source double property 0x%04x", prop);
     return false;
 }
+catch(check_exception&) {
+    return false;
+}
 
-bool GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALint> values)
-{
-    ALdouble dvals[MaxValues];
+bool GetSourceiv(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<int> values)
+try {
+    auto CheckSize = GetSizeChecker(Context, prop, values);
+    double dvals[MaxValues];
     bool err;
 
     switch(prop)
     {
     case AL_SOURCE_RELATIVE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->HeadRelative;
         return true;
 
     case AL_LOOPING:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->Looping;
         return true;
 
     case AL_BUFFER:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         {
-            ALbufferlistitem *BufferList{nullptr};
-            if(Source->SourceType == AL_STATIC) BufferList = Source->queue;
-            ALbuffer *buffer{nullptr};
-            if(BufferList) buffer = BufferList->mBuffer;
-            values[0] = buffer ? static_cast<ALint>(buffer->id) : 0;
+            ALbufferQueueItem *BufferList{};
+            /* HACK: This query should technically only return the buffer set
+             * on a static source. However, some apps had used it to detect
+             * when a streaming source changed buffers, so report the current
+             * buffer's ID when playing.
+             */
+            if(Source->SourceType == AL_STATIC || Source->state == AL_INITIAL)
+            {
+                if(!Source->mQueue.empty())
+                    BufferList = &Source->mQueue.front();
+            }
+            else if(Voice *voice{GetSourceVoice(Source, Context)})
+            {
+                VoiceBufferItem *Current{voice->mCurrentBuffer.load(std::memory_order_relaxed)};
+                BufferList = static_cast<ALbufferQueueItem*>(Current);
+            }
+            ALbuffer *buffer{BufferList ? BufferList->mBuffer : nullptr};
+            values[0] = buffer ? static_cast<int>(buffer->id) : 0;
         }
         return true;
 
     case AL_SOURCE_STATE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = GetSourceState(Source, GetSourceVoice(Source, Context));
         return true;
 
     case AL_BUFFERS_QUEUED:
-        CHECKSIZE(values, 1);
-        if(ALbufferlistitem *BufferList{Source->queue})
-        {
-            ALsizei count{0};
-            do {
-                ++count;
-                BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-            } while(BufferList != nullptr);
-            values[0] = count;
-        }
-        else
-            values[0] = 0;
+        CheckSize(1);
+        values[0] = static_cast<int>(Source->mQueue.size());
         return true;
 
     case AL_BUFFERS_PROCESSED:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         if(Source->Looping || Source->SourceType != AL_STREAMING)
         {
             /* Buffers on a looping source are in a perpetual state of PENDING,
@@ -1785,65 +2381,105 @@ bool GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
         }
         else
         {
-            const ALbufferlistitem *BufferList{Source->queue};
-            const ALbufferlistitem *Current{nullptr};
-            ALsizei played{0};
-
-            ALvoice *voice{GetSourceVoice(Source, Context)};
-            if(voice != nullptr)
-                Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
-            else if(Source->state == AL_INITIAL)
-                Current = BufferList;
-
-            while(BufferList && BufferList != Current)
+            int played{0};
+            if(Source->state != AL_INITIAL)
             {
-                ++played;
-                BufferList = BufferList->mNext.load(std::memory_order_relaxed);
+                const VoiceBufferItem *Current{nullptr};
+                if(Voice *voice{GetSourceVoice(Source, Context)})
+                    Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
+                for(auto &item : Source->mQueue)
+                {
+                    if(&item == Current)
+                        break;
+                    ++played;
+                }
             }
             values[0] = played;
         }
         return true;
 
     case AL_SOURCE_TYPE:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->SourceType;
         return true;
 
     case AL_DIRECT_FILTER_GAINHF_AUTO:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->DryGainHFAuto;
         return true;
 
     case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->WetGainAuto;
         return true;
 
     case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = Source->WetGainHFAuto;
         return true;
 
     case AL_DIRECT_CHANNELS_SOFT:
-        CHECKSIZE(values, 1);
-        values[0] = Source->DirectChannels;
+        CheckSize(1);
+        values[0] = EnumFromDirectMode(Source->DirectChannels);
         return true;
 
     case AL_DISTANCE_MODEL:
-        CHECKSIZE(values, 1);
-        values[0] = static_cast<int>(Source->mDistanceModel);
+        CheckSize(1);
+        values[0] = ALenumFromDistanceModel(Source->mDistanceModel);
+        return true;
+
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SEC_LENGTH_SOFT:
+        CheckSize(1);
+        values[0] = static_cast<int>(mind(GetSourceLength(Source, prop),
+            std::numeric_limits<int>::max()));
         return true;
 
     case AL_SOURCE_RESAMPLER_SOFT:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         values[0] = static_cast<int>(Source->mResampler);
         return true;
 
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
-        values[0] = Source->mSpatialize;
+        CheckSize(1);
+        values[0] = EnumFromSpatializeMode(Source->mSpatialize);
         return true;
 
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
+        values[0] = EnumFromStereoMode(Source->mStereoMode);
+        return true;
+
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+        {
+            CheckSize(2);
+            const auto offset = GetSourceOffset(Source, AL_SAMPLE_OFFSET, Context);
+            /* FIXME: values[1] should be ahead of values[0] by the device
+             * update time. It needs to clamp or wrap the length of the buffer
+             * queue.
+             */
+            values[0] = static_cast<int>(mind(offset, std::numeric_limits<int>::max()));
+            values[1] = values[0];
+            return true;
+        }
+        break;
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+        {
+            CheckSize(2);
+            const auto offset = GetSourceOffset(Source, AL_BYTE_OFFSET, Context);
+            /* FIXME: values[1] should be ahead of values[0] by the device
+             * update time. It needs to clamp or wrap the length of the buffer
+             * queue.
+             */
+            values[0] = static_cast<int>(mind(offset, std::numeric_limits<int>::max()));
+            values[1] = values[0];
+            return true;
+        }
+        /*fall-through*/
+
     /* 1x float/double */
     case AL_CONE_INNER_ANGLE:
     case AL_CONE_OUTER_ANGLE:
@@ -1862,36 +2498,36 @@ bool GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     case AL_AIR_ABSORPTION_FACTOR:
     case AL_ROOM_ROLLOFF_FACTOR:
     case AL_CONE_OUTER_GAINHF:
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 1u})) != false)
-            values[0] = static_cast<ALint>(dvals[0]);
+            values[0] = static_cast<int>(dvals[0]);
         return err;
 
     /* 3x float/double */
     case AL_POSITION:
     case AL_VELOCITY:
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 3u})) != false)
         {
-            values[0] = static_cast<ALint>(dvals[0]);
-            values[1] = static_cast<ALint>(dvals[1]);
-            values[2] = static_cast<ALint>(dvals[2]);
+            values[0] = static_cast<int>(dvals[0]);
+            values[1] = static_cast<int>(dvals[1]);
+            values[2] = static_cast<int>(dvals[2]);
         }
         return err;
 
     /* 6x float/double */
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
+        CheckSize(6);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 6u})) != false)
         {
-            values[0] = static_cast<ALint>(dvals[0]);
-            values[1] = static_cast<ALint>(dvals[1]);
-            values[2] = static_cast<ALint>(dvals[2]);
-            values[3] = static_cast<ALint>(dvals[3]);
-            values[4] = static_cast<ALint>(dvals[4]);
-            values[5] = static_cast<ALint>(dvals[5]);
+            values[0] = static_cast<int>(dvals[0]);
+            values[1] = static_cast<int>(dvals[1]);
+            values[2] = static_cast<int>(dvals[2]);
+            values[3] = static_cast<int>(dvals[3]);
+            values[4] = static_cast<int>(dvals[4]);
+            values[5] = static_cast<int>(dvals[5]);
         }
         return err;
 
@@ -1913,27 +2549,39 @@ bool GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, const a
     Context->setError(AL_INVALID_ENUM, "Invalid source integer property 0x%04x", prop);
     return false;
 }
+catch(check_exception&) {
+    return false;
+}
 
-bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const al::span<ALint64SOFT> values)
-{
-    ALCdevice *device = Context->mDevice.get();
+bool GetSourcei64v(ALsource *const Source, ALCcontext *const Context, const SourceProp prop,
+    const al::span<int64_t> values)
+try {
+    auto CheckSize = GetSizeChecker(Context, prop, values);
+    ALCdevice *device{Context->mALDevice.get()};
     ClockLatency clocktime;
     nanoseconds srcclock;
-    ALdouble dvals[MaxValues];
-    ALint ivals[MaxValues];
+    double dvals[MaxValues];
+    int ivals[MaxValues];
     bool err;
 
     switch(prop)
     {
+    case AL_BYTE_LENGTH_SOFT:
+    case AL_SAMPLE_LENGTH_SOFT:
+    case AL_SEC_LENGTH_SOFT:
+        CheckSize(1);
+        values[0] = static_cast<int64_t>(GetSourceLength(Source, prop));
+        return true;
+
     case AL_SAMPLE_OFFSET_LATENCY_SOFT:
-        CHECKSIZE(values, 2);
+        CheckSize(2);
         /* Get the source offset with the clock time first. Then get the clock
          * time with the device latency. Order is important.
          */
         values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
         {
             std::lock_guard<std::mutex> _{device->StateLock};
-            clocktime = GetClockLatency(device);
+            clocktime = GetClockLatency(device, device->Backend.get());
         }
         if(srcclock == clocktime.ClockTime)
             values[1] = clocktime.Latency.count();
@@ -1948,11 +2596,38 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
         return true;
 
     case AL_SAMPLE_OFFSET_CLOCK_SOFT:
-        CHECKSIZE(values, 2);
+        CheckSize(2);
         values[0] = GetSourceSampleOffset(Source, Context, &srcclock);
         values[1] = srcclock.count();
         return true;
 
+    case AL_SAMPLE_RW_OFFSETS_SOFT:
+        if(sBufferSubDataCompat)
+        {
+            CheckSize(2);
+            /* FIXME: values[1] should be ahead of values[0] by the device
+             * update time. It needs to clamp or wrap the length of the buffer
+             * queue.
+             */
+            values[0] = static_cast<int64_t>(GetSourceOffset(Source, AL_SAMPLE_OFFSET, Context));
+            values[1] = values[0];
+            return true;
+        }
+        break;
+    case AL_SOURCE_RADIUS: /*AL_BYTE_RW_OFFSETS_SOFT:*/
+        if(sBufferSubDataCompat)
+        {
+            CheckSize(2);
+            /* FIXME: values[1] should be ahead of values[0] by the device
+             * update time. It needs to clamp or wrap the length of the buffer
+             * queue.
+             */
+            values[0] = static_cast<int64_t>(GetSourceOffset(Source, AL_BYTE_OFFSET, Context));
+            values[1] = values[0];
+            return true;
+        }
+        /*fall-through*/
+
     /* 1x float/double */
     case AL_CONE_INNER_ANGLE:
     case AL_CONE_OUTER_ANGLE:
@@ -1971,8 +2646,8 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_AIR_ABSORPTION_FACTOR:
     case AL_ROOM_ROLLOFF_FACTOR:
     case AL_CONE_OUTER_GAINHF:
-    case AL_SOURCE_RADIUS:
-        CHECKSIZE(values, 1);
+    case AL_SUPER_STEREO_WIDTH_SOFT:
+        CheckSize(1);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 1u})) != false)
             values[0] = static_cast<int64_t>(dvals[0]);
         return err;
@@ -1981,7 +2656,7 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_POSITION:
     case AL_VELOCITY:
     case AL_DIRECTION:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 3u})) != false)
         {
             values[0] = static_cast<int64_t>(dvals[0]);
@@ -1992,7 +2667,7 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
 
     /* 6x float/double */
     case AL_ORIENTATION:
-        CHECKSIZE(values, 6);
+        CheckSize(6);
         if((err=GetSourcedv(Source, Context, prop, {dvals, 6u})) != false)
         {
             values[0] = static_cast<int64_t>(dvals[0]);
@@ -2018,7 +2693,8 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     case AL_DISTANCE_MODEL:
     case AL_SOURCE_RESAMPLER_SOFT:
     case AL_SOURCE_SPATIALIZE_SOFT:
-        CHECKSIZE(values, 1);
+    case AL_STEREO_MODE_SOFT:
+        CheckSize(1);
         if((err=GetSourceiv(Source, Context, prop, {ivals, 1u})) != false)
             values[0] = ivals[0];
         return err;
@@ -2026,14 +2702,14 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     /* 1x uint */
     case AL_BUFFER:
     case AL_DIRECT_FILTER:
-        CHECKSIZE(values, 1);
+        CheckSize(1);
         if((err=GetSourceiv(Source, Context, prop, {ivals, 1u})) != false)
             values[0] = static_cast<ALuint>(ivals[0]);
         return err;
 
     /* 3x uint */
     case AL_AUXILIARY_SEND_FILTER:
-        CHECKSIZE(values, 3);
+        CheckSize(3);
         if((err=GetSourceiv(Source, Context, prop, {ivals, 3u})) != false)
         {
             values[0] = static_cast<ALuint>(ivals[0]);
@@ -2053,21 +2729,194 @@ bool GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop, const
     Context->setError(AL_INVALID_ENUM, "Invalid source integer64 property 0x%04x", prop);
     return false;
 }
+catch(check_exception&) {
+    return false;
+}
+
+
+void StartSources(ALCcontext *const context, const al::span<ALsource*> srchandles,
+    const nanoseconds start_time=nanoseconds::min())
+{
+    ALCdevice *device{context->mALDevice.get()};
+    /* If the device is disconnected, and voices stop on disconnect, go right
+     * to stopped.
+     */
+    if(!device->Connected.load(std::memory_order_acquire)) UNLIKELY
+    {
+        if(context->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
+        {
+            for(ALsource *source : srchandles)
+            {
+                /* TODO: Send state change event? */
+                source->Offset = 0.0;
+                source->OffsetType = AL_NONE;
+                source->state = AL_STOPPED;
+            }
+            return;
+        }
+    }
+
+    /* Count the number of reusable voices. */
+    auto voicelist = context->getVoicesSpan();
+    size_t free_voices{0};
+    for(const Voice *voice : voicelist)
+    {
+        free_voices += (voice->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
+            && voice->mSourceID.load(std::memory_order_relaxed) == 0u
+            && voice->mPendingChange.load(std::memory_order_relaxed) == false);
+        if(free_voices == srchandles.size())
+            break;
+    }
+    if(srchandles.size() != free_voices) UNLIKELY
+    {
+        const size_t inc_amount{srchandles.size() - free_voices};
+        auto &allvoices = *context->mVoices.load(std::memory_order_relaxed);
+        if(inc_amount > allvoices.size() - voicelist.size())
+        {
+            /* Increase the number of voices to handle the request. */
+            context->allocVoices(inc_amount - (allvoices.size() - voicelist.size()));
+        }
+        context->mActiveVoiceCount.fetch_add(inc_amount, std::memory_order_release);
+        voicelist = context->getVoicesSpan();
+    }
+
+    auto voiceiter = voicelist.begin();
+    ALuint vidx{0};
+    VoiceChange *tail{}, *cur{};
+    for(ALsource *source : srchandles)
+    {
+        /* Check that there is a queue containing at least one valid, non zero
+         * length buffer.
+         */
+        auto find_buffer = [](ALbufferQueueItem &entry) noexcept
+        { return entry.mSampleLen != 0 || entry.mCallback != nullptr; };
+        auto BufferList = std::find_if(source->mQueue.begin(), source->mQueue.end(), find_buffer);
+
+        /* If there's nothing to play, go right to stopped. */
+        if(BufferList == source->mQueue.end()) UNLIKELY
+        {
+            /* NOTE: A source without any playable buffers should not have a
+             * Voice since it shouldn't be in a playing or paused state. So
+             * there's no need to look up its voice and clear the source.
+             */
+            source->Offset = 0.0;
+            source->OffsetType = AL_NONE;
+            source->state = AL_STOPPED;
+            continue;
+        }
+
+        if(!cur)
+            cur = tail = GetVoiceChanger(context);
+        else
+        {
+            cur->mNext.store(GetVoiceChanger(context), std::memory_order_relaxed);
+            cur = cur->mNext.load(std::memory_order_relaxed);
+        }
+
+        Voice *voice{GetSourceVoice(source, context)};
+        switch(GetSourceState(source, voice))
+        {
+        case AL_PAUSED:
+            /* A source that's paused simply resumes. If there's no voice, it
+             * was lost from a disconnect, so just start over with a new one.
+             */
+            cur->mOldVoice = nullptr;
+            if(!voice) break;
+            cur->mVoice = voice;
+            cur->mSourceID = source->id;
+            cur->mState = VChangeState::Play;
+            source->state = AL_PLAYING;
+#ifdef ALSOFT_EAX
+            if(context->hasEax())
+                source->eaxCommit();
+#endif // ALSOFT_EAX
+            continue;
+
+        case AL_PLAYING:
+            /* A source that's already playing is restarted from the beginning.
+             * Stop the current voice and start a new one so it properly cross-
+             * fades back to the beginning.
+             */
+            if(voice)
+                voice->mPendingChange.store(true, std::memory_order_relaxed);
+            cur->mOldVoice = voice;
+            voice = nullptr;
+            break;
+
+        default:
+            assert(voice == nullptr);
+            cur->mOldVoice = nullptr;
+#ifdef ALSOFT_EAX
+            if(context->hasEax())
+                source->eaxCommit();
+#endif // ALSOFT_EAX
+            break;
+        }
+
+        /* Find the next unused voice to play this source with. */
+        for(;voiceiter != voicelist.end();++voiceiter,++vidx)
+        {
+            Voice *v{*voiceiter};
+            if(v->mPlayState.load(std::memory_order_acquire) == Voice::Stopped
+                && v->mSourceID.load(std::memory_order_relaxed) == 0u
+                && v->mPendingChange.load(std::memory_order_relaxed) == false)
+            {
+                voice = v;
+                break;
+            }
+        }
+        ASSUME(voice != nullptr);
+
+        voice->mPosition.store(0, std::memory_order_relaxed);
+        voice->mPositionFrac.store(0, std::memory_order_relaxed);
+        voice->mCurrentBuffer.store(&source->mQueue.front(), std::memory_order_relaxed);
+        voice->mStartTime = start_time;
+        voice->mFlags.reset();
+        /* A source that's not playing or paused has any offset applied when it
+         * starts playing.
+         */
+        if(const ALenum offsettype{source->OffsetType})
+        {
+            const double offset{source->Offset};
+            source->OffsetType = AL_NONE;
+            source->Offset = 0.0;
+            if(auto vpos = GetSampleOffset(source->mQueue, offsettype, offset))
+            {
+                voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
+                voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
+                voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_relaxed);
+                if(vpos->pos > 0 || (vpos->pos == 0 && vpos->frac > 0)
+                    || vpos->bufferitem != &source->mQueue.front())
+                    voice->mFlags.set(VoiceIsFading);
+            }
+        }
+        InitVoice(voice, source, al::to_address(BufferList), context, device);
+
+        source->VoiceIdx = vidx;
+        source->state = AL_PLAYING;
+
+        cur->mVoice = voice;
+        cur->mSourceID = source->id;
+        cur->mState = VChangeState::Play;
+    }
+    if(tail) LIKELY
+        SendVoiceChanges(context, tail);
+}
 
 } // namespace
 
-AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n, ALuint *sources)
+AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Generating %d sources", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     std::unique_lock<std::mutex> srclock{context->mSourceLock};
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     if(static_cast<ALuint>(n) > device->SourcesMax-context->mNumSources)
     {
         context->setError(AL_OUT_OF_MEMORY, "Exceeding %u source limit (%u + %d)",
@@ -2082,31 +2931,39 @@ START_API_FUNC
 
     if(n == 1)
     {
-        ALsource *source{AllocSource(context.get(), device->NumAuxSends)};
+        ALsource *source{AllocSource(context.get())};
         sources[0] = source->id;
+
+#ifdef ALSOFT_EAX
+        source->eaxInitialize(context.get());
+#endif // ALSOFT_EAX
     }
     else
     {
-        const ALuint num_sends{device->NumAuxSends};
         al::vector<ALuint> ids;
         ids.reserve(static_cast<ALuint>(n));
         do {
-            ALsource *source{AllocSource(context.get(), num_sends)};
+            ALsource *source{AllocSource(context.get())};
             ids.emplace_back(source->id);
+
+#ifdef ALSOFT_EAX
+            source->eaxInitialize(context.get());
+#endif // ALSOFT_EAX
         } while(--n);
         std::copy(ids.cbegin(), ids.cend(), sources);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
+AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
-        SETERR_RETURN(context, AL_INVALID_VALUE,, "Deleting %d sources", n);
+    if(n < 0) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "Deleting %d sources", n);
+    if(n <= 0) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
 
@@ -2116,11 +2973,8 @@ START_API_FUNC
 
     const ALuint *sources_end = sources + n;
     auto invsrc = std::find_if_not(sources, sources_end, validate_source);
-    if UNLIKELY(invsrc != sources_end)
-    {
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", *invsrc);
-        return;
-    }
+    if(invsrc != sources_end) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *invsrc);
 
     /* All good. Delete source IDs. */
     auto delete_source = [&context](const ALuint sid) -> void
@@ -2136,7 +2990,7 @@ AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if LIKELY(context)
+    if(context) LIKELY
     {
         std::lock_guard<std::mutex> _{context->mSourceLock};
         if(LookupSource(context.get(), source) != nullptr)
@@ -2147,134 +3001,132 @@ START_API_FUNC
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value)
+AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), {&value, 1u});
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
     {
-        const ALfloat fvals[3]{ value1, value2, value3 };
+        const float fvals[3]{ value1, value2, value3 };
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), fvals);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values)
+AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{FloatValsByProp(param)};
+    SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value)
+AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
     {
-        const ALfloat fval[1]{static_cast<ALfloat>(value)};
+        const float fval[1]{static_cast<float>(value)};
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), fval);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3)
+AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
     {
-        const ALfloat fvals[3]{static_cast<ALfloat>(value1), static_cast<ALfloat>(value2),
-            static_cast<ALfloat>(value3)};
+        const float fvals[3]{static_cast<float>(value1), static_cast<float>(value2),
+            static_cast<float>(value3)};
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), fvals);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values)
+AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-    {
-        const ALuint count{DoubleValsByProp(param)};
-        ALfloat fvals[MaxValues];
-        for(ALuint i{0};i < count;i++)
-            fvals[i] = static_cast<ALfloat>(values[i]);
-        SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), {fvals, count});
-    }
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{DoubleValsByProp(param)};
+    float fvals[MaxValues];
+    std::copy_n(values, count, fvals);
+    SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), {fvals, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value)
+AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
         SetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {&value, 1u});
@@ -2285,16 +3137,16 @@ AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, AL
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
     {
-        const ALint ivals[3]{ value1, value2, value3 };
+        const int ivals[3]{ value1, value2, value3 };
         SetSourceiv(Source, context.get(), static_cast<SourceProp>(param), ivals);
     }
 }
@@ -2304,31 +3156,32 @@ AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *val
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source = LookupSource(context.get(), source);
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        SetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{IntValsByProp(param)};
+    SetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value)
+AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
         SetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {&value, 1u});
@@ -2339,16 +3192,16 @@ AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOF
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
     else
     {
-        const ALint64SOFT i64vals[3]{ value1, value2, value3 };
+        const int64_t i64vals[3]{ value1, value2, value3 };
         SetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), i64vals);
     }
 }
@@ -2358,89 +3211,85 @@ AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALin
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     std::lock_guard<std::mutex> __{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        SetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{Int64ValsByProp(param)};
+    SetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value)
+AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
     {
-        ALdouble dval[1];
+        double dval[1];
         if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), dval))
-            *value = static_cast<ALfloat>(dval[0]);
+            *value = static_cast<float>(dval[0]);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
+AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!(value1 && value2 && value3))
+    else if(!(value1 && value2 && value3)) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
     {
-        ALdouble dvals[3];
+        double dvals[3];
         if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), dvals))
         {
-            *value1 = static_cast<ALfloat>(dvals[0]);
-            *value2 = static_cast<ALfloat>(dvals[1]);
-            *value3 = static_cast<ALfloat>(dvals[2]);
+            *value1 = static_cast<float>(dvals[0]);
+            *value2 = static_cast<float>(dvals[1]);
+            *value3 = static_cast<float>(dvals[2]);
         }
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values)
+AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-    {
-        const ALuint count{FloatValsByProp(param)};
-        ALdouble dvals[MaxValues];
-        if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), {dvals, count}))
-        {
-            for(ALuint i{0};i < count;i++)
-                values[i] = static_cast<ALfloat>(dvals[i]);
-        }
-    }
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{FloatValsByProp(param)};
+    double dvals[MaxValues];
+    if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), {dvals, count}))
+        std::copy_n(dvals, count, values);
 }
 END_API_FUNC
 
@@ -2449,13 +3298,13 @@ AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
         GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), {value, 1u});
@@ -2466,17 +3315,17 @@ AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!(value1 && value2 && value3))
+    else if(!(value1 && value2 && value3)) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
     {
-        ALdouble dvals[3];
+        double dvals[3];
         if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), dvals))
         {
             *value1 = dvals[0];
@@ -2491,31 +3340,32 @@ AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{DoubleValsByProp(param)};
+    GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value)
+AL_API void AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
         GetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {value, 1u});
@@ -2526,17 +3376,17 @@ AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!(value1 && value2 && value3))
+    else if(!(value1 && value2 && value3)) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
     {
-        ALint ivals[3];
+        int ivals[3];
         if(GetSourceiv(Source, context.get(), static_cast<SourceProp>(param), ivals))
         {
             *value1 = ivals[0];
@@ -2551,16 +3401,17 @@ AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        GetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{IntValsByProp(param)};
+    GetSourceiv(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
@@ -2569,13 +3420,13 @@ AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64S
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!value)
+    else if(!value) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
         GetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {value, 1u});
@@ -2586,17 +3437,17 @@ AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
+    if(!Source) UNLIKELY
         context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!(value1 && value2 && value3))
+    else if(!(value1 && value2 && value3)) UNLIKELY
         context->setError(AL_INVALID_VALUE, "NULL pointer");
     else
     {
-        ALint64SOFT i64vals[3];
+        int64_t i64vals[3];
         if(GetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), i64vals))
         {
             *value1 = i64vals[0];
@@ -2611,39 +3462,68 @@ AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *Source{LookupSource(context.get(), source)};
-    if UNLIKELY(!Source)
-        context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
-    else if UNLIKELY(!values)
-        context->setError(AL_INVALID_VALUE, "NULL pointer");
-    else
-        GetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {values, MaxValues});
+    if(!Source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+    if(!values) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "NULL pointer");
+
+    const ALuint count{Int64ValsByProp(param)};
+    GetSourcei64v(Source, context.get(), static_cast<SourceProp>(param), {values, count});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)
+AL_API void AL_APIENTRY alSourcePlay(ALuint source)
 START_API_FUNC
-{ alSourcePlayv(1, &source); }
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    std::lock_guard<std::mutex> _{context->mSourceLock};
+    ALsource *srchandle{LookupSource(context.get(), source)};
+    if(!srchandle)
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+
+    StartSources(context.get(), {&srchandle, 1});
+}
+END_API_FUNC
+
+void AL_APIENTRY alSourcePlayAtTimeSOFT(ALuint source, ALint64SOFT start_time)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    if(start_time < 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time);
+
+    std::lock_guard<std::mutex> _{context->mSourceLock};
+    ALsource *srchandle{LookupSource(context.get(), source)};
+    if(!srchandle)
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", source);
+
+    StartSources(context.get(), {&srchandle, 1}, nanoseconds{start_time});
+}
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
+AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Playing %d sources", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     al::vector<ALsource*> extra_sources;
     std::array<ALsource*,8> source_storage;
     al::span<ALsource*> srchandles;
-    if LIKELY(static_cast<ALuint>(n) <= source_storage.size())
+    if(static_cast<ALuint>(n) <= source_storage.size()) LIKELY
         srchandles = {source_storage.data(), static_cast<ALuint>(n)};
     else
     {
@@ -2655,245 +3535,72 @@ START_API_FUNC
     for(auto &srchdl : srchandles)
     {
         srchdl = LookupSource(context.get(), *sources);
-        if(!srchdl)
-            SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", *sources);
+        if(!srchdl) UNLIKELY
+            return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *sources);
         ++sources;
     }
 
-    ALCdevice *device{context->mDevice.get()};
-    BackendLockGuard __{*device->Backend};
-    /* If the device is disconnected, go right to stopped. */
-    if UNLIKELY(!device->Connected.load(std::memory_order_acquire))
-    {
-        /* TODO: Send state change event? */
-        std::for_each(srchandles.begin(), srchandles.end(),
-            [](ALsource *source) -> void
-            {
-                source->OffsetType = AL_NONE;
-                source->Offset = 0.0;
-                source->state = AL_STOPPED;
-            }
-        );
-        return;
-    }
-
-    /* Count the number of reusable voices. */
-    auto count_free_voices = [](const ALuint count, const ALvoice &voice) noexcept -> ALuint
-    {
-        if(voice.mPlayState.load(std::memory_order_acquire) == ALvoice::Stopped
-            && voice.mSourceID.load(std::memory_order_relaxed) == 0u)
-            return count + 1;
-        return count;
-    };
-    auto free_voices = std::accumulate(context->mVoices.begin(), context->mVoices.end(),
-        ALuint{0}, count_free_voices);
-    if UNLIKELY(srchandles.size() > free_voices)
-    {
-        /* Increase the number of voices to handle the request. */
-        const size_t need_voices{srchandles.size() - free_voices};
-        context->mVoices.resize(context->mVoices.size() + need_voices);
-    }
-
-    auto start_source = [&context,device](ALsource *source) -> void
-    {
-        /* Check that there is a queue containing at least one valid, non zero
-         * length buffer.
-         */
-        ALbufferlistitem *BufferList{source->queue};
-        while(BufferList && BufferList->mSampleLen == 0)
-            BufferList = BufferList->mNext.load(std::memory_order_relaxed);
-
-        /* If there's nothing to play, go right to stopped. */
-        if UNLIKELY(!BufferList)
-        {
-            /* NOTE: A source without any playable buffers should not have an
-             * ALvoice since it shouldn't be in a playing or paused state. So
-             * there's no need to look up its voice and clear the source.
-             */
-            ALenum oldstate{GetSourceState(source, nullptr)};
-            source->OffsetType = AL_NONE;
-            source->Offset = 0.0;
-            if(oldstate != AL_STOPPED)
-            {
-                source->state = AL_STOPPED;
-                SendStateChangeEvent(context.get(), source->id, AL_STOPPED);
-            }
-            return;
-        }
-
-        ALvoice *voice{GetSourceVoice(source, context.get())};
-        switch(GetSourceState(source, voice))
-        {
-        case AL_PAUSED:
-            assert(voice != nullptr);
-            /* A source that's paused simply resumes. */
-            voice->mPlayState.store(ALvoice::Playing, std::memory_order_release);
-            source->state = AL_PLAYING;
-            SendStateChangeEvent(context.get(), source->id, AL_PLAYING);
-            return;
-
-        case AL_PLAYING:
-            assert(voice != nullptr);
-            /* A source that's already playing is restarted from the beginning.
-             * Stop the current voice and start a new one so it properly cross-
-             * fades back to the beginning.
-             */
-            voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mSourceID.store(0u, std::memory_order_release);
-            voice->mPlayState.store(ALvoice::Stopping, std::memory_order_release);
-            voice = nullptr;
-            break;
-
-        default:
-            assert(voice == nullptr);
-            break;
-        }
-
-        /* Look for an unused voice to play this source with. */
-        auto find_voice = [](const ALvoice &v) noexcept -> bool
-        {
-            return v.mPlayState.load(std::memory_order_acquire) == ALvoice::Stopped
-                && v.mSourceID.load(std::memory_order_relaxed) == 0u;
-        };
-        auto voices_end = context->mVoices.data() + context->mVoices.size();
-        voice = std::find_if(context->mVoices.data(), voices_end, find_voice);
-        assert(voice != voices_end);
-
-        auto vidx = static_cast<ALuint>(std::distance(context->mVoices.data(), voice));
-        voice->mPlayState.store(ALvoice::Stopped, std::memory_order_release);
-
-        source->PropsClean.test_and_set(std::memory_order_acquire);
-        UpdateSourceProps(source, voice, context.get());
-
-        /* A source that's not playing or paused has any offset applied when it
-         * starts playing.
-         */
-        if(source->Looping)
-            voice->mLoopBuffer.store(source->queue, std::memory_order_relaxed);
-        else
-            voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-        voice->mCurrentBuffer.store(BufferList, std::memory_order_relaxed);
-        voice->mPosition.store(0u, std::memory_order_relaxed);
-        voice->mPositionFrac.store(0, std::memory_order_relaxed);
-        bool start_fading{false};
-        if(auto vpos = GetSampleOffset(source))
-        {
-            start_fading = vpos->pos != 0 || vpos->frac != 0 || vpos->bufferitem != BufferList;
-            voice->mPosition.store(vpos->pos, std::memory_order_relaxed);
-            voice->mPositionFrac.store(vpos->frac, std::memory_order_relaxed);
-            voice->mCurrentBuffer.store(vpos->bufferitem, std::memory_order_relaxed);
-        }
-
-        ALbuffer *buffer{BufferList->mBuffer};
-        voice->mFrequency = buffer->Frequency;
-        voice->mFmtChannels = buffer->mFmtChannels;
-        voice->mNumChannels = ChannelsFromFmt(buffer->mFmtChannels);
-        voice->mSampleSize  = BytesFromFmt(buffer->mFmtType);
-
-        /* Clear the stepping value so the mixer knows not to mix this until
-         * the update gets applied.
-         */
-        voice->mStep = 0;
-
-        voice->mFlags = start_fading ? VOICE_IS_FADING : 0;
-        if(source->SourceType == AL_STATIC) voice->mFlags |= VOICE_IS_STATIC;
-
-        /* Don't need to set the VOICE_IS_AMBISONIC flag if the device is
-         * mixing in first order. No HF scaling is necessary to mix it.
-         */
-        if((voice->mFmtChannels == FmtBFormat2D || voice->mFmtChannels == FmtBFormat3D)
-            && device->mAmbiOrder > 1)
-        {
-            const ALuint *OrderFromChan;
-            if(voice->mFmtChannels == FmtBFormat2D)
-            {
-                static const ALuint Order2DFromChan[MAX_AMBI2D_CHANNELS]{
-                    0, 1,1, 2,2, 3,3,};
-                OrderFromChan = Order2DFromChan;
-            }
-            else
-            {
-                static const ALuint Order3DFromChan[MAX_AMBI_CHANNELS]{
-                    0, 1,1,1, 2,2,2,2,2, 3,3,3,3,3,3,3,};
-                OrderFromChan = Order3DFromChan;
-            }
-
-            BandSplitter splitter{400.0f / static_cast<float>(device->Frequency)};
+    StartSources(context.get(), srchandles);
+}
+END_API_FUNC
 
-            const auto scales = BFormatDec::GetHFOrderScales(1, device->mAmbiOrder);
-            auto init_ambi = [scales,&OrderFromChan,&splitter](ALvoice::ChannelData &chandata) -> void
-            {
-                chandata.mPrevSamples.fill(0.0f);
-                chandata.mAmbiScale = scales[*(OrderFromChan++)];
-                chandata.mAmbiSplitter = splitter;
-            };
-            std::for_each(voice->mChans.begin(), voice->mChans.begin()+voice->mNumChannels,
-                init_ambi);
+void AL_APIENTRY alSourcePlayAtTimevSOFT(ALsizei n, const ALuint *sources, ALint64SOFT start_time)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
 
-            voice->mFlags |= VOICE_IS_AMBISONIC;
-        }
-        else
-        {
-            /* Clear previous samples. */
-            auto clear_prevs = [](ALvoice::ChannelData &chandata) -> void
-            { chandata.mPrevSamples.fill(0.0f); };
-            std::for_each(voice->mChans.begin(), voice->mChans.begin()+voice->mNumChannels,
-                clear_prevs);
-        }
+    if(n < 0) UNLIKELY
+        context->setError(AL_INVALID_VALUE, "Playing %d sources", n);
+    if(n <= 0) UNLIKELY return;
 
-        auto clear_params = [device](ALvoice::ChannelData &chandata) -> void
-        {
-            chandata.mDryParams = DirectParams{};
-            std::fill_n(chandata.mWetParams.begin(), device->NumAuxSends, SendParams{});
-        };
-        std::for_each(voice->mChans.begin(), voice->mChans.begin()+voice->mNumChannels,
-            clear_params);
+    if(start_time < 0) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Invalid time point %" PRId64, start_time);
 
-        if(device->AvgSpeakerDist > 0.0f)
-        {
-            const ALfloat w1{SPEEDOFSOUNDMETRESPERSEC /
-                (device->AvgSpeakerDist * static_cast<float>(device->Frequency))};
-            auto init_nfc = [w1](ALvoice::ChannelData &chandata) -> void
-            { chandata.mDryParams.NFCtrlFilter.init(w1); };
-            std::for_each(voice->mChans.begin(), voice->mChans.begin()+voice->mNumChannels,
-                init_nfc);
-        }
+    al::vector<ALsource*> extra_sources;
+    std::array<ALsource*,8> source_storage;
+    al::span<ALsource*> srchandles;
+    if(static_cast<ALuint>(n) <= source_storage.size()) LIKELY
+        srchandles = {source_storage.data(), static_cast<ALuint>(n)};
+    else
+    {
+        extra_sources.resize(static_cast<ALuint>(n));
+        srchandles = {extra_sources.data(), extra_sources.size()};
+    }
 
-        voice->mSourceID.store(source->id, std::memory_order_relaxed);
-        voice->mPlayState.store(ALvoice::Playing, std::memory_order_release);
-        source->VoiceIdx = vidx;
+    std::lock_guard<std::mutex> _{context->mSourceLock};
+    for(auto &srchdl : srchandles)
+    {
+        srchdl = LookupSource(context.get(), *sources);
+        if(!srchdl)
+            return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *sources);
+        ++sources;
+    }
 
-        if(source->state != AL_PLAYING)
-        {
-            source->state = AL_PLAYING;
-            SendStateChangeEvent(context.get(), source->id, AL_PLAYING);
-        }
-    };
-    std::for_each(srchandles.begin(), srchandles.end(), start_source);
+    StartSources(context.get(), srchandles, nanoseconds{start_time});
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)
+AL_API void AL_APIENTRY alSourcePause(ALuint source)
 START_API_FUNC
 { alSourcePausev(1, &source); }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
+AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Pausing %d sources", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     al::vector<ALsource*> extra_sources;
     std::array<ALsource*,8> source_storage;
     al::span<ALsource*> srchandles;
-    if LIKELY(static_cast<ALuint>(n) <= source_storage.size())
+    if(static_cast<ALuint>(n) <= source_storage.size()) LIKELY
         srchandles = {source_storage.data(), static_cast<ALuint>(n)};
     else
     {
@@ -2906,52 +3613,70 @@ START_API_FUNC
     {
         srchdl = LookupSource(context.get(), *sources);
         if(!srchdl)
-            SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", *sources);
+            return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *sources);
         ++sources;
     }
 
-    ALCdevice *device{context->mDevice.get()};
-    BackendLockGuard __{*device->Backend};
-    auto pause_source = [&context](ALsource *source) -> void
+    /* Pausing has to be done in two steps. First, for each source that's
+     * detected to be playing, chamge the voice (asynchronously) to
+     * stopping/paused.
+     */
+    VoiceChange *tail{}, *cur{};
+    for(ALsource *source : srchandles)
     {
-        ALvoice *voice{GetSourceVoice(source, context.get())};
-        if(voice)
+        Voice *voice{GetSourceVoice(source, context.get())};
+        if(GetSourceState(source, voice) == AL_PLAYING)
         {
-            std::atomic_thread_fence(std::memory_order_release);
-            ALvoice::State oldvstate{ALvoice::Playing};
-            voice->mPlayState.compare_exchange_strong(oldvstate, ALvoice::Stopping,
-                std::memory_order_acq_rel, std::memory_order_acquire);
+            if(!cur)
+                cur = tail = GetVoiceChanger(context.get());
+            else
+            {
+                cur->mNext.store(GetVoiceChanger(context.get()), std::memory_order_relaxed);
+                cur = cur->mNext.load(std::memory_order_relaxed);
+            }
+            cur->mVoice = voice;
+            cur->mSourceID = source->id;
+            cur->mState = VChangeState::Pause;
         }
-        if(GetSourceState(source, voice) == AL_PLAYING)
+    }
+    if(tail) LIKELY
+    {
+        SendVoiceChanges(context.get(), tail);
+        /* Second, now that the voice changes have been sent, because it's
+         * possible that the voice stopped after it was detected playing and
+         * before the voice got paused, recheck that the source is still
+         * considered playing and set it to paused if so.
+         */
+        for(ALsource *source : srchandles)
         {
-            source->state = AL_PAUSED;
-            SendStateChangeEvent(context.get(), source->id, AL_PAUSED);
+            Voice *voice{GetSourceVoice(source, context.get())};
+            if(GetSourceState(source, voice) == AL_PLAYING)
+                source->state = AL_PAUSED;
         }
-    };
-    std::for_each(srchandles.begin(), srchandles.end(), pause_source);
+    }
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)
+AL_API void AL_APIENTRY alSourceStop(ALuint source)
 START_API_FUNC
 { alSourceStopv(1, &source); }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
+AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Stopping %d sources", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     al::vector<ALsource*> extra_sources;
     std::array<ALsource*,8> source_storage;
     al::span<ALsource*> srchandles;
-    if LIKELY(static_cast<ALuint>(n) <= source_storage.size())
+    if(static_cast<ALuint>(n) <= source_storage.size()) LIKELY
         srchandles = {source_storage.data(), static_cast<ALuint>(n)};
     else
     {
@@ -2964,62 +3689,57 @@ START_API_FUNC
     {
         srchdl = LookupSource(context.get(), *sources);
         if(!srchdl)
-            SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", *sources);
+            return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *sources);
         ++sources;
     }
 
-    ALCdevice *device{context->mDevice.get()};
-    BackendLockGuard __{*device->Backend};
-    auto stop_source = [&context](ALsource *source) -> void
+    VoiceChange *tail{}, *cur{};
+    for(ALsource *source : srchandles)
     {
-        /* Get the source state before clearing from the voice, so we know what
-         * state the source+voice was actually in.
-         */
-        ALvoice *voice{GetSourceVoice(source, context.get())};
-        const ALenum oldstate{GetSourceState(source, voice)};
-        if(voice != nullptr)
-        {
-            voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mSourceID.store(0u, std::memory_order_relaxed);
-            std::atomic_thread_fence(std::memory_order_release);
-            ALvoice::State oldvstate{ALvoice::Playing};
-            voice->mPlayState.compare_exchange_strong(oldvstate, ALvoice::Stopping,
-                std::memory_order_acq_rel, std::memory_order_acquire);
-            voice = nullptr;
-        }
-        if(oldstate != AL_INITIAL && oldstate != AL_STOPPED)
+        if(Voice *voice{GetSourceVoice(source, context.get())})
         {
+            if(!cur)
+                cur = tail = GetVoiceChanger(context.get());
+            else
+            {
+                cur->mNext.store(GetVoiceChanger(context.get()), std::memory_order_relaxed);
+                cur = cur->mNext.load(std::memory_order_relaxed);
+            }
+            voice->mPendingChange.store(true, std::memory_order_relaxed);
+            cur->mVoice = voice;
+            cur->mSourceID = source->id;
+            cur->mState = VChangeState::Stop;
             source->state = AL_STOPPED;
-            SendStateChangeEvent(context.get(), source->id, AL_STOPPED);
         }
-        source->OffsetType = AL_NONE;
         source->Offset = 0.0;
-    };
-    std::for_each(srchandles.begin(), srchandles.end(), stop_source);
+        source->OffsetType = AL_NONE;
+        source->VoiceIdx = INVALID_VOICE_IDX;
+    }
+    if(tail) LIKELY
+        SendVoiceChanges(context.get(), tail);
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)
+AL_API void AL_APIENTRY alSourceRewind(ALuint source)
 START_API_FUNC
 { alSourceRewindv(1, &source); }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
+AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(n < 0)
+    if(n < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Rewinding %d sources", n);
-    if UNLIKELY(n <= 0) return;
+    if(n <= 0) UNLIKELY return;
 
     al::vector<ALsource*> extra_sources;
     std::array<ALsource*,8> source_storage;
     al::span<ALsource*> srchandles;
-    if LIKELY(static_cast<ALuint>(n) <= source_storage.size())
+    if(static_cast<ALuint>(n) <= source_storage.size()) LIKELY
         srchandles = {source_storage.data(), static_cast<ALuint>(n)};
     else
     {
@@ -3032,122 +3752,151 @@ START_API_FUNC
     {
         srchdl = LookupSource(context.get(), *sources);
         if(!srchdl)
-            SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", *sources);
+            return context->setError(AL_INVALID_NAME, "Invalid source ID %u", *sources);
         ++sources;
     }
 
-    ALCdevice *device{context->mDevice.get()};
-    BackendLockGuard __{*device->Backend};
-    auto rewind_source = [&context](ALsource *source) -> void
+    VoiceChange *tail{}, *cur{};
+    for(ALsource *source : srchandles)
     {
-        ALvoice *voice{GetSourceVoice(source, context.get())};
-        if(voice != nullptr)
-        {
-            voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-            voice->mSourceID.store(0u, std::memory_order_relaxed);
-            std::atomic_thread_fence(std::memory_order_release);
-            ALvoice::State oldvstate{ALvoice::Playing};
-            voice->mPlayState.compare_exchange_strong(oldvstate, ALvoice::Stopping,
-                std::memory_order_acq_rel, std::memory_order_acquire);
-            voice = nullptr;
-        }
+        Voice *voice{GetSourceVoice(source, context.get())};
         if(source->state != AL_INITIAL)
         {
+            if(!cur)
+                cur = tail = GetVoiceChanger(context.get());
+            else
+            {
+                cur->mNext.store(GetVoiceChanger(context.get()), std::memory_order_relaxed);
+                cur = cur->mNext.load(std::memory_order_relaxed);
+            }
+            if(voice)
+                voice->mPendingChange.store(true, std::memory_order_relaxed);
+            cur->mVoice = voice;
+            cur->mSourceID = source->id;
+            cur->mState = VChangeState::Reset;
             source->state = AL_INITIAL;
-            SendStateChangeEvent(context.get(), source->id, AL_INITIAL);
         }
-        source->OffsetType = AL_NONE;
         source->Offset = 0.0;
-    };
-    std::for_each(srchandles.begin(), srchandles.end(), rewind_source);
+        source->OffsetType = AL_NONE;
+        source->VoiceIdx = INVALID_VOICE_IDX;
+    }
+    if(tail) LIKELY
+        SendVoiceChanges(context.get(), tail);
 }
 END_API_FUNC
 
 
-AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALuint *buffers)
+AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALuint *buffers)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(nb < 0)
+    if(nb < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Queueing %d buffers", nb);
-    if UNLIKELY(nb <= 0) return;
+    if(nb <= 0) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *source{LookupSource(context.get(),src)};
-    if UNLIKELY(!source)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", src);
+    if(!source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", src);
 
     /* Can't queue on a Static Source */
-    if UNLIKELY(source->SourceType == AL_STATIC)
-        SETERR_RETURN(context, AL_INVALID_OPERATION,, "Queueing onto static source %u", src);
+    if(source->SourceType == AL_STATIC) UNLIKELY
+        return context->setError(AL_INVALID_OPERATION, "Queueing onto static source %u", src);
 
     /* Check for a valid Buffer, for its frequency and format */
-    ALCdevice *device{context->mDevice.get()};
+    ALCdevice *device{context->mALDevice.get()};
     ALbuffer *BufferFmt{nullptr};
-    ALbufferlistitem *BufferList{source->queue};
-    while(BufferList && !BufferFmt)
+    for(auto &item : source->mQueue)
     {
-        BufferFmt = BufferList->mBuffer;
-        BufferList = BufferList->mNext.load(std::memory_order_relaxed);
+        BufferFmt = item.mBuffer;
+        if(BufferFmt) break;
     }
 
     std::unique_lock<std::mutex> buflock{device->BufferLock};
-    ALbufferlistitem *BufferListStart{nullptr};
-    BufferList = nullptr;
+    const size_t NewListStart{source->mQueue.size()};
+    ALbufferQueueItem *BufferList{nullptr};
     for(ALsizei i{0};i < nb;i++)
     {
+        bool fmt_mismatch{false};
         ALbuffer *buffer{nullptr};
         if(buffers[i] && (buffer=LookupBuffer(device, buffers[i])) == nullptr)
         {
             context->setError(AL_INVALID_NAME, "Queueing invalid buffer ID %u", buffers[i]);
             goto buffer_error;
         }
-
-        if(!BufferListStart)
+        if(buffer)
         {
-            BufferListStart = new ALbufferlistitem{};
-            BufferList = BufferListStart;
+            if(buffer->mSampleRate < 1)
+            {
+                context->setError(AL_INVALID_OPERATION, "Queueing buffer %u with no format",
+                    buffer->id);
+                goto buffer_error;
+            }
+            if(buffer->mCallback)
+            {
+                context->setError(AL_INVALID_OPERATION, "Queueing callback buffer %u", buffer->id);
+                goto buffer_error;
+            }
+            if(buffer->MappedAccess != 0 && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
+            {
+                context->setError(AL_INVALID_OPERATION,
+                    "Queueing non-persistently mapped buffer %u", buffer->id);
+                goto buffer_error;
+            }
         }
+
+        source->mQueue.emplace_back();
+        if(!BufferList)
+            BufferList = &source->mQueue.back();
         else
         {
-            auto item = new ALbufferlistitem{};
-            BufferList->mNext.store(item, std::memory_order_relaxed);
-            BufferList = item;
+            auto &item = source->mQueue.back();
+            BufferList->mNext.store(&item, std::memory_order_relaxed);
+            BufferList = &item;
         }
-        BufferList->mNext.store(nullptr, std::memory_order_relaxed);
-        BufferList->mSampleLen = buffer ? buffer->SampleLen : 0;
-        BufferList->mBuffer = buffer;
         if(!buffer) continue;
-
+        BufferList->mBlockAlign = buffer->mBlockAlign;
+        BufferList->mSampleLen = buffer->mSampleLen;
+        BufferList->mLoopEnd = buffer->mSampleLen;
+        BufferList->mSamples = buffer->mData.data();
+        BufferList->mBuffer = buffer;
         IncrementRef(buffer->ref);
 
-        if(buffer->MappedAccess != 0 && !(buffer->MappedAccess&AL_MAP_PERSISTENT_BIT_SOFT))
-        {
-            context->setError(AL_INVALID_OPERATION, "Queueing non-persistently mapped buffer %u",
-                buffer->id);
-            goto buffer_error;
-        }
-
         if(BufferFmt == nullptr)
             BufferFmt = buffer;
-        else if(BufferFmt->Frequency != buffer->Frequency ||
-                BufferFmt->mFmtChannels != buffer->mFmtChannels ||
-                BufferFmt->OriginalType != buffer->OriginalType)
+        else
+        {
+            fmt_mismatch |= BufferFmt->mSampleRate != buffer->mSampleRate;
+            fmt_mismatch |= BufferFmt->mChannels != buffer->mChannels;
+            fmt_mismatch |= BufferFmt->mType != buffer->mType;
+            if(BufferFmt->isBFormat())
+            {
+                fmt_mismatch |= BufferFmt->mAmbiLayout != buffer->mAmbiLayout;
+                fmt_mismatch |= BufferFmt->mAmbiScaling != buffer->mAmbiScaling;
+            }
+            fmt_mismatch |= BufferFmt->mAmbiOrder != buffer->mAmbiOrder;
+        }
+        if(fmt_mismatch) UNLIKELY
         {
-            context->setError(AL_INVALID_OPERATION, "Queueing buffer with mismatched format");
+            context->setError(AL_INVALID_OPERATION, "Queueing buffer with mismatched format\n"
+                "  Expected: %uhz, %s, %s ; Got: %uhz, %s, %s\n", BufferFmt->mSampleRate,
+                NameFromFormat(BufferFmt->mType), NameFromFormat(BufferFmt->mChannels),
+                buffer->mSampleRate, NameFromFormat(buffer->mType),
+                NameFromFormat(buffer->mChannels));
 
         buffer_error:
             /* A buffer failed (invalid ID or format), so unlock and release
-             * each buffer we had. */
-            while(BufferListStart)
+             * each buffer we had.
+             */
+            auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
+            for(;iter != source->mQueue.end();++iter)
             {
-                std::unique_ptr<ALbufferlistitem> head{BufferListStart};
-                BufferListStart = head->mNext.load(std::memory_order_relaxed);
-                if((buffer=head->mBuffer) != nullptr) DecrementRef(buffer->ref);
+                if(ALbuffer *buf{iter->mBuffer})
+                    DecrementRef(buf->ref);
             }
+            source->mQueue.resize(NewListStart);
             return;
         }
     }
@@ -3157,134 +3906,86 @@ START_API_FUNC
     /* Source is now streaming */
     source->SourceType = AL_STREAMING;
 
-    BufferList = source->queue;
-    if(!BufferList)
-        source->queue = BufferListStart;
-    else
+    if(NewListStart != 0)
     {
-        ALbufferlistitem *next;
-        while((next=BufferList->mNext.load(std::memory_order_relaxed)) != nullptr)
-            BufferList = next;
-        BufferList->mNext.store(BufferListStart, std::memory_order_release);
+        auto iter = source->mQueue.begin() + ptrdiff_t(NewListStart);
+        (iter-1)->mNext.store(al::to_address(iter), std::memory_order_release);
     }
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint *buffers)
+AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint *buffers)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if UNLIKELY(nb < 0)
+    if(nb < 0) UNLIKELY
         context->setError(AL_INVALID_VALUE, "Unqueueing %d buffers", nb);
-    if UNLIKELY(nb <= 0) return;
+    if(nb <= 0) UNLIKELY return;
 
     std::lock_guard<std::mutex> _{context->mSourceLock};
     ALsource *source{LookupSource(context.get(),src)};
-    if UNLIKELY(!source)
-        SETERR_RETURN(context, AL_INVALID_NAME,, "Invalid source ID %u", src);
+    if(!source) UNLIKELY
+        return context->setError(AL_INVALID_NAME, "Invalid source ID %u", src);
 
-    if UNLIKELY(source->Looping)
-        SETERR_RETURN(context, AL_INVALID_VALUE,, "Unqueueing from looping source %u", src);
-    if UNLIKELY(source->SourceType != AL_STREAMING)
-        SETERR_RETURN(context, AL_INVALID_VALUE,, "Unqueueing from a non-streaming source %u",
+    if(source->SourceType != AL_STREAMING) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Unqueueing from a non-streaming source %u",
             src);
+    if(source->Looping) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Unqueueing from looping source %u", src);
 
     /* Make sure enough buffers have been processed to unqueue. */
-    ALbufferlistitem *BufferList{source->queue};
-    ALvoice *voice{GetSourceVoice(source, context.get())};
-    ALbufferlistitem *Current{nullptr};
-    if(voice)
-        Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
-    else if(source->state == AL_INITIAL)
-        Current = BufferList;
-    if UNLIKELY(BufferList == Current)
-        SETERR_RETURN(context, AL_INVALID_VALUE,, "Unqueueing pending buffers");
-
-    ALuint i{1u};
-    while(i < static_cast<ALuint>(nb))
-    {
-        /* If the next bufferlist to check is NULL or is the current one, it's
-         * trying to unqueue pending buffers.
-         */
-        ALbufferlistitem *next{BufferList->mNext.load(std::memory_order_relaxed)};
-        if UNLIKELY(!next || next == Current)
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "Unqueueing pending buffers");
-        BufferList = next;
-
-        ++i;
+    uint processed{0u};
+    if(source->state != AL_INITIAL) LIKELY
+    {
+        VoiceBufferItem *Current{nullptr};
+        if(Voice *voice{GetSourceVoice(source, context.get())})
+            Current = voice->mCurrentBuffer.load(std::memory_order_relaxed);
+        for(auto &item : source->mQueue)
+        {
+            if(&item == Current)
+                break;
+            ++processed;
+        }
     }
+    if(processed < static_cast<ALuint>(nb)) UNLIKELY
+        return context->setError(AL_INVALID_VALUE, "Unqueueing %d buffer%s (only %u processed)",
+            nb, (nb==1)?"":"s", processed);
 
     do {
-        std::unique_ptr<ALbufferlistitem> head{source->queue};
-        source->queue = head->mNext.load(std::memory_order_relaxed);
-
-        if(ALbuffer *buffer{head->mBuffer})
+        auto &head = source->mQueue.front();
+        if(ALbuffer *buffer{head.mBuffer})
         {
             *(buffers++) = buffer->id;
             DecrementRef(buffer->ref);
         }
         else
             *(buffers++) = 0;
+        source->mQueue.pop_front();
     } while(--nb);
 }
 END_API_FUNC
 
 
-ALsource::ALsource(ALuint num_sends)
-{
-    InnerAngle = 360.0f;
-    OuterAngle = 360.0f;
-    Pitch = 1.0f;
-    Position[0] = 0.0f;
-    Position[1] = 0.0f;
-    Position[2] = 0.0f;
-    Velocity[0] = 0.0f;
-    Velocity[1] = 0.0f;
-    Velocity[2] = 0.0f;
-    Direction[0] = 0.0f;
-    Direction[1] = 0.0f;
-    Direction[2] = 0.0f;
-    OrientAt[0] =  0.0f;
-    OrientAt[1] =  0.0f;
-    OrientAt[2] = -1.0f;
-    OrientUp[0] =  0.0f;
-    OrientUp[1] =  1.0f;
-    OrientUp[2] =  0.0f;
-    RefDistance = 1.0f;
-    MaxDistance = std::numeric_limits<float>::max();
-    RolloffFactor = 1.0f;
-    Gain = 1.0f;
-    MinGain = 0.0f;
-    MaxGain = 1.0f;
-    OuterGain = 0.0f;
-    OuterGainHF = 1.0f;
-
-    DryGainHFAuto = AL_TRUE;
-    WetGainAuto = AL_TRUE;
-    WetGainHFAuto = AL_TRUE;
-    AirAbsorptionFactor = 0.0f;
-    RoomRolloffFactor = 0.0f;
-    DopplerFactor = 1.0f;
-    HeadRelative = AL_FALSE;
-    Looping = AL_FALSE;
-    mDistanceModel = DistanceModel::Default;
-    mResampler = ResamplerDefault;
-    DirectChannels = AL_FALSE;
-    mSpatialize = SpatializeAuto;
-
-    StereoPan[0] = Deg2Rad( 30.0f);
-    StereoPan[1] = Deg2Rad(-30.0f);
-
-    Radius = 0.0f;
+AL_API void AL_APIENTRY alSourceQueueBufferLayersSOFT(ALuint, ALsizei, const ALuint*)
+START_API_FUNC
+{
+    ContextRef context{GetContextRef()};
+    if(!context) UNLIKELY return;
+
+    context->setError(AL_INVALID_OPERATION, "alSourceQueueBufferLayersSOFT not supported");
+}
+END_API_FUNC
+
 
+ALsource::ALsource()
+{
     Direct.Gain = 1.0f;
     Direct.GainHF = 1.0f;
     Direct.HFReference = LOWPASSFREQREF;
     Direct.GainLF = 1.0f;
     Direct.LFReference = HIGHPASSFREQREF;
-    Send.resize(num_sends);
     for(auto &send : Send)
     {
         send.Slot = nullptr;
@@ -3294,43 +3995,37 @@ ALsource::ALsource(ALuint num_sends)
         send.GainLF = 1.0f;
         send.LFReference = HIGHPASSFREQREF;
     }
-
-    PropsClean.test_and_set(std::memory_order_relaxed);
 }
 
 ALsource::~ALsource()
 {
-    ALbufferlistitem *BufferList{queue};
-    while(BufferList != nullptr)
+    for(auto &item : mQueue)
     {
-        std::unique_ptr<ALbufferlistitem> head{BufferList};
-        BufferList = head->mNext.load(std::memory_order_relaxed);
-        if(ALbuffer *buffer{head->mBuffer}) DecrementRef(buffer->ref);
+        if(ALbuffer *buffer{item.mBuffer})
+            DecrementRef(buffer->ref);
     }
-    queue = nullptr;
 
-    std::for_each(Send.begin(), Send.end(),
-        [](ALsource::SendData &send) -> void
-        {
-            if(send.Slot)
-                DecrementRef(send.Slot->ref);
-            send.Slot = nullptr;
-        }
-    );
+    auto clear_send = [](ALsource::SendData &send) -> void
+    { if(send.Slot) DecrementRef(send.Slot->ref); };
+    std::for_each(Send.begin(), Send.end(), clear_send);
 }
 
 void UpdateAllSourceProps(ALCcontext *context)
 {
     std::lock_guard<std::mutex> _{context->mSourceLock};
-    std::for_each(context->mVoices.begin(), context->mVoices.end(),
-        [context](ALvoice &voice) -> void
+    auto voicelist = context->getVoicesSpan();
+    ALuint vidx{0u};
+    for(Voice *voice : voicelist)
+    {
+        ALuint sid{voice->mSourceID.load(std::memory_order_acquire)};
+        ALsource *source = sid ? LookupSource(context, sid) : nullptr;
+        if(source && source->VoiceIdx == vidx)
         {
-            ALuint sid{voice.mSourceID.load(std::memory_order_acquire)};
-            ALsource *source = sid ? LookupSource(context, sid) : nullptr;
-            if(source && !source->PropsClean.test_and_set(std::memory_order_acq_rel))
-                UpdateSourceProps(source, &voice, context);
+            if(std::exchange(source->mPropsDirty, false))
+                UpdateSourceProps(source, voice, context);
         }
-    );
+        ++vidx;
+    }
 }
 
 SourceSubList::~SourceSubList()
@@ -3338,11 +4033,1312 @@ SourceSubList::~SourceSubList()
     uint64_t usemask{~FreeMask};
     while(usemask)
     {
-        ALsizei idx{CTZ64(usemask)};
-        al::destroy_at(Sources+idx);
+        const int idx{al::countr_zero(usemask)};
         usemask &= ~(1_u64 << idx);
+        al::destroy_at(Sources+idx);
     }
     FreeMask = ~usemask;
     al_free(Sources);
     Sources = nullptr;
 }
+
+
+#ifdef ALSOFT_EAX
+constexpr const ALsource::EaxFxSlotIds ALsource::eax4_fx_slot_ids;
+constexpr const ALsource::EaxFxSlotIds ALsource::eax5_fx_slot_ids;
+
+void ALsource::eaxInitialize(ALCcontext *context) noexcept
+{
+    assert(context != nullptr);
+    mEaxAlContext = context;
+
+    mEaxPrimaryFxSlotId = context->eaxGetPrimaryFxSlotIndex();
+    eax_set_defaults();
+
+    eax1_translate(mEax1.i, mEax);
+    mEaxVersion = 1;
+    mEaxChanged = true;
+}
+
+void ALsource::eaxDispatch(const EaxCall& call)
+{
+    call.is_get() ? eax_get(call) : eax_set(call);
+}
+
+ALsource* ALsource::EaxLookupSource(ALCcontext& al_context, ALuint source_id) noexcept
+{
+    return LookupSource(&al_context, source_id);
+}
+
+[[noreturn]] void ALsource::eax_fail(const char* message)
+{
+    throw Exception{message};
+}
+
+[[noreturn]] void ALsource::eax_fail_unknown_property_id()
+{
+    eax_fail("Unknown property id.");
+}
+
+[[noreturn]] void ALsource::eax_fail_unknown_version()
+{
+    eax_fail("Unknown version.");
+}
+
+[[noreturn]] void ALsource::eax_fail_unknown_active_fx_slot_id()
+{
+    eax_fail("Unknown active FX slot ID.");
+}
+
+[[noreturn]] void ALsource::eax_fail_unknown_receiving_fx_slot_id()
+{
+    eax_fail("Unknown receiving FX slot ID.");
+}
+
+void ALsource::eax_set_sends_defaults(EaxSends& sends, const EaxFxSlotIds& ids) noexcept
+{
+    for (auto i = size_t{}; i < EAX_MAX_FXSLOTS; ++i) {
+        auto& send = sends[i];
+        send.guidReceivingFXSlotID = *(ids[i]);
+        send.lSend = EAXSOURCE_DEFAULTSEND;
+        send.lSendHF = EAXSOURCE_DEFAULTSENDHF;
+        send.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
+        send.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
+        send.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
+        send.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+        send.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
+        send.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
+    }
+}
+
+void ALsource::eax1_set_defaults(Eax1Props& props) noexcept
+{
+    props.fMix = EAX_REVERBMIX_USEDISTANCE;
+}
+
+void ALsource::eax1_set_defaults() noexcept
+{
+    eax1_set_defaults(mEax1.i);
+    mEax1.d = mEax1.i;
+}
+
+void ALsource::eax2_set_defaults(Eax2Props& props) noexcept
+{
+    props.lDirect = EAXSOURCE_DEFAULTDIRECT;
+    props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
+    props.lRoom = EAXSOURCE_DEFAULTROOM;
+    props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
+    props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
+    props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
+    props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
+    props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
+    props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
+    props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
+    props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
+    props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
+    props.dwFlags = EAXSOURCE_DEFAULTFLAGS;
+}
+
+void ALsource::eax2_set_defaults() noexcept
+{
+    eax2_set_defaults(mEax2.i);
+    mEax2.d = mEax2.i;
+}
+
+void ALsource::eax3_set_defaults(Eax3Props& props) noexcept
+{
+    props.lDirect = EAXSOURCE_DEFAULTDIRECT;
+    props.lDirectHF = EAXSOURCE_DEFAULTDIRECTHF;
+    props.lRoom = EAXSOURCE_DEFAULTROOM;
+    props.lRoomHF = EAXSOURCE_DEFAULTROOMHF;
+    props.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
+    props.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
+    props.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
+    props.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
+    props.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
+    props.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+    props.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
+    props.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
+    props.lOutsideVolumeHF = EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF;
+    props.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
+    props.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
+    props.flRoomRolloffFactor = EAXSOURCE_DEFAULTROOMROLLOFFFACTOR;
+    props.flAirAbsorptionFactor = EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR;
+    props.ulFlags = EAXSOURCE_DEFAULTFLAGS;
+}
+
+void ALsource::eax3_set_defaults() noexcept
+{
+    eax3_set_defaults(mEax3.i);
+    mEax3.d = mEax3.i;
+}
+
+void ALsource::eax4_set_sends_defaults(EaxSends& sends) noexcept
+{
+    eax_set_sends_defaults(sends, eax4_fx_slot_ids);
+}
+
+void ALsource::eax4_set_active_fx_slots_defaults(EAX40ACTIVEFXSLOTS& slots) noexcept
+{
+    slots = EAX40SOURCE_DEFAULTACTIVEFXSLOTID;
+}
+
+void ALsource::eax4_set_defaults() noexcept
+{
+    eax3_set_defaults(mEax4.i.source);
+    eax4_set_sends_defaults(mEax4.i.sends);
+    eax4_set_active_fx_slots_defaults(mEax4.i.active_fx_slots);
+    mEax4.d = mEax4.i;
+}
+
+void ALsource::eax5_set_source_defaults(EAX50SOURCEPROPERTIES& props) noexcept
+{
+    eax3_set_defaults(static_cast<Eax3Props&>(props));
+    props.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
+}
+
+void ALsource::eax5_set_sends_defaults(EaxSends& sends) noexcept
+{
+    eax_set_sends_defaults(sends, eax5_fx_slot_ids);
+}
+
+void ALsource::eax5_set_active_fx_slots_defaults(EAX50ACTIVEFXSLOTS& slots) noexcept
+{
+    slots = EAX50SOURCE_3DDEFAULTACTIVEFXSLOTID;
+}
+
+void ALsource::eax5_set_speaker_levels_defaults(EaxSpeakerLevels& speaker_levels) noexcept
+{
+    for (auto i = size_t{}; i < eax_max_speakers; ++i) {
+        auto& speaker_level = speaker_levels[i];
+        speaker_level.lSpeakerID = static_cast<long>(EAXSPEAKER_FRONT_LEFT + i);
+        speaker_level.lLevel = EAXSOURCE_DEFAULTSPEAKERLEVEL;
+    }
+}
+
+void ALsource::eax5_set_defaults(Eax5Props& props) noexcept
+{
+    eax5_set_source_defaults(props.source);
+    eax5_set_sends_defaults(props.sends);
+    eax5_set_active_fx_slots_defaults(props.active_fx_slots);
+    eax5_set_speaker_levels_defaults(props.speaker_levels);
+}
+
+void ALsource::eax5_set_defaults() noexcept
+{
+    eax5_set_defaults(mEax5.i);
+    mEax5.d = mEax5.i;
+}
+
+void ALsource::eax_set_defaults() noexcept
+{
+    eax1_set_defaults();
+    eax2_set_defaults();
+    eax3_set_defaults();
+    eax4_set_defaults();
+    eax5_set_defaults();
+}
+
+void ALsource::eax1_translate(const Eax1Props& src, Eax5Props& dst) noexcept
+{
+    eax5_set_defaults(dst);
+
+    if (src.fMix == EAX_REVERBMIX_USEDISTANCE)
+    {
+        dst.source.ulFlags |= EAXSOURCEFLAGS_ROOMAUTO;
+        dst.sends[0].lSend = 0;
+    }
+    else
+    {
+        dst.source.ulFlags &= ~EAXSOURCEFLAGS_ROOMAUTO;
+        dst.sends[0].lSend = clamp(static_cast<long>(gain_to_level_mb(src.fMix)),
+            EAXSOURCE_MINSEND, EAXSOURCE_MAXSEND);
+    }
+}
+
+void ALsource::eax2_translate(const Eax2Props& src, Eax5Props& dst) noexcept
+{
+    // Source.
+    //
+    dst.source.lDirect = src.lDirect;
+    dst.source.lDirectHF = src.lDirectHF;
+    dst.source.lRoom = src.lRoom;
+    dst.source.lRoomHF = src.lRoomHF;
+    dst.source.lObstruction = src.lObstruction;
+    dst.source.flObstructionLFRatio = src.flObstructionLFRatio;
+    dst.source.lOcclusion = src.lOcclusion;
+    dst.source.flOcclusionLFRatio = src.flOcclusionLFRatio;
+    dst.source.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
+    dst.source.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+    dst.source.lExclusion = EAXSOURCE_DEFAULTEXCLUSION;
+    dst.source.flExclusionLFRatio = EAXSOURCE_DEFAULTEXCLUSIONLFRATIO;
+    dst.source.lOutsideVolumeHF = src.lOutsideVolumeHF;
+    dst.source.flDopplerFactor = EAXSOURCE_DEFAULTDOPPLERFACTOR;
+    dst.source.flRolloffFactor = EAXSOURCE_DEFAULTROLLOFFFACTOR;
+    dst.source.flRoomRolloffFactor = src.flRoomRolloffFactor;
+    dst.source.flAirAbsorptionFactor = src.flAirAbsorptionFactor;
+    dst.source.ulFlags = src.dwFlags;
+    dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
+
+    // Set everyting else to defaults.
+    //
+    eax5_set_sends_defaults(dst.sends);
+    eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
+    eax5_set_speaker_levels_defaults(dst.speaker_levels);
+}
+
+void ALsource::eax3_translate(const Eax3Props& src, Eax5Props& dst) noexcept
+{
+    // Source.
+    //
+    static_cast<Eax3Props&>(dst.source) = src;
+    dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
+
+    // Set everyting else to defaults.
+    //
+    eax5_set_sends_defaults(dst.sends);
+    eax5_set_active_fx_slots_defaults(dst.active_fx_slots);
+    eax5_set_speaker_levels_defaults(dst.speaker_levels);
+}
+
+void ALsource::eax4_translate(const Eax4Props& src, Eax5Props& dst) noexcept
+{
+    // Source.
+    //
+    static_cast<Eax3Props&>(dst.source) = src.source;
+    dst.source.flMacroFXFactor = EAXSOURCE_DEFAULTMACROFXFACTOR;
+
+    // Sends.
+    //
+    dst.sends = src.sends;
+
+    for (auto i = size_t{}; i < EAX_MAX_FXSLOTS; ++i)
+        dst.sends[i].guidReceivingFXSlotID = *(eax5_fx_slot_ids[i]);
+
+    // Active FX slots.
+    //
+    for (auto i = 0; i < EAX50_MAX_ACTIVE_FXSLOTS; ++i) {
+        auto& dst_id = dst.active_fx_slots.guidActiveFXSlots[i];
+
+        if (i < EAX40_MAX_ACTIVE_FXSLOTS) {
+            const auto& src_id = src.active_fx_slots.guidActiveFXSlots[i];
+
+            if (src_id == EAX_NULL_GUID)
+                dst_id = EAX_NULL_GUID;
+            else if (src_id == EAX_PrimaryFXSlotID)
+                dst_id = EAX_PrimaryFXSlotID;
+            else if (src_id == EAXPROPERTYID_EAX40_FXSlot0)
+                dst_id = EAXPROPERTYID_EAX50_FXSlot0;
+            else if (src_id == EAXPROPERTYID_EAX40_FXSlot1)
+                dst_id = EAXPROPERTYID_EAX50_FXSlot1;
+            else if (src_id == EAXPROPERTYID_EAX40_FXSlot2)
+                dst_id = EAXPROPERTYID_EAX50_FXSlot2;
+            else if (src_id == EAXPROPERTYID_EAX40_FXSlot3)
+                dst_id = EAXPROPERTYID_EAX50_FXSlot3;
+            else
+                assert(false && "Unknown active FX slot ID.");
+        } else
+            dst_id = EAX_NULL_GUID;
+    }
+
+    // Speaker levels.
+    //
+    eax5_set_speaker_levels_defaults(dst.speaker_levels);
+}
+
+float ALsource::eax_calculate_dst_occlusion_mb(
+    long src_occlusion_mb,
+    float path_ratio,
+    float lf_ratio) noexcept
+{
+    const auto ratio_1 = path_ratio + lf_ratio - 1.0F;
+    const auto ratio_2 = path_ratio * lf_ratio;
+    const auto ratio = (ratio_2 > ratio_1) ? ratio_2 : ratio_1;
+    const auto dst_occlustion_mb = static_cast<float>(src_occlusion_mb) * ratio;
+    return dst_occlustion_mb;
+}
+
+EaxAlLowPassParam ALsource::eax_create_direct_filter_param() const noexcept
+{
+    auto gain_mb =
+        static_cast<float>(mEax.source.lDirect) +
+        (static_cast<float>(mEax.source.lObstruction) * mEax.source.flObstructionLFRatio) +
+        eax_calculate_dst_occlusion_mb(
+            mEax.source.lOcclusion,
+            mEax.source.flOcclusionDirectRatio,
+            mEax.source.flOcclusionLFRatio);
+
+    const auto has_source_occlusion = (mEax.source.lOcclusion != 0);
+
+    auto gain_hf_mb =
+        static_cast<float>(mEax.source.lDirectHF) +
+        static_cast<float>(mEax.source.lObstruction);
+
+    for (auto i = std::size_t{}; i < EAX_MAX_FXSLOTS; ++i)
+    {
+        if(!mEaxActiveFxSlots[i])
+            continue;
+
+        if(has_source_occlusion) {
+            const auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
+            const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
+            const auto is_environmental_fx = ((fx_slot_eax.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0);
+            const auto is_primary = (mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index());
+            const auto is_listener_environment = (is_environmental_fx && is_primary);
+
+            if(is_listener_environment) {
+                gain_mb += eax_calculate_dst_occlusion_mb(
+                    mEax.source.lOcclusion,
+                    mEax.source.flOcclusionDirectRatio,
+                    mEax.source.flOcclusionLFRatio);
+
+                gain_hf_mb += static_cast<float>(mEax.source.lOcclusion) * mEax.source.flOcclusionDirectRatio;
+            }
+        }
+
+        const auto& send = mEax.sends[i];
+
+        if(send.lOcclusion != 0) {
+            gain_mb += eax_calculate_dst_occlusion_mb(
+                send.lOcclusion,
+                send.flOcclusionDirectRatio,
+                send.flOcclusionLFRatio);
+
+            gain_hf_mb += static_cast<float>(send.lOcclusion) * send.flOcclusionDirectRatio;
+        }
+    }
+
+    const auto al_low_pass_param = EaxAlLowPassParam{
+        level_mb_to_gain(gain_mb),
+        minf(level_mb_to_gain(gain_hf_mb), 1.0f)};
+
+    return al_low_pass_param;
+}
+
+EaxAlLowPassParam ALsource::eax_create_room_filter_param(
+    const ALeffectslot& fx_slot,
+    const EAXSOURCEALLSENDPROPERTIES& send) const noexcept
+{
+    const auto& fx_slot_eax = fx_slot.eax_get_eax_fx_slot();
+    const auto is_environmental_fx = ((fx_slot_eax.ulFlags & EAXFXSLOTFLAGS_ENVIRONMENT) != 0);
+    const auto is_primary = (mEaxPrimaryFxSlotId.value_or(-1) == fx_slot.eax_get_index());
+    const auto is_listener_environment = (is_environmental_fx && is_primary);
+
+    const auto gain_mb =
+        (static_cast<float>(fx_slot_eax.lOcclusion) * fx_slot_eax.flOcclusionLFRatio) +
+        static_cast<float>((is_environmental_fx ? mEax.source.lRoom : 0) + send.lSend) +
+        (is_listener_environment ?
+            eax_calculate_dst_occlusion_mb(
+                mEax.source.lOcclusion,
+                mEax.source.flOcclusionRoomRatio,
+                mEax.source.flOcclusionLFRatio) :
+            0.0f) +
+        eax_calculate_dst_occlusion_mb(
+            send.lOcclusion,
+            send.flOcclusionRoomRatio,
+            send.flOcclusionLFRatio) +
+        (is_listener_environment ?
+            (static_cast<float>(mEax.source.lExclusion) * mEax.source.flExclusionLFRatio) :
+            0.0f) +
+        (static_cast<float>(send.lExclusion) * send.flExclusionLFRatio);
+
+    const auto gain_hf_mb =
+        static_cast<float>(fx_slot_eax.lOcclusion) +
+        static_cast<float>((is_environmental_fx ? mEax.source.lRoomHF : 0) + send.lSendHF) +
+        (is_listener_environment ?
+            ((static_cast<float>(mEax.source.lOcclusion) * mEax.source.flOcclusionRoomRatio)) :
+            0.0f) +
+        (static_cast<float>(send.lOcclusion) * send.flOcclusionRoomRatio) +
+        (is_listener_environment ?
+            static_cast<float>(mEax.source.lExclusion + send.lExclusion) :
+            0.0f);
+
+    const auto al_low_pass_param = EaxAlLowPassParam{
+        level_mb_to_gain(gain_mb),
+        minf(level_mb_to_gain(gain_hf_mb), 1.0f)};
+
+    return al_low_pass_param;
+}
+
+void ALsource::eax_update_direct_filter()
+{
+    const auto& direct_param = eax_create_direct_filter_param();
+    Direct.Gain = direct_param.gain;
+    Direct.GainHF = direct_param.gain_hf;
+    Direct.HFReference = LOWPASSFREQREF;
+    Direct.GainLF = 1.0f;
+    Direct.LFReference = HIGHPASSFREQREF;
+    mPropsDirty = true;
+}
+
+void ALsource::eax_update_room_filters()
+{
+    for (auto i = size_t{}; i < EAX_MAX_FXSLOTS; ++i) {
+        if (!mEaxActiveFxSlots[i])
+            continue;
+
+        auto& fx_slot = mEaxAlContext->eaxGetFxSlot(i);
+        const auto& send = mEax.sends[i];
+        const auto& room_param = eax_create_room_filter_param(fx_slot, send);
+        eax_set_al_source_send(&fx_slot, i, room_param);
+    }
+}
+
+void ALsource::eax_set_efx_outer_gain_hf()
+{
+    OuterGainHF = clamp(
+        level_mb_to_gain(static_cast<float>(mEax.source.lOutsideVolumeHF)),
+        AL_MIN_CONE_OUTER_GAINHF,
+        AL_MAX_CONE_OUTER_GAINHF);
+}
+
+void ALsource::eax_set_efx_doppler_factor()
+{
+    DopplerFactor = mEax.source.flDopplerFactor;
+}
+
+void ALsource::eax_set_efx_rolloff_factor()
+{
+    RolloffFactor2 = mEax.source.flRolloffFactor;
+}
+
+void ALsource::eax_set_efx_room_rolloff_factor()
+{
+    RoomRolloffFactor = mEax.source.flRoomRolloffFactor;
+}
+
+void ALsource::eax_set_efx_air_absorption_factor()
+{
+    AirAbsorptionFactor = mEax.source.flAirAbsorptionFactor;
+}
+
+void ALsource::eax_set_efx_dry_gain_hf_auto()
+{
+    DryGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_DIRECTHFAUTO) != 0);
+}
+
+void ALsource::eax_set_efx_wet_gain_auto()
+{
+    WetGainAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMAUTO) != 0);
+}
+
+void ALsource::eax_set_efx_wet_gain_hf_auto()
+{
+    WetGainHFAuto = ((mEax.source.ulFlags & EAXSOURCEFLAGS_ROOMHFAUTO) != 0);
+}
+
+void ALsource::eax1_set(const EaxCall& call, Eax1Props& props)
+{
+    switch (call.get_property_id()) {
+        case DSPROPERTY_EAXBUFFER_ALL:
+            eax_defer<Eax1SourceAllValidator>(call, props);
+            break;
+
+        case DSPROPERTY_EAXBUFFER_REVERBMIX:
+            eax_defer<Eax1SourceReverbMixValidator>(call, props.fMix);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax2_set(const EaxCall& call, Eax2Props& props)
+{
+    switch (call.get_property_id()) {
+        case DSPROPERTY_EAX20BUFFER_NONE:
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
+            eax_defer<Eax2SourceAllValidator>(call, props);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_DIRECT:
+            eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_DIRECTHF:
+            eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOM:
+            eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOMHF:
+            eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
+            eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
+            eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
+            eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSION:
+            eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
+            eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
+            eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
+            eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
+            eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_FLAGS:
+            eax_defer<Eax2SourceFlagsValidator>(call, props.dwFlags);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax3_set(const EaxCall& call, Eax3Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+            break;
+
+        case EAXSOURCE_ALLPARAMETERS:
+            eax_defer<Eax3SourceAllValidator>(call, props);
+            break;
+
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+            eax_defer_sub<Eax4ObstructionValidator, EAXOBSTRUCTIONPROPERTIES>(call, props.lObstruction);
+            break;
+
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+            eax_defer_sub<Eax4OcclusionValidator, EAXOCCLUSIONPROPERTIES>(call, props.lOcclusion);
+            break;
+
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+            eax_defer_sub<Eax4ExclusionValidator, EAXEXCLUSIONPROPERTIES>(call, props.lExclusion);
+            break;
+
+        case EAXSOURCE_DIRECT:
+            eax_defer<Eax2SourceDirectValidator>(call, props.lDirect);
+            break;
+
+        case EAXSOURCE_DIRECTHF:
+            eax_defer<Eax2SourceDirectHfValidator>(call, props.lDirectHF);
+            break;
+
+        case EAXSOURCE_ROOM:
+            eax_defer<Eax2SourceRoomValidator>(call, props.lRoom);
+            break;
+
+        case EAXSOURCE_ROOMHF:
+            eax_defer<Eax2SourceRoomHfValidator>(call, props.lRoomHF);
+            break;
+
+        case EAXSOURCE_OBSTRUCTION:
+            eax_defer<Eax2SourceObstructionValidator>(call, props.lObstruction);
+            break;
+
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+            eax_defer<Eax2SourceObstructionLfRatioValidator>(call, props.flObstructionLFRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSION:
+            eax_defer<Eax2SourceOcclusionValidator>(call, props.lOcclusion);
+            break;
+
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+            eax_defer<Eax2SourceOcclusionLfRatioValidator>(call, props.flOcclusionLFRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+            eax_defer<Eax2SourceOcclusionRoomRatioValidator>(call, props.flOcclusionRoomRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+            eax_defer<Eax3SourceOcclusionDirectRatioValidator>(call, props.flOcclusionDirectRatio);
+            break;
+
+        case EAXSOURCE_EXCLUSION:
+            eax_defer<Eax3SourceExclusionValidator>(call, props.lExclusion);
+            break;
+
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+            eax_defer<Eax3SourceExclusionLfRatioValidator>(call, props.flExclusionLFRatio);
+            break;
+
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+            eax_defer<Eax2SourceOutsideVolumeHfValidator>(call, props.lOutsideVolumeHF);
+            break;
+
+        case EAXSOURCE_DOPPLERFACTOR:
+            eax_defer<Eax3SourceDopplerFactorValidator>(call, props.flDopplerFactor);
+            break;
+
+        case EAXSOURCE_ROLLOFFFACTOR:
+            eax_defer<Eax3SourceRolloffFactorValidator>(call, props.flRolloffFactor);
+            break;
+
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+            eax_defer<Eax2SourceRoomRolloffFactorValidator>(call, props.flRoomRolloffFactor);
+            break;
+
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+            eax_defer<Eax2SourceAirAbsorptionFactorValidator>(call, props.flAirAbsorptionFactor);
+            break;
+
+        case EAXSOURCE_FLAGS:
+            eax_defer<Eax2SourceFlagsValidator>(call, props.ulFlags);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax4_set(const EaxCall& call, Eax4Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+        case EAXSOURCE_ALLPARAMETERS:
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+        case EAXSOURCE_DIRECT:
+        case EAXSOURCE_DIRECTHF:
+        case EAXSOURCE_ROOM:
+        case EAXSOURCE_ROOMHF:
+        case EAXSOURCE_OBSTRUCTION:
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+        case EAXSOURCE_OCCLUSION:
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+        case EAXSOURCE_EXCLUSION:
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+        case EAXSOURCE_DOPPLERFACTOR:
+        case EAXSOURCE_ROLLOFFFACTOR:
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+        case EAXSOURCE_FLAGS:
+            eax3_set(call, props.source);
+            break;
+
+        case EAXSOURCE_SENDPARAMETERS:
+            eax4_defer_sends<Eax4SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ALLSENDPARAMETERS:
+            eax4_defer_sends<Eax4AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
+            eax4_defer_sends<Eax4OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
+            eax4_defer_sends<Eax4ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ACTIVEFXSLOTID:
+            eax4_defer_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax5_defer_all_2d(const EaxCall& call, EAX50SOURCEPROPERTIES& props)
+{
+    const auto& src_props = call.get_value<Exception, const EAXSOURCE2DPROPERTIES>();
+    Eax5SourceAll2dValidator{}(src_props);
+    props.lDirect = src_props.lDirect;
+    props.lDirectHF = src_props.lDirectHF;
+    props.lRoom = src_props.lRoom;
+    props.lRoomHF = src_props.lRoomHF;
+    props.ulFlags = src_props.ulFlags;
+}
+
+void ALsource::eax5_defer_speaker_levels(const EaxCall& call, EaxSpeakerLevels& props)
+{
+    const auto values = call.get_values<const EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
+    std::for_each(values.cbegin(), values.cend(), Eax5SpeakerAllValidator{});
+
+    for (const auto& value : values) {
+        const auto index = static_cast<size_t>(value.lSpeakerID - EAXSPEAKER_FRONT_LEFT);
+        props[index].lLevel = value.lLevel;
+    }
+}
+
+void ALsource::eax5_set(const EaxCall& call, Eax5Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+            break;
+
+        case EAXSOURCE_ALLPARAMETERS:
+            eax_defer<Eax5SourceAllValidator>(call, props.source);
+            break;
+
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+        case EAXSOURCE_DIRECT:
+        case EAXSOURCE_DIRECTHF:
+        case EAXSOURCE_ROOM:
+        case EAXSOURCE_ROOMHF:
+        case EAXSOURCE_OBSTRUCTION:
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+        case EAXSOURCE_OCCLUSION:
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+        case EAXSOURCE_EXCLUSION:
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+        case EAXSOURCE_DOPPLERFACTOR:
+        case EAXSOURCE_ROLLOFFFACTOR:
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+        case EAXSOURCE_FLAGS:
+            eax3_set(call, props.source);
+            break;
+
+        case EAXSOURCE_SENDPARAMETERS:
+            eax5_defer_sends<Eax5SendValidator, EAXSOURCESENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ALLSENDPARAMETERS:
+            eax5_defer_sends<Eax5AllSendValidator, EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
+            eax5_defer_sends<Eax5OcclusionSendValidator, EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
+            eax5_defer_sends<Eax5ExclusionSendValidator, EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ACTIVEFXSLOTID:
+            eax5_defer_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots);
+            break;
+
+        case EAXSOURCE_MACROFXFACTOR:
+            eax_defer<Eax5SourceMacroFXFactorValidator>(call, props.source.flMacroFXFactor);
+            break;
+
+        case EAXSOURCE_SPEAKERLEVELS:
+            eax5_defer_speaker_levels(call, props.speaker_levels);
+            break;
+
+        case EAXSOURCE_ALL2DPARAMETERS:
+            eax5_defer_all_2d(call, props.source);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax_set(const EaxCall& call)
+{
+    const auto eax_version = call.get_version();
+    switch(eax_version)
+    {
+    case 1: eax1_set(call, mEax1.d); break;
+    case 2: eax2_set(call, mEax2.d); break;
+    case 3: eax3_set(call, mEax3.d); break;
+    case 4: eax4_set(call, mEax4.d); break;
+    case 5: eax5_set(call, mEax5.d); break;
+    default: eax_fail_unknown_property_id();
+    }
+    mEaxChanged = true;
+    mEaxVersion = eax_version;
+}
+
+void ALsource::eax_get_active_fx_slot_id(const EaxCall& call, const GUID* ids, size_t max_count)
+{
+    assert(ids != nullptr);
+    assert(max_count == EAX40_MAX_ACTIVE_FXSLOTS || max_count == EAX50_MAX_ACTIVE_FXSLOTS);
+    const auto dst_ids = call.get_values<GUID>(max_count);
+    const auto count = dst_ids.size();
+    std::uninitialized_copy_n(ids, count, dst_ids.begin());
+}
+
+void ALsource::eax1_get(const EaxCall& call, const Eax1Props& props)
+{
+    switch (call.get_property_id()) {
+        case DSPROPERTY_EAXBUFFER_ALL:
+        case DSPROPERTY_EAXBUFFER_REVERBMIX:
+            call.set_value<Exception>(props.fMix);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax2_get(const EaxCall& call, const Eax2Props& props)
+{
+    switch (call.get_property_id()) {
+        case DSPROPERTY_EAX20BUFFER_NONE:
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ALLPARAMETERS:
+            call.set_value<Exception>(props);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_DIRECT:
+            call.set_value<Exception>(props.lDirect);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_DIRECTHF:
+            call.set_value<Exception>(props.lDirectHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOM:
+            call.set_value<Exception>(props.lRoom);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOMHF:
+            call.set_value<Exception>(props.lRoomHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_ROOMROLLOFFFACTOR:
+            call.set_value<Exception>(props.flRoomRolloffFactor);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OBSTRUCTION:
+            call.set_value<Exception>(props.lObstruction);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OBSTRUCTIONLFRATIO:
+            call.set_value<Exception>(props.flObstructionLFRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSION:
+            call.set_value<Exception>(props.lOcclusion);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSIONLFRATIO:
+            call.set_value<Exception>(props.flOcclusionLFRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OCCLUSIONROOMRATIO:
+            call.set_value<Exception>(props.flOcclusionRoomRatio);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_OUTSIDEVOLUMEHF:
+            call.set_value<Exception>(props.lOutsideVolumeHF);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_AIRABSORPTIONFACTOR:
+            call.set_value<Exception>(props.flAirAbsorptionFactor);
+            break;
+
+        case DSPROPERTY_EAX20BUFFER_FLAGS:
+            call.set_value<Exception>(props.dwFlags);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax3_get_obstruction(const EaxCall& call, const Eax3Props& props)
+{
+    const auto& subprops = reinterpret_cast<const EAXOBSTRUCTIONPROPERTIES&>(props.lObstruction);
+    call.set_value<Exception>(subprops);
+}
+
+void ALsource::eax3_get_occlusion(const EaxCall& call, const Eax3Props& props)
+{
+    const auto& subprops = reinterpret_cast<const EAXOCCLUSIONPROPERTIES&>(props.lOcclusion);
+    call.set_value<Exception>(subprops);
+}
+
+void ALsource::eax3_get_exclusion(const EaxCall& call, const Eax3Props& props)
+{
+    const auto& subprops = reinterpret_cast<const EAXEXCLUSIONPROPERTIES&>(props.lExclusion);
+    call.set_value<Exception>(subprops);
+}
+
+void ALsource::eax3_get(const EaxCall& call, const Eax3Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+            break;
+
+        case EAXSOURCE_ALLPARAMETERS:
+            call.set_value<Exception>(props);
+            break;
+
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+            eax3_get_obstruction(call, props);
+            break;
+
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+            eax3_get_occlusion(call, props);
+            break;
+
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+            eax3_get_exclusion(call, props);
+            break;
+
+        case EAXSOURCE_DIRECT:
+            call.set_value<Exception>(props.lDirect);
+            break;
+
+        case EAXSOURCE_DIRECTHF:
+            call.set_value<Exception>(props.lDirectHF);
+            break;
+
+        case EAXSOURCE_ROOM:
+            call.set_value<Exception>(props.lRoom);
+            break;
+
+        case EAXSOURCE_ROOMHF:
+            call.set_value<Exception>(props.lRoomHF);
+            break;
+
+        case EAXSOURCE_OBSTRUCTION:
+            call.set_value<Exception>(props.lObstruction);
+            break;
+
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+            call.set_value<Exception>(props.flObstructionLFRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSION:
+            call.set_value<Exception>(props.lOcclusion);
+            break;
+
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+            call.set_value<Exception>(props.flOcclusionLFRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+            call.set_value<Exception>(props.flOcclusionRoomRatio);
+            break;
+
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+            call.set_value<Exception>(props.flOcclusionDirectRatio);
+            break;
+
+        case EAXSOURCE_EXCLUSION:
+            call.set_value<Exception>(props.lExclusion);
+            break;
+
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+            call.set_value<Exception>(props.flExclusionLFRatio);
+            break;
+
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+            call.set_value<Exception>(props.lOutsideVolumeHF);
+            break;
+
+        case EAXSOURCE_DOPPLERFACTOR:
+            call.set_value<Exception>(props.flDopplerFactor);
+            break;
+
+        case EAXSOURCE_ROLLOFFFACTOR:
+            call.set_value<Exception>(props.flRolloffFactor);
+            break;
+
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+            call.set_value<Exception>(props.flRoomRolloffFactor);
+            break;
+
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+            call.set_value<Exception>(props.flAirAbsorptionFactor);
+            break;
+
+        case EAXSOURCE_FLAGS:
+            call.set_value<Exception>(props.ulFlags);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax4_get(const EaxCall& call, const Eax4Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+            break;
+
+        case EAXSOURCE_ALLPARAMETERS:
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+        case EAXSOURCE_DIRECT:
+        case EAXSOURCE_DIRECTHF:
+        case EAXSOURCE_ROOM:
+        case EAXSOURCE_ROOMHF:
+        case EAXSOURCE_OBSTRUCTION:
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+        case EAXSOURCE_OCCLUSION:
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+        case EAXSOURCE_EXCLUSION:
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+        case EAXSOURCE_DOPPLERFACTOR:
+        case EAXSOURCE_ROLLOFFFACTOR:
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+        case EAXSOURCE_FLAGS:
+            eax3_get(call, props.source);
+            break;
+
+        case EAXSOURCE_SENDPARAMETERS:
+            eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ALLSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ACTIVEFXSLOTID:
+            eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots, EAX40_MAX_ACTIVE_FXSLOTS);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax5_get_all_2d(const EaxCall& call, const EAX50SOURCEPROPERTIES& props)
+{
+    auto& subprops = call.get_value<Exception, EAXSOURCE2DPROPERTIES>();
+    subprops.lDirect = props.lDirect;
+    subprops.lDirectHF = props.lDirectHF;
+    subprops.lRoom = props.lRoom;
+    subprops.lRoomHF = props.lRoomHF;
+    subprops.ulFlags = props.ulFlags;
+}
+
+void ALsource::eax5_get_speaker_levels(const EaxCall& call, const EaxSpeakerLevels& props)
+{
+    const auto subprops = call.get_values<EAXSPEAKERLEVELPROPERTIES>(eax_max_speakers);
+    std::uninitialized_copy_n(props.cbegin(), subprops.size(), subprops.begin());
+}
+
+void ALsource::eax5_get(const EaxCall& call, const Eax5Props& props)
+{
+    switch (call.get_property_id()) {
+        case EAXSOURCE_NONE:
+            break;
+
+        case EAXSOURCE_ALLPARAMETERS:
+        case EAXSOURCE_OBSTRUCTIONPARAMETERS:
+        case EAXSOURCE_OCCLUSIONPARAMETERS:
+        case EAXSOURCE_EXCLUSIONPARAMETERS:
+        case EAXSOURCE_DIRECT:
+        case EAXSOURCE_DIRECTHF:
+        case EAXSOURCE_ROOM:
+        case EAXSOURCE_ROOMHF:
+        case EAXSOURCE_OBSTRUCTION:
+        case EAXSOURCE_OBSTRUCTIONLFRATIO:
+        case EAXSOURCE_OCCLUSION:
+        case EAXSOURCE_OCCLUSIONLFRATIO:
+        case EAXSOURCE_OCCLUSIONROOMRATIO:
+        case EAXSOURCE_OCCLUSIONDIRECTRATIO:
+        case EAXSOURCE_EXCLUSION:
+        case EAXSOURCE_EXCLUSIONLFRATIO:
+        case EAXSOURCE_OUTSIDEVOLUMEHF:
+        case EAXSOURCE_DOPPLERFACTOR:
+        case EAXSOURCE_ROLLOFFFACTOR:
+        case EAXSOURCE_ROOMROLLOFFFACTOR:
+        case EAXSOURCE_AIRABSORPTIONFACTOR:
+        case EAXSOURCE_FLAGS:
+            eax3_get(call, props.source);
+            break;
+
+        case EAXSOURCE_SENDPARAMETERS:
+            eax_get_sends<EAXSOURCESENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ALLSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEALLSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_OCCLUSIONSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEOCCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_EXCLUSIONSENDPARAMETERS:
+            eax_get_sends<EAXSOURCEEXCLUSIONSENDPROPERTIES>(call, props.sends);
+            break;
+
+        case EAXSOURCE_ACTIVEFXSLOTID:
+            eax_get_active_fx_slot_id(call, props.active_fx_slots.guidActiveFXSlots, EAX50_MAX_ACTIVE_FXSLOTS);
+            break;
+
+        case EAXSOURCE_MACROFXFACTOR:
+            call.set_value<Exception>(props.source.flMacroFXFactor);
+            break;
+
+        case EAXSOURCE_SPEAKERLEVELS:
+            call.set_value<Exception>(props.speaker_levels);
+            break;
+
+        case EAXSOURCE_ALL2DPARAMETERS:
+            eax5_get_all_2d(call, props.source);
+            break;
+
+        default:
+            eax_fail_unknown_property_id();
+    }
+}
+
+void ALsource::eax_get(const EaxCall& call)
+{
+    switch (call.get_version()) {
+        case 1: eax1_get(call, mEax1.i); break;
+        case 2: eax2_get(call, mEax2.i); break;
+        case 3: eax3_get(call, mEax3.i); break;
+        case 4: eax4_get(call, mEax4.i); break;
+        case 5: eax5_get(call, mEax5.i); break;
+        default: eax_fail_unknown_version();
+    }
+}
+
+void ALsource::eax_set_al_source_send(ALeffectslot *slot, size_t sendidx, const EaxAlLowPassParam &filter)
+{
+    if(sendidx >= EAX_MAX_FXSLOTS)
+        return;
+
+    auto &send = Send[sendidx];
+    send.Gain = filter.gain;
+    send.GainHF = filter.gain_hf;
+    send.HFReference = LOWPASSFREQREF;
+    send.GainLF = 1.0f;
+    send.LFReference = HIGHPASSFREQREF;
+
+    if(slot != nullptr)
+        IncrementRef(slot->ref);
+    if(auto *oldslot = send.Slot)
+        DecrementRef(oldslot->ref);
+
+    send.Slot = slot;
+    mPropsDirty = true;
+}
+
+void ALsource::eax_commit_active_fx_slots()
+{
+    // Clear all slots to an inactive state.
+    mEaxActiveFxSlots.fill(false);
+
+    // Mark the set slots as active.
+    for(const auto& slot_id : mEax.active_fx_slots.guidActiveFXSlots)
+    {
+        if(slot_id == EAX_NULL_GUID)
+        {
+        }
+        else if(slot_id == EAX_PrimaryFXSlotID)
+        {
+            // Mark primary FX slot as active.
+            if(mEaxPrimaryFxSlotId.has_value())
+                mEaxActiveFxSlots[*mEaxPrimaryFxSlotId] = true;
+        }
+        else if(slot_id == EAXPROPERTYID_EAX50_FXSlot0)
+            mEaxActiveFxSlots[0] = true;
+        else if(slot_id == EAXPROPERTYID_EAX50_FXSlot1)
+            mEaxActiveFxSlots[1] = true;
+        else if(slot_id == EAXPROPERTYID_EAX50_FXSlot2)
+            mEaxActiveFxSlots[2] = true;
+        else if(slot_id == EAXPROPERTYID_EAX50_FXSlot3)
+            mEaxActiveFxSlots[3] = true;
+    }
+
+    // Deactivate EFX auxiliary effect slots for inactive slots. Active slots
+    // will be updated with the room filters.
+    for(auto i = size_t{}; i < EAX_MAX_FXSLOTS; ++i)
+    {
+        if(!mEaxActiveFxSlots[i])
+            eax_set_al_source_send(nullptr, i, EaxAlLowPassParam{1.0f, 1.0f});
+    }
+}
+
+void ALsource::eax_commit_filters()
+{
+    eax_update_direct_filter();
+    eax_update_room_filters();
+}
+
+void ALsource::eaxCommit()
+{
+    const auto primary_fx_slot_id = mEaxAlContext->eaxGetPrimaryFxSlotIndex();
+    const auto is_primary_fx_slot_id_changed = (mEaxPrimaryFxSlotId != primary_fx_slot_id);
+
+    if(!mEaxChanged && !is_primary_fx_slot_id_changed)
+        return;
+
+    mEaxPrimaryFxSlotId = primary_fx_slot_id;
+    mEaxChanged = false;
+
+    switch(mEaxVersion)
+    {
+    case 1:
+        mEax1.i = mEax1.d;
+        eax1_translate(mEax1.i, mEax);
+        break;
+    case 2:
+        mEax2.i = mEax2.d;
+        eax2_translate(mEax2.i, mEax);
+        break;
+    case 3:
+        mEax3.i = mEax3.d;
+        eax3_translate(mEax3.i, mEax);
+        break;
+    case 4:
+        mEax4.i = mEax4.d;
+        eax4_translate(mEax4.i, mEax);
+        break;
+    case 5:
+        mEax5.i = mEax5.d;
+        mEax = mEax5.d;
+        break;
+    }
+
+    eax_set_efx_outer_gain_hf();
+    eax_set_efx_doppler_factor();
+    eax_set_efx_rolloff_factor();
+    eax_set_efx_room_rolloff_factor();
+    eax_set_efx_air_absorption_factor();
+    eax_set_efx_dry_gain_hf_auto();
+    eax_set_efx_wet_gain_auto();
+    eax_set_efx_wet_gain_hf_auto();
+
+    eax_commit_active_fx_slots();
+    eax_commit_filters();
+}
+
+#endif // ALSOFT_EAX
diff --git a/al/source.h b/al/source.h
index 7ca889d7..ac97c8a7 100644
--- a/al/source.h
+++ b/al/source.h
@@ -5,97 +5,131 @@
 #include <atomic>
 #include <cstddef>
 #include <iterator>
+#include <limits>
+#include <deque>
 
 #include "AL/al.h"
 #include "AL/alc.h"
 
-#include "alcontext.h"
+#include "alc/alu.h"
+#include "alc/context.h"
+#include "alc/inprogext.h"
+#include "aldeque.h"
 #include "almalloc.h"
 #include "alnumeric.h"
-#include "alu.h"
+#include "atomic.h"
+#include "core/voice.h"
 #include "vector.h"
 
+#ifdef ALSOFT_EAX
+#include "eax/call.h"
+#include "eax/exception.h"
+#include "eax/fx_slot_index.h"
+#include "eax/utils.h"
+#endif // ALSOFT_EAX
+
 struct ALbuffer;
 struct ALeffectslot;
 
 
+enum class SourceStereo : bool {
+    Normal = AL_NORMAL_SOFT,
+    Enhanced = AL_SUPER_STEREO_SOFT
+};
+
 #define DEFAULT_SENDS  2
 
 #define INVALID_VOICE_IDX static_cast<ALuint>(-1)
 
-struct ALbufferlistitem {
-    std::atomic<ALbufferlistitem*> mNext{nullptr};
-    ALuint mSampleLen{0u};
+extern bool sBufferSubDataCompat;
+
+struct ALbufferQueueItem : public VoiceBufferItem {
     ALbuffer *mBuffer{nullptr};
 
-    DEF_NEWDEL(ALbufferlistitem)
+    DISABLE_ALLOC()
 };
 
 
+#ifdef ALSOFT_EAX
+class EaxSourceException : public EaxException {
+public:
+    explicit EaxSourceException(const char* message)
+        : EaxException{"EAX_SOURCE", message}
+    {}
+};
+#endif // ALSOFT_EAX
+
 struct ALsource {
     /** Source properties. */
-    ALfloat   Pitch;
-    ALfloat   Gain;
-    ALfloat   OuterGain;
-    ALfloat   MinGain;
-    ALfloat   MaxGain;
-    ALfloat   InnerAngle;
-    ALfloat   OuterAngle;
-    ALfloat   RefDistance;
-    ALfloat   MaxDistance;
-    ALfloat   RolloffFactor;
-    std::array<ALfloat,3> Position;
-    std::array<ALfloat,3> Velocity;
-    std::array<ALfloat,3> Direction;
-    std::array<ALfloat,3> OrientAt;
-    std::array<ALfloat,3> OrientUp;
-    bool HeadRelative;
-    bool Looping;
-    DistanceModel mDistanceModel;
-    Resampler mResampler;
-    bool DirectChannels;
-    SpatializeMode mSpatialize;
-
-    bool DryGainHFAuto;
-    bool WetGainAuto;
-    bool WetGainHFAuto;
-    ALfloat OuterGainHF;
-
-    ALfloat AirAbsorptionFactor;
-    ALfloat RoomRolloffFactor;
-    ALfloat DopplerFactor;
+    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};
+#ifdef ALSOFT_EAX
+    // For EAXSOURCE_ROLLOFFFACTOR, which is distinct from and added to
+    // AL_ROLLOFF_FACTOR
+    float RolloffFactor2{0.0f};
+#endif
+    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};
+    SourceStereo mStereoMode{SourceStereo::Normal};
+
+    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<ALfloat,2> StereoPan;
+    std::array<float,2> StereoPan{{al::numbers::pi_v<float>/6.0f, -al::numbers::pi_v<float>/6.0f}};
 
-    ALfloat Radius;
+    float Radius{0.0f};
+    float EnhWidth{0.593f};
 
     /** Direct filter and auxiliary send info. */
     struct {
-        ALfloat Gain;
-        ALfloat GainHF;
-        ALfloat HFReference;
-        ALfloat GainLF;
-        ALfloat LFReference;
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
     } Direct;
     struct SendData {
         ALeffectslot *Slot;
-        ALfloat Gain;
-        ALfloat GainHF;
-        ALfloat HFReference;
-        ALfloat GainLF;
-        ALfloat LFReference;
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
     };
-    al::vector<SendData> Send;
+    std::array<SendData,MAX_SENDS> Send;
 
     /**
      * Last user-specified offset, and the offset type (bytes, samples, or
      * seconds).
      */
-    ALdouble Offset{0.0};
-    ALenum   OffsetType{AL_NONE};
+    double Offset{0.0};
+    ALenum OffsetType{AL_NONE};
 
     /** Source type (static, streaming, or undetermined) */
     ALenum SourceType{AL_UNDETERMINED};
@@ -104,9 +138,9 @@ struct ALsource {
     ALenum state{AL_INITIAL};
 
     /** Source Buffer Queue head. */
-    ALbufferlistitem *queue{nullptr};
+    al::deque<ALbufferQueueItem> mQueue;
 
-    std::atomic_flag PropsClean;
+    bool mPropsDirty{true};
 
     /* Index into the context's Voices array. Lazily updated, only checked and
      * reset when looking up the voice.
@@ -117,11 +151,892 @@ struct ALsource {
     ALuint id{0};
 
 
-    ALsource(ALuint num_sends);
+    ALsource();
     ~ALsource();
 
     ALsource(const ALsource&) = delete;
     ALsource& operator=(const ALsource&) = delete;
+
+    DISABLE_ALLOC()
+
+#ifdef ALSOFT_EAX
+public:
+    void eaxInitialize(ALCcontext *context) noexcept;
+    void eaxDispatch(const EaxCall& call);
+    void eaxCommit();
+    void eaxMarkAsChanged() noexcept { mEaxChanged = true; }
+
+    static ALsource* EaxLookupSource(ALCcontext& al_context, ALuint source_id) noexcept;
+
+private:
+    using Exception = EaxSourceException;
+
+    static constexpr auto eax_max_speakers = 9;
+
+    using EaxFxSlotIds = const GUID* [EAX_MAX_FXSLOTS];
+
+    static constexpr const EaxFxSlotIds eax4_fx_slot_ids = {
+        &EAXPROPERTYID_EAX40_FXSlot0,
+        &EAXPROPERTYID_EAX40_FXSlot1,
+        &EAXPROPERTYID_EAX40_FXSlot2,
+        &EAXPROPERTYID_EAX40_FXSlot3,
+    };
+
+    static constexpr const EaxFxSlotIds eax5_fx_slot_ids = {
+        &EAXPROPERTYID_EAX50_FXSlot0,
+        &EAXPROPERTYID_EAX50_FXSlot1,
+        &EAXPROPERTYID_EAX50_FXSlot2,
+        &EAXPROPERTYID_EAX50_FXSlot3,
+    };
+
+    using EaxActiveFxSlots = std::array<bool, EAX_MAX_FXSLOTS>;
+    using EaxSpeakerLevels = std::array<EAXSPEAKERLEVELPROPERTIES, eax_max_speakers>;
+    using EaxSends = std::array<EAXSOURCEALLSENDPROPERTIES, EAX_MAX_FXSLOTS>;
+
+    using Eax1Props = EAXBUFFER_REVERBPROPERTIES;
+    struct Eax1State {
+        Eax1Props i; // Immediate.
+        Eax1Props d; // Deferred.
+    };
+
+    using Eax2Props = EAX20BUFFERPROPERTIES;
+    struct Eax2State {
+        Eax2Props i; // Immediate.
+        Eax2Props d; // Deferred.
+    };
+
+    using Eax3Props = EAX30SOURCEPROPERTIES;
+    struct Eax3State {
+        Eax3Props i; // Immediate.
+        Eax3Props d; // Deferred.
+    };
+
+    struct Eax4Props {
+        Eax3Props source;
+        EaxSends sends;
+        EAX40ACTIVEFXSLOTS active_fx_slots;
+
+        bool operator==(const Eax4Props& rhs) noexcept
+        {
+            return std::memcmp(this, &rhs, sizeof(Eax4Props)) == 0;
+        }
+    };
+
+    struct Eax4State {
+        Eax4Props i; // Immediate.
+        Eax4Props d; // Deferred.
+    };
+
+    struct Eax5Props {
+        EAX50SOURCEPROPERTIES source;
+        EaxSends sends;
+        EAX50ACTIVEFXSLOTS active_fx_slots;
+        EaxSpeakerLevels speaker_levels;
+
+        bool operator==(const Eax5Props& rhs) noexcept
+        {
+            return std::memcmp(this, &rhs, sizeof(Eax5Props)) == 0;
+        }
+    };
+
+    struct Eax5State {
+        Eax5Props i; // Immediate.
+        Eax5Props d; // Deferred.
+    };
+
+    ALCcontext* mEaxAlContext{};
+    EaxFxSlotIndex mEaxPrimaryFxSlotId{};
+    EaxActiveFxSlots mEaxActiveFxSlots{};
+    int mEaxVersion{};
+    bool mEaxChanged{};
+    Eax1State mEax1{};
+    Eax2State mEax2{};
+    Eax3State mEax3{};
+    Eax4State mEax4{};
+    Eax5State mEax5{};
+    Eax5Props mEax{};
+
+    // ----------------------------------------------------------------------
+    // Source validators
+
+    struct Eax1SourceReverbMixValidator {
+        void operator()(float reverb_mix) const
+        {
+            if (reverb_mix == EAX_REVERBMIX_USEDISTANCE)
+                return;
+
+            eax_validate_range<Exception>(
+                "Reverb Mix",
+                reverb_mix,
+                EAX_BUFFER_MINREVERBMIX,
+                EAX_BUFFER_MAXREVERBMIX);
+        }
+    };
+
+    struct Eax2SourceDirectValidator {
+        void operator()(long lDirect) const
+        {
+            eax_validate_range<Exception>(
+                "Direct",
+                lDirect,
+                EAXSOURCE_MINDIRECT,
+                EAXSOURCE_MAXDIRECT);
+        }
+    };
+
+    struct Eax2SourceDirectHfValidator {
+        void operator()(long lDirectHF) const
+        {
+            eax_validate_range<Exception>(
+                "Direct HF",
+                lDirectHF,
+                EAXSOURCE_MINDIRECTHF,
+                EAXSOURCE_MAXDIRECTHF);
+        }
+    };
+
+    struct Eax2SourceRoomValidator {
+        void operator()(long lRoom) const
+        {
+            eax_validate_range<Exception>(
+                "Room",
+                lRoom,
+                EAXSOURCE_MINROOM,
+                EAXSOURCE_MAXROOM);
+        }
+    };
+
+    struct Eax2SourceRoomHfValidator {
+        void operator()(long lRoomHF) const
+        {
+            eax_validate_range<Exception>(
+                "Room HF",
+                lRoomHF,
+                EAXSOURCE_MINROOMHF,
+                EAXSOURCE_MAXROOMHF);
+        }
+    };
+
+    struct Eax2SourceRoomRolloffFactorValidator {
+        void operator()(float flRoomRolloffFactor) const
+        {
+            eax_validate_range<Exception>(
+                "Room Rolloff Factor",
+                flRoomRolloffFactor,
+                EAXSOURCE_MINROOMROLLOFFFACTOR,
+                EAXSOURCE_MAXROOMROLLOFFFACTOR);
+        }
+    };
+
+    struct Eax2SourceObstructionValidator {
+        void operator()(long lObstruction) const
+        {
+            eax_validate_range<Exception>(
+                "Obstruction",
+                lObstruction,
+                EAXSOURCE_MINOBSTRUCTION,
+                EAXSOURCE_MAXOBSTRUCTION);
+        }
+    };
+
+    struct Eax2SourceObstructionLfRatioValidator {
+        void operator()(float flObstructionLFRatio) const
+        {
+            eax_validate_range<Exception>(
+                "Obstruction LF Ratio",
+                flObstructionLFRatio,
+                EAXSOURCE_MINOBSTRUCTIONLFRATIO,
+                EAXSOURCE_MAXOBSTRUCTIONLFRATIO);
+        }
+    };
+
+    struct Eax2SourceOcclusionValidator {
+        void operator()(long lOcclusion) const
+        {
+            eax_validate_range<Exception>(
+                "Occlusion",
+                lOcclusion,
+                EAXSOURCE_MINOCCLUSION,
+                EAXSOURCE_MAXOCCLUSION);
+        }
+    };
+
+    struct Eax2SourceOcclusionLfRatioValidator {
+        void operator()(float flOcclusionLFRatio) const
+        {
+            eax_validate_range<Exception>(
+                "Occlusion LF Ratio",
+                flOcclusionLFRatio,
+                EAXSOURCE_MINOCCLUSIONLFRATIO,
+                EAXSOURCE_MAXOCCLUSIONLFRATIO);
+        }
+    };
+
+    struct Eax2SourceOcclusionRoomRatioValidator {
+        void operator()(float flOcclusionRoomRatio) const
+        {
+            eax_validate_range<Exception>(
+                "Occlusion Room Ratio",
+                flOcclusionRoomRatio,
+                EAXSOURCE_MINOCCLUSIONROOMRATIO,
+                EAXSOURCE_MAXOCCLUSIONROOMRATIO);
+        }
+    };
+
+    struct Eax2SourceOutsideVolumeHfValidator {
+        void operator()(long lOutsideVolumeHF) const
+        {
+            eax_validate_range<Exception>(
+                "Outside Volume HF",
+                lOutsideVolumeHF,
+                EAXSOURCE_MINOUTSIDEVOLUMEHF,
+                EAXSOURCE_MAXOUTSIDEVOLUMEHF);
+        }
+    };
+
+    struct Eax2SourceAirAbsorptionFactorValidator {
+        void operator()(float flAirAbsorptionFactor) const
+        {
+            eax_validate_range<Exception>(
+                "Air Absorption Factor",
+                flAirAbsorptionFactor,
+                EAXSOURCE_MINAIRABSORPTIONFACTOR,
+                EAXSOURCE_MAXAIRABSORPTIONFACTOR);
+        }
+    };
+
+    struct Eax2SourceFlagsValidator {
+        void operator()(unsigned long dwFlags) const
+        {
+            eax_validate_range<Exception>(
+                "Flags",
+                dwFlags,
+                0UL,
+                ~EAX20SOURCEFLAGS_RESERVED);
+        }
+    };
+
+    struct Eax3SourceOcclusionDirectRatioValidator {
+        void operator()(float flOcclusionDirectRatio) const
+        {
+            eax_validate_range<Exception>(
+                "Occlusion Direct Ratio",
+                flOcclusionDirectRatio,
+                EAXSOURCE_MINOCCLUSIONDIRECTRATIO,
+                EAXSOURCE_MAXOCCLUSIONDIRECTRATIO);
+        }
+    };
+
+    struct Eax3SourceExclusionValidator {
+        void operator()(long lExclusion) const
+        {
+            eax_validate_range<Exception>(
+                "Exclusion",
+                lExclusion,
+                EAXSOURCE_MINEXCLUSION,
+                EAXSOURCE_MAXEXCLUSION);
+        }
+    };
+
+    struct Eax3SourceExclusionLfRatioValidator {
+        void operator()(float flExclusionLFRatio) const
+        {
+            eax_validate_range<Exception>(
+                "Exclusion LF Ratio",
+                flExclusionLFRatio,
+                EAXSOURCE_MINEXCLUSIONLFRATIO,
+                EAXSOURCE_MAXEXCLUSIONLFRATIO);
+        }
+    };
+
+    struct Eax3SourceDopplerFactorValidator {
+        void operator()(float flDopplerFactor) const
+        {
+            eax_validate_range<Exception>(
+                "Doppler Factor",
+                flDopplerFactor,
+                EAXSOURCE_MINDOPPLERFACTOR,
+                EAXSOURCE_MAXDOPPLERFACTOR);
+        }
+    };
+
+    struct Eax3SourceRolloffFactorValidator {
+        void operator()(float flRolloffFactor) const
+        {
+            eax_validate_range<Exception>(
+                "Rolloff Factor",
+                flRolloffFactor,
+                EAXSOURCE_MINROLLOFFFACTOR,
+                EAXSOURCE_MAXROLLOFFFACTOR);
+        }
+    };
+
+    struct Eax5SourceMacroFXFactorValidator {
+        void operator()(float flMacroFXFactor) const
+        {
+            eax_validate_range<Exception>(
+                "Macro FX Factor",
+                flMacroFXFactor,
+                EAXSOURCE_MINMACROFXFACTOR,
+                EAXSOURCE_MAXMACROFXFACTOR);
+        }
+    };
+
+    struct Eax5SourceFlagsValidator {
+        void operator()(unsigned long dwFlags) const
+        {
+            eax_validate_range<Exception>(
+                "Flags",
+                dwFlags,
+                0UL,
+                ~EAX50SOURCEFLAGS_RESERVED);
+        }
+    };
+
+    struct Eax1SourceAllValidator {
+        void operator()(const Eax1Props& props) const
+        {
+            Eax1SourceReverbMixValidator{}(props.fMix);
+        }
+    };
+
+    struct Eax2SourceAllValidator {
+        void operator()(const Eax2Props& props) const
+        {
+            Eax2SourceDirectValidator{}(props.lDirect);
+            Eax2SourceDirectHfValidator{}(props.lDirectHF);
+            Eax2SourceRoomValidator{}(props.lRoom);
+            Eax2SourceRoomHfValidator{}(props.lRoomHF);
+            Eax2SourceRoomRolloffFactorValidator{}(props.flRoomRolloffFactor);
+            Eax2SourceObstructionValidator{}(props.lObstruction);
+            Eax2SourceObstructionLfRatioValidator{}(props.flObstructionLFRatio);
+            Eax2SourceOcclusionValidator{}(props.lOcclusion);
+            Eax2SourceOcclusionLfRatioValidator{}(props.flOcclusionLFRatio);
+            Eax2SourceOcclusionRoomRatioValidator{}(props.flOcclusionRoomRatio);
+            Eax2SourceOutsideVolumeHfValidator{}(props.lOutsideVolumeHF);
+            Eax2SourceAirAbsorptionFactorValidator{}(props.flAirAbsorptionFactor);
+            Eax2SourceFlagsValidator{}(props.dwFlags);
+        }
+    };
+
+    struct Eax3SourceAllValidator {
+        void operator()(const Eax3Props& props) const
+        {
+            Eax2SourceDirectValidator{}(props.lDirect);
+            Eax2SourceDirectHfValidator{}(props.lDirectHF);
+            Eax2SourceRoomValidator{}(props.lRoom);
+            Eax2SourceRoomHfValidator{}(props.lRoomHF);
+            Eax2SourceObstructionValidator{}(props.lObstruction);
+            Eax2SourceObstructionLfRatioValidator{}(props.flObstructionLFRatio);
+            Eax2SourceOcclusionValidator{}(props.lOcclusion);
+            Eax2SourceOcclusionLfRatioValidator{}(props.flOcclusionLFRatio);
+            Eax2SourceOcclusionRoomRatioValidator{}(props.flOcclusionRoomRatio);
+            Eax3SourceOcclusionDirectRatioValidator{}(props.flOcclusionDirectRatio);
+            Eax3SourceExclusionValidator{}(props.lExclusion);
+            Eax3SourceExclusionLfRatioValidator{}(props.flExclusionLFRatio);
+            Eax2SourceOutsideVolumeHfValidator{}(props.lOutsideVolumeHF);
+            Eax3SourceDopplerFactorValidator{}(props.flDopplerFactor);
+            Eax3SourceRolloffFactorValidator{}(props.flRolloffFactor);
+            Eax2SourceRoomRolloffFactorValidator{}(props.flRoomRolloffFactor);
+            Eax2SourceAirAbsorptionFactorValidator{}(props.flAirAbsorptionFactor);
+            Eax2SourceFlagsValidator{}(props.ulFlags);
+        }
+    };
+
+    struct Eax5SourceAllValidator {
+        void operator()(const EAX50SOURCEPROPERTIES& props) const
+        {
+            Eax3SourceAllValidator{}(static_cast<const Eax3Props&>(props));
+            Eax5SourceMacroFXFactorValidator{}(props.flMacroFXFactor);
+        }
+    };
+
+    struct Eax5SourceAll2dValidator {
+        void operator()(const EAXSOURCE2DPROPERTIES& props) const
+        {
+            Eax2SourceDirectValidator{}(props.lDirect);
+            Eax2SourceDirectHfValidator{}(props.lDirectHF);
+            Eax2SourceRoomValidator{}(props.lRoom);
+            Eax2SourceRoomHfValidator{}(props.lRoomHF);
+            Eax5SourceFlagsValidator{}(props.ulFlags);
+        }
+    };
+
+    struct Eax4ObstructionValidator {
+        void operator()(const EAXOBSTRUCTIONPROPERTIES& props) const
+        {
+            Eax2SourceObstructionValidator{}(props.lObstruction);
+            Eax2SourceObstructionLfRatioValidator{}(props.flObstructionLFRatio);
+        }
+    };
+
+    struct Eax4OcclusionValidator {
+        void operator()(const EAXOCCLUSIONPROPERTIES& props) const
+        {
+            Eax2SourceOcclusionValidator{}(props.lOcclusion);
+            Eax2SourceOcclusionLfRatioValidator{}(props.flOcclusionLFRatio);
+            Eax2SourceOcclusionRoomRatioValidator{}(props.flOcclusionRoomRatio);
+            Eax3SourceOcclusionDirectRatioValidator{}(props.flOcclusionDirectRatio);
+        }
+    };
+
+    struct Eax4ExclusionValidator {
+        void operator()(const EAXEXCLUSIONPROPERTIES& props) const
+        {
+            Eax3SourceExclusionValidator{}(props.lExclusion);
+            Eax3SourceExclusionLfRatioValidator{}(props.flExclusionLFRatio);
+        }
+    };
+
+    // Source validators
+    // ----------------------------------------------------------------------
+    // Send validators
+
+    struct Eax4SendReceivingFxSlotIdValidator {
+        void operator()(const GUID& guidReceivingFXSlotID) const
+        {
+            if (guidReceivingFXSlotID != EAXPROPERTYID_EAX40_FXSlot0 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX40_FXSlot1 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX40_FXSlot2 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX40_FXSlot3)
+            {
+                eax_fail_unknown_receiving_fx_slot_id();
+            }
+        }
+    };
+
+    struct Eax5SendReceivingFxSlotIdValidator {
+        void operator()(const GUID& guidReceivingFXSlotID) const
+        {
+            if (guidReceivingFXSlotID != EAXPROPERTYID_EAX50_FXSlot0 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX50_FXSlot1 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX50_FXSlot2 &&
+                guidReceivingFXSlotID != EAXPROPERTYID_EAX50_FXSlot3)
+            {
+                eax_fail_unknown_receiving_fx_slot_id();
+            }
+        }
+    };
+
+    struct Eax4SendSendValidator {
+        void operator()(long lSend) const
+        {
+            eax_validate_range<Exception>(
+                "Send",
+                lSend,
+                EAXSOURCE_MINSEND,
+                EAXSOURCE_MAXSEND);
+        }
+    };
+
+    struct Eax4SendSendHfValidator {
+        void operator()(long lSendHF) const
+        {
+            eax_validate_range<Exception>(
+                "Send HF",
+                lSendHF,
+                EAXSOURCE_MINSENDHF,
+                EAXSOURCE_MAXSENDHF);
+        }
+    };
+
+    template<typename TIdValidator>
+    struct EaxSendValidator {
+        void operator()(const EAXSOURCESENDPROPERTIES& props) const
+        {
+            TIdValidator{}(props.guidReceivingFXSlotID);
+            Eax4SendSendValidator{}(props.lSend);
+            Eax4SendSendHfValidator{}(props.lSendHF);
+        }
+    };
+
+    struct Eax4SendValidator : EaxSendValidator<Eax4SendReceivingFxSlotIdValidator> {};
+    struct Eax5SendValidator : EaxSendValidator<Eax5SendReceivingFxSlotIdValidator> {};
+
+    template<typename TIdValidator>
+    struct EaxOcclusionSendValidator {
+        void operator()(const EAXSOURCEOCCLUSIONSENDPROPERTIES& props) const
+        {
+            TIdValidator{}(props.guidReceivingFXSlotID);
+            Eax2SourceOcclusionValidator{}(props.lOcclusion);
+            Eax2SourceOcclusionLfRatioValidator{}(props.flOcclusionLFRatio);
+            Eax2SourceOcclusionRoomRatioValidator{}(props.flOcclusionRoomRatio);
+            Eax3SourceOcclusionDirectRatioValidator{}(props.flOcclusionDirectRatio);
+        }
+    };
+
+    struct Eax4OcclusionSendValidator : EaxOcclusionSendValidator<Eax4SendReceivingFxSlotIdValidator> {};
+    struct Eax5OcclusionSendValidator : EaxOcclusionSendValidator<Eax5SendReceivingFxSlotIdValidator> {};
+
+    template<typename TIdValidator>
+    struct EaxExclusionSendValidator {
+        void operator()(const EAXSOURCEEXCLUSIONSENDPROPERTIES& props) const
+        {
+            TIdValidator{}(props.guidReceivingFXSlotID);
+            Eax3SourceExclusionValidator{}(props.lExclusion);
+            Eax3SourceExclusionLfRatioValidator{}(props.flExclusionLFRatio);
+        }
+    };
+
+    struct Eax4ExclusionSendValidator : EaxExclusionSendValidator<Eax4SendReceivingFxSlotIdValidator> {};
+    struct Eax5ExclusionSendValidator : EaxExclusionSendValidator<Eax5SendReceivingFxSlotIdValidator> {};
+
+    template<typename TIdValidator>
+    struct EaxAllSendValidator {
+        void operator()(const EAXSOURCEALLSENDPROPERTIES& props) const
+        {
+            TIdValidator{}(props.guidReceivingFXSlotID);
+            Eax4SendSendValidator{}(props.lSend);
+            Eax4SendSendHfValidator{}(props.lSendHF);
+            Eax2SourceOcclusionValidator{}(props.lOcclusion);
+            Eax2SourceOcclusionLfRatioValidator{}(props.flOcclusionLFRatio);
+            Eax2SourceOcclusionRoomRatioValidator{}(props.flOcclusionRoomRatio);
+            Eax3SourceOcclusionDirectRatioValidator{}(props.flOcclusionDirectRatio);
+            Eax3SourceExclusionValidator{}(props.lExclusion);
+            Eax3SourceExclusionLfRatioValidator{}(props.flExclusionLFRatio);
+        }
+    };
+
+    struct Eax4AllSendValidator : EaxAllSendValidator<Eax4SendReceivingFxSlotIdValidator> {};
+    struct Eax5AllSendValidator : EaxAllSendValidator<Eax5SendReceivingFxSlotIdValidator> {};
+
+    // Send validators
+    // ----------------------------------------------------------------------
+    // Active FX slot ID validators
+
+    struct Eax4ActiveFxSlotIdValidator {
+        void operator()(const GUID &guid) const
+        {
+            if(guid != EAX_NULL_GUID && guid != EAX_PrimaryFXSlotID
+                && guid != EAXPROPERTYID_EAX40_FXSlot0 && guid != EAXPROPERTYID_EAX40_FXSlot1
+                && guid != EAXPROPERTYID_EAX40_FXSlot2 && guid != EAXPROPERTYID_EAX40_FXSlot3)
+            {
+                eax_fail_unknown_active_fx_slot_id();
+            }
+        }
+    };
+
+    struct Eax5ActiveFxSlotIdValidator {
+        void operator()(const GUID &guid) const
+        {
+            if(guid != EAX_NULL_GUID && guid != EAX_PrimaryFXSlotID
+                && guid != EAXPROPERTYID_EAX50_FXSlot0 && guid != EAXPROPERTYID_EAX50_FXSlot1
+                && guid != EAXPROPERTYID_EAX50_FXSlot2 && guid != EAXPROPERTYID_EAX50_FXSlot3)
+            {
+                eax_fail_unknown_active_fx_slot_id();
+            }
+        }
+    };
+
+    // Active FX slot ID validators
+    // ----------------------------------------------------------------------
+    // Speaker level validators.
+
+    struct Eax5SpeakerIdValidator {
+        void operator()(long lSpeakerID) const
+        {
+            switch (lSpeakerID) {
+                case EAXSPEAKER_FRONT_LEFT:
+                case EAXSPEAKER_FRONT_CENTER:
+                case EAXSPEAKER_FRONT_RIGHT:
+                case EAXSPEAKER_SIDE_RIGHT:
+                case EAXSPEAKER_REAR_RIGHT:
+                case EAXSPEAKER_REAR_CENTER:
+                case EAXSPEAKER_REAR_LEFT:
+                case EAXSPEAKER_SIDE_LEFT:
+                case EAXSPEAKER_LOW_FREQUENCY:
+                    break;
+
+                default:
+                    eax_fail("Unknown speaker ID.");
+            }
+        }
+    };
+
+    struct Eax5SpeakerLevelValidator {
+        void operator()(long lLevel) const
+        {
+            // TODO Use a range when the feature will be implemented.
+            if (lLevel != EAXSOURCE_DEFAULTSPEAKERLEVEL)
+                eax_fail("Speaker level out of range.");
+        }
+    };
+
+    struct Eax5SpeakerAllValidator {
+        void operator()(const EAXSPEAKERLEVELPROPERTIES& all) const
+        {
+            Eax5SpeakerIdValidator{}(all.lSpeakerID);
+            Eax5SpeakerLevelValidator{}(all.lLevel);
+        }
+    };
+
+    // Speaker level validators.
+    // ----------------------------------------------------------------------
+
+    struct Eax4SendIndexGetter {
+        EaxFxSlotIndexValue operator()(const GUID &guid) const
+        {
+            if(guid == EAXPROPERTYID_EAX40_FXSlot0)
+                return 0;
+            if(guid == EAXPROPERTYID_EAX40_FXSlot1)
+                return 1;
+            if(guid == EAXPROPERTYID_EAX40_FXSlot2)
+                return 2;
+            if(guid == EAXPROPERTYID_EAX40_FXSlot3)
+                return 3;
+            eax_fail_unknown_receiving_fx_slot_id();
+        }
+    };
+
+    struct Eax5SendIndexGetter {
+        EaxFxSlotIndexValue operator()(const GUID &guid) const
+        {
+            if(guid == EAXPROPERTYID_EAX50_FXSlot0)
+                return 0;
+            if(guid == EAXPROPERTYID_EAX50_FXSlot1)
+                return 1;
+            if(guid == EAXPROPERTYID_EAX50_FXSlot2)
+                return 2;
+            if(guid == EAXPROPERTYID_EAX50_FXSlot3)
+                return 3;
+            eax_fail_unknown_receiving_fx_slot_id();
+        }
+    };
+
+    [[noreturn]] static void eax_fail(const char* message);
+    [[noreturn]] static void eax_fail_unknown_property_id();
+    [[noreturn]] static void eax_fail_unknown_version();
+    [[noreturn]] static void eax_fail_unknown_active_fx_slot_id();
+    [[noreturn]] static void eax_fail_unknown_receiving_fx_slot_id();
+
+    void eax_set_sends_defaults(EaxSends& sends, const EaxFxSlotIds& ids) noexcept;
+    void eax1_set_defaults(Eax1Props& props) noexcept;
+    void eax1_set_defaults() noexcept;
+    void eax2_set_defaults(Eax2Props& props) noexcept;
+    void eax2_set_defaults() noexcept;
+    void eax3_set_defaults(Eax3Props& props) noexcept;
+    void eax3_set_defaults() noexcept;
+    void eax4_set_sends_defaults(EaxSends& sends) noexcept;
+    void eax4_set_active_fx_slots_defaults(EAX40ACTIVEFXSLOTS& slots) noexcept;
+    void eax4_set_defaults() noexcept;
+    void eax5_set_source_defaults(EAX50SOURCEPROPERTIES& props) noexcept;
+    void eax5_set_sends_defaults(EaxSends& sends) noexcept;
+    void eax5_set_active_fx_slots_defaults(EAX50ACTIVEFXSLOTS& slots) noexcept;
+    void eax5_set_speaker_levels_defaults(EaxSpeakerLevels& speaker_levels) noexcept;
+    void eax5_set_defaults(Eax5Props& props) noexcept;
+    void eax5_set_defaults() noexcept;
+    void eax_set_defaults() noexcept;
+
+    void eax1_translate(const Eax1Props& src, Eax5Props& dst) noexcept;
+    void eax2_translate(const Eax2Props& src, Eax5Props& dst) noexcept;
+    void eax3_translate(const Eax3Props& src, Eax5Props& dst) noexcept;
+    void eax4_translate(const Eax4Props& src, Eax5Props& dst) noexcept;
+
+    static float eax_calculate_dst_occlusion_mb(
+        long src_occlusion_mb,
+        float path_ratio,
+        float lf_ratio) noexcept;
+
+    EaxAlLowPassParam eax_create_direct_filter_param() const noexcept;
+
+    EaxAlLowPassParam eax_create_room_filter_param(
+        const ALeffectslot& fx_slot,
+        const EAXSOURCEALLSENDPROPERTIES& send) const noexcept;
+
+    void eax_update_direct_filter();
+    void eax_update_room_filters();
+    void eax_commit_filters();
+
+    static void eax_copy_send_for_get(
+        const EAXSOURCEALLSENDPROPERTIES& src,
+        EAXSOURCESENDPROPERTIES& dst) noexcept
+    {
+        dst = reinterpret_cast<const EAXSOURCESENDPROPERTIES&>(src);
+    }
+
+    static void eax_copy_send_for_get(
+        const EAXSOURCEALLSENDPROPERTIES& src,
+        EAXSOURCEALLSENDPROPERTIES& dst) noexcept
+    {
+        dst = src;
+    }
+
+    static void eax_copy_send_for_get(
+        const EAXSOURCEALLSENDPROPERTIES& src,
+        EAXSOURCEOCCLUSIONSENDPROPERTIES& dst) noexcept
+    {
+        dst.guidReceivingFXSlotID = src.guidReceivingFXSlotID;
+        dst.lOcclusion = src.lOcclusion;
+        dst.flOcclusionLFRatio = src.flOcclusionLFRatio;
+        dst.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
+        dst.flOcclusionDirectRatio = src.flOcclusionDirectRatio;
+    }
+
+    static void eax_copy_send_for_get(
+        const EAXSOURCEALLSENDPROPERTIES& src,
+        EAXSOURCEEXCLUSIONSENDPROPERTIES& dst) noexcept
+    {
+        dst.guidReceivingFXSlotID = src.guidReceivingFXSlotID;
+        dst.lExclusion = src.lExclusion;
+        dst.flExclusionLFRatio = src.flExclusionLFRatio;
+    }
+
+    template<typename TDstSend>
+    void eax_get_sends(const EaxCall& call, const EaxSends& src_sends)
+    {
+        const auto dst_sends = call.get_values<TDstSend>(EAX_MAX_FXSLOTS);
+        const auto count = dst_sends.size();
+
+        for (auto i = decltype(count){}; i < count; ++i) {
+            const auto& src_send = src_sends[i];
+            auto& dst_send = dst_sends[i];
+            eax_copy_send_for_get(src_send, dst_send);
+        }
+    }
+
+    void eax_get_active_fx_slot_id(const EaxCall& call, const GUID* ids, size_t max_count);
+    void eax1_get(const EaxCall& call, const Eax1Props& props);
+    void eax2_get(const EaxCall& call, const Eax2Props& props);
+    void eax3_get_obstruction(const EaxCall& call, const Eax3Props& props);
+    void eax3_get_occlusion(const EaxCall& call, const Eax3Props& props);
+    void eax3_get_exclusion(const EaxCall& call, const Eax3Props& props);
+    void eax3_get(const EaxCall& call, const Eax3Props& props);
+    void eax4_get(const EaxCall& call, const Eax4Props& props);
+    void eax5_get_all_2d(const EaxCall& call, const EAX50SOURCEPROPERTIES& props);
+    void eax5_get_speaker_levels(const EaxCall& call, const EaxSpeakerLevels& props);
+    void eax5_get(const EaxCall& call, const Eax5Props& props);
+    void eax_get(const EaxCall& call);
+
+    static void eax_copy_send_for_set(
+        const EAXSOURCESENDPROPERTIES& src,
+        EAXSOURCEALLSENDPROPERTIES& dst) noexcept
+    {
+        dst.lSend = src.lSend;
+        dst.lSendHF = src.lSendHF;
+    }
+
+    static void eax_copy_send_for_set(
+        const EAXSOURCEALLSENDPROPERTIES& src,
+        EAXSOURCEALLSENDPROPERTIES& dst) noexcept
+    {
+        dst.lSend = src.lSend;
+        dst.lSendHF = src.lSendHF;
+        dst.lOcclusion = src.lOcclusion;
+        dst.flOcclusionLFRatio = src.flOcclusionLFRatio;
+        dst.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
+        dst.flOcclusionDirectRatio = src.flOcclusionDirectRatio;
+        dst.lExclusion = src.lExclusion;
+        dst.flExclusionLFRatio = src.flExclusionLFRatio;
+    }
+
+    static void eax_copy_send_for_set(
+        const EAXSOURCEOCCLUSIONSENDPROPERTIES& src,
+        EAXSOURCEALLSENDPROPERTIES& dst) noexcept
+    {
+        dst.lOcclusion = src.lOcclusion;
+        dst.flOcclusionLFRatio = src.flOcclusionLFRatio;
+        dst.flOcclusionRoomRatio = src.flOcclusionRoomRatio;
+        dst.flOcclusionDirectRatio = src.flOcclusionDirectRatio;
+    }
+
+    static void eax_copy_send_for_set(
+        const EAXSOURCEEXCLUSIONSENDPROPERTIES& src,
+        EAXSOURCEALLSENDPROPERTIES& dst) noexcept
+    {
+        dst.lExclusion = src.lExclusion;
+        dst.flExclusionLFRatio = src.flExclusionLFRatio;
+    }
+
+    template<typename TValidator, typename TIndexGetter, typename TSrcSend>
+    void eax_defer_sends(const EaxCall& call, EaxSends& dst_sends)
+    {
+        const auto src_sends = call.get_values<const TSrcSend>(EAX_MAX_FXSLOTS);
+        std::for_each(src_sends.cbegin(), src_sends.cend(), TValidator{});
+        const auto count = src_sends.size();
+        const auto index_getter = TIndexGetter{};
+
+        for (auto i = decltype(count){}; i < count; ++i) {
+            const auto& src_send = src_sends[i];
+            const auto dst_index = index_getter(src_send.guidReceivingFXSlotID);
+            auto& dst_send = dst_sends[dst_index];
+            eax_copy_send_for_set(src_send, dst_send);
+        }
+    }
+
+    template<typename TValidator, typename TSrcSend>
+    void eax4_defer_sends(const EaxCall& call, EaxSends& dst_sends)
+    {
+        eax_defer_sends<TValidator, Eax4SendIndexGetter, TSrcSend>(call, dst_sends);
+    }
+
+    template<typename TValidator, typename TSrcSend>
+    void eax5_defer_sends(const EaxCall& call, EaxSends& dst_sends)
+    {
+        eax_defer_sends<TValidator, Eax5SendIndexGetter, TSrcSend>(call, dst_sends);
+    }
+
+    template<typename TValidator, size_t TIdCount>
+    void eax_defer_active_fx_slot_id(const EaxCall& call, GUID (&dst_ids)[TIdCount])
+    {
+        const auto src_ids = call.get_values<const GUID>(TIdCount);
+        std::for_each(src_ids.cbegin(), src_ids.cend(), TValidator{});
+        std::uninitialized_copy(src_ids.cbegin(), src_ids.cend(), dst_ids);
+    }
+
+    template<size_t TIdCount>
+    void eax4_defer_active_fx_slot_id(const EaxCall& call, GUID (&dst_ids)[TIdCount])
+    {
+        eax_defer_active_fx_slot_id<Eax4ActiveFxSlotIdValidator>(call, dst_ids);
+    }
+
+    template<size_t TIdCount>
+    void eax5_defer_active_fx_slot_id(const EaxCall& call, GUID (&dst_ids)[TIdCount])
+    {
+        eax_defer_active_fx_slot_id<Eax5ActiveFxSlotIdValidator>(call, dst_ids);
+    }
+
+    template<typename TValidator, typename TProperty>
+    static void eax_defer(const EaxCall& call, TProperty& property)
+    {
+        const auto& value = call.get_value<Exception, const TProperty>();
+        TValidator{}(value);
+        property = value;
+    }
+
+    // Defers source's sub-properties (obstruction, occlusion, exclusion).
+    template<typename TValidator, typename TSubproperty, typename TProperty>
+    void eax_defer_sub(const EaxCall& call, TProperty& property)
+    {
+        const auto& src_props = call.get_value<Exception, const TSubproperty>();
+        TValidator{}(src_props);
+        auto& dst_props = reinterpret_cast<TSubproperty&>(property);
+        dst_props = src_props;
+    }
+
+    void eax_set_efx_outer_gain_hf();
+    void eax_set_efx_doppler_factor();
+    void eax_set_efx_rolloff_factor();
+    void eax_set_efx_room_rolloff_factor();
+    void eax_set_efx_air_absorption_factor();
+    void eax_set_efx_dry_gain_hf_auto();
+    void eax_set_efx_wet_gain_auto();
+    void eax_set_efx_wet_gain_hf_auto();
+
+    void eax1_set(const EaxCall& call, Eax1Props& props);
+    void eax2_set(const EaxCall& call, Eax2Props& props);
+    void eax3_set(const EaxCall& call, Eax3Props& props);
+    void eax4_set(const EaxCall& call, Eax4Props& props);
+    void eax5_defer_all_2d(const EaxCall& call, EAX50SOURCEPROPERTIES& props);
+    void eax5_defer_speaker_levels(const EaxCall& call, EaxSpeakerLevels& props);
+    void eax5_set(const EaxCall& call, Eax5Props& props);
+    void eax_set(const EaxCall& call);
+
+    // `alSource3i(source, AL_AUXILIARY_SEND_FILTER, ...)`
+    void eax_set_al_source_send(ALeffectslot *slot, size_t sendidx,
+        const EaxAlLowPassParam &filter);
+
+    void eax_commit_active_fx_slots();
+#endif // ALSOFT_EAX
 };
 
 void UpdateAllSourceProps(ALCcontext *context);
diff --git a/al/state.cpp b/al/state.cpp
index 25a0efd1..86d81b13 100644
--- a/al/state.cpp
+++ b/al/state.cpp
@@ -24,26 +24,35 @@
 
 #include <atomic>
 #include <cmath>
-#include <cstdlib>
-#include <cstring>
 #include <mutex>
+#include <stdexcept>
+#include <string>
 
 #include "AL/al.h"
 #include "AL/alc.h"
 #include "AL/alext.h"
 
-#include "alcontext.h"
-#include "alexcpt.h"
-#include "almalloc.h"
+#include "alc/alu.h"
+#include "alc/context.h"
+#include "alc/inprogext.h"
 #include "alnumeric.h"
-#include "alspan.h"
-#include "alu.h"
+#include "aloptional.h"
 #include "atomic.h"
-#include "event.h"
-#include "inprogext.h"
+#include "core/context.h"
+#include "core/except.h"
+#include "core/mixer/defs.h"
+#include "core/voice.h"
+#include "intrusive_ptr.h"
 #include "opthelpers.h"
 #include "strutils.h"
 
+#ifdef ALSOFT_EAX
+#include "alc/device.h"
+
+#include "eax/globals.h"
+#include "eax/x_ram.h"
+#endif // ALSOFT_EAX
+
 
 namespace {
 
@@ -94,12 +103,41 @@ const ALchar *GetResamplerName(const Resampler rtype)
     throw std::runtime_error{"Unexpected resampler index"};
 }
 
+al::optional<DistanceModel> DistanceModelFromALenum(ALenum model)
+{
+    switch(model)
+    {
+    case AL_NONE: return DistanceModel::Disable;
+    case AL_INVERSE_DISTANCE: return DistanceModel::Inverse;
+    case AL_INVERSE_DISTANCE_CLAMPED: return DistanceModel::InverseClamped;
+    case AL_LINEAR_DISTANCE: return DistanceModel::Linear;
+    case AL_LINEAR_DISTANCE_CLAMPED: return DistanceModel::LinearClamped;
+    case AL_EXPONENT_DISTANCE: return DistanceModel::Exponent;
+    case AL_EXPONENT_DISTANCE_CLAMPED: return 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)
+AL_API const ALchar* AL_APIENTRY alsoft_get_version(void)
 START_API_FUNC
 {
     static const auto spoof = al::getenv("ALSOFT_SPOOF_VERSION");
@@ -109,25 +147,31 @@ START_API_FUNC
 END_API_FUNC
 
 #define DO_UPDATEPROPS() do {                                                 \
-    if(!context->mDeferUpdates.load(std::memory_order_acquire))               \
+    if(!context->mDeferUpdates)                                               \
         UpdateContextProps(context.get());                                    \
     else                                                                      \
-        context->mPropsClean.clear(std::memory_order_release);                \
+        context->mPropsDirty = true;                                          \
 } while(0)
 
 
-AL_API ALvoid AL_APIENTRY alEnable(ALenum capability)
+AL_API void AL_APIENTRY alEnable(ALenum capability)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    std::lock_guard<std::mutex> _{context->mPropLock};
     switch(capability)
     {
     case AL_SOURCE_DISTANCE_MODEL:
-        context->mSourceDistanceModel = AL_TRUE;
-        DO_UPDATEPROPS();
+        {
+            std::lock_guard<std::mutex> _{context->mPropLock};
+            context->mSourceDistanceModel = true;
+            DO_UPDATEPROPS();
+        }
+        break;
+
+    case AL_STOP_SOURCES_ON_DISCONNECT_SOFT:
+        context->setError(AL_INVALID_OPERATION, "Re-enabling AL_STOP_SOURCES_ON_DISCONNECT_SOFT not yet supported");
         break;
 
     default:
@@ -136,18 +180,24 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDisable(ALenum capability)
+AL_API void AL_APIENTRY alDisable(ALenum capability)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    std::lock_guard<std::mutex> _{context->mPropLock};
     switch(capability)
     {
     case AL_SOURCE_DISTANCE_MODEL:
-        context->mSourceDistanceModel = AL_FALSE;
-        DO_UPDATEPROPS();
+        {
+            std::lock_guard<std::mutex> _{context->mPropLock};
+            context->mSourceDistanceModel = false;
+            DO_UPDATEPROPS();
+        }
+        break;
+
+    case AL_STOP_SOURCES_ON_DISCONNECT_SOFT:
+        context->mStopVoicesOnDisconnect = false;
         break;
 
     default:
@@ -160,14 +210,18 @@ AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return AL_FALSE;
+    if(!context) UNLIKELY return AL_FALSE;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALboolean value{AL_FALSE};
     switch(capability)
     {
     case AL_SOURCE_DISTANCE_MODEL:
-        value = context->mSourceDistanceModel;
+        value = context->mSourceDistanceModel ? AL_TRUE : AL_FALSE;
+        break;
+
+    case AL_STOP_SOURCES_ON_DISCONNECT_SOFT:
+        value = context->mStopVoicesOnDisconnect ? AL_TRUE : AL_FALSE;
         break;
 
     default:
@@ -182,7 +236,7 @@ AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return AL_FALSE;
+    if(!context) UNLIKELY return AL_FALSE;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALboolean value{AL_FALSE};
@@ -209,12 +263,12 @@ START_API_FUNC
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
-        if(context->mDeferUpdates.load(std::memory_order_acquire))
+        if(context->mDeferUpdates)
             value = AL_TRUE;
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        if(GAIN_MIX_MAX/context->mGainBoost != 0.0f)
+        if(GainMixMax/context->mGainBoost != 0.0f)
             value = AL_TRUE;
         break;
 
@@ -239,7 +293,7 @@ AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return 0.0;
+    if(!context) UNLIKELY return 0.0;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALdouble value{0.0};
@@ -254,7 +308,7 @@ START_API_FUNC
         break;
 
     case AL_DISTANCE_MODEL:
-        value = static_cast<ALdouble>(context->mDistanceModel);
+        value = static_cast<ALdouble>(ALenumFromDistanceModel(context->mDistanceModel));
         break;
 
     case AL_SPEED_OF_SOUND:
@@ -262,12 +316,12 @@ START_API_FUNC
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
-        if(context->mDeferUpdates.load(std::memory_order_acquire))
+        if(context->mDeferUpdates)
             value = static_cast<ALdouble>(AL_TRUE);
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = ALdouble{GAIN_MIX_MAX}/context->mGainBoost;
+        value = ALdouble{GainMixMax}/context->mGainBoost;
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
@@ -290,7 +344,7 @@ AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return 0.0f;
+    if(!context) UNLIKELY return 0.0f;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALfloat value{0.0f};
@@ -305,7 +359,7 @@ START_API_FUNC
         break;
 
     case AL_DISTANCE_MODEL:
-        value = static_cast<ALfloat>(context->mDistanceModel);
+        value = static_cast<ALfloat>(ALenumFromDistanceModel(context->mDistanceModel));
         break;
 
     case AL_SPEED_OF_SOUND:
@@ -313,12 +367,12 @@ START_API_FUNC
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
-        if(context->mDeferUpdates.load(std::memory_order_acquire))
+        if(context->mDeferUpdates)
             value = static_cast<ALfloat>(AL_TRUE);
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = GAIN_MIX_MAX/context->mGainBoost;
+        value = GainMixMax/context->mGainBoost;
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
@@ -341,7 +395,7 @@ AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return 0;
+    if(!context) UNLIKELY return 0;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALint value{0};
@@ -356,7 +410,7 @@ START_API_FUNC
         break;
 
     case AL_DISTANCE_MODEL:
-        value = static_cast<ALint>(context->mDistanceModel);
+        value = ALenumFromDistanceModel(context->mDistanceModel);
         break;
 
     case AL_SPEED_OF_SOUND:
@@ -364,12 +418,12 @@ START_API_FUNC
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
-        if(context->mDeferUpdates.load(std::memory_order_acquire))
+        if(context->mDeferUpdates)
             value = AL_TRUE;
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = static_cast<ALint>(GAIN_MIX_MAX/context->mGainBoost);
+        value = static_cast<ALint>(GainMixMax/context->mGainBoost);
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
@@ -380,6 +434,41 @@ START_API_FUNC
         value = static_cast<int>(ResamplerDefault);
         break;
 
+#ifdef ALSOFT_EAX
+
+#define EAX_ERROR "[alGetInteger] EAX not enabled."
+
+    case AL_EAX_RAM_SIZE:
+        if (eax_g_is_enabled)
+        {
+            value = eax_x_ram_max_size;
+        }
+        else
+        {
+            context->setError(AL_INVALID_VALUE, EAX_ERROR);
+        }
+
+        break;
+
+    case AL_EAX_RAM_FREE:
+        if (eax_g_is_enabled)
+        {
+            auto device = context->mALDevice.get();
+            std::lock_guard<std::mutex> device_lock{device->BufferLock};
+
+            value = static_cast<ALint>(device->eax_x_ram_free_size);
+        }
+        else
+        {
+            context->setError(AL_INVALID_VALUE, EAX_ERROR);
+        }
+
+        break;
+
+#undef EAX_ERROR
+
+#endif // ALSOFT_EAX
+
     default:
         context->setError(AL_INVALID_VALUE, "Invalid integer property 0x%04x", pname);
     }
@@ -388,11 +477,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-extern "C" AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname)
+AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return 0_i64;
+    if(!context) UNLIKELY return 0_i64;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     ALint64SOFT value{0};
@@ -407,7 +496,7 @@ START_API_FUNC
         break;
 
     case AL_DISTANCE_MODEL:
-        value = static_cast<ALint64SOFT>(context->mDistanceModel);
+        value = ALenumFromDistanceModel(context->mDistanceModel);
         break;
 
     case AL_SPEED_OF_SOUND:
@@ -415,12 +504,12 @@ START_API_FUNC
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
-        if(context->mDeferUpdates.load(std::memory_order_acquire))
+        if(context->mDeferUpdates)
             value = AL_TRUE;
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = static_cast<ALint64SOFT>(GAIN_MIX_MAX/context->mGainBoost);
+        value = static_cast<ALint64SOFT>(GainMixMax/context->mGainBoost);
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
@@ -439,11 +528,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname)
+AL_API ALvoid* AL_APIENTRY alGetPointerSOFT(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return nullptr;
+    if(!context) UNLIKELY return nullptr;
 
     std::lock_guard<std::mutex> _{context->mPropLock};
     void *value{nullptr};
@@ -465,7 +554,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetBooleanv(ALenum pname, ALboolean *values)
+AL_API void AL_APIENTRY alGetBooleanv(ALenum pname, ALboolean *values)
 START_API_FUNC
 {
     if(values)
@@ -486,7 +575,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -498,7 +587,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetDoublev(ALenum pname, ALdouble *values)
+AL_API void AL_APIENTRY alGetDoublev(ALenum pname, ALdouble *values)
 START_API_FUNC
 {
     if(values)
@@ -519,7 +608,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -531,7 +620,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetFloatv(ALenum pname, ALfloat *values)
+AL_API void AL_APIENTRY alGetFloatv(ALenum pname, ALfloat *values)
 START_API_FUNC
 {
     if(values)
@@ -552,7 +641,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -564,7 +653,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values)
+AL_API void AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values)
 START_API_FUNC
 {
     if(values)
@@ -585,7 +674,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -597,7 +686,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-extern "C" AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values)
+AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values)
 START_API_FUNC
 {
     if(values)
@@ -618,7 +707,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -630,7 +719,7 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values)
+AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, ALvoid **values)
 START_API_FUNC
 {
     if(values)
@@ -645,7 +734,7 @@ START_API_FUNC
     }
 
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!values)
         context->setError(AL_INVALID_VALUE, "NULL pointer");
@@ -661,7 +750,7 @@ AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return nullptr;
+    if(!context) UNLIKELY return nullptr;
 
     const ALchar *value{nullptr};
     switch(pname)
@@ -713,11 +802,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDopplerFactor(ALfloat value)
+AL_API void AL_APIENTRY alDopplerFactor(ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!(value >= 0.0f && std::isfinite(value)))
         context->setError(AL_INVALID_VALUE, "Doppler factor %f out of range", value);
@@ -730,25 +819,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDopplerVelocity(ALfloat value)
+AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
-
-    if((context->mEnabledEvts.load(std::memory_order_relaxed)&EventType_Deprecated))
-    {
-        std::lock_guard<std::mutex> _{context->mEventCbLock};
-        ALbitfieldSOFT enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)};
-        if((enabledevts&EventType_Deprecated) && context->mEventCb)
-        {
-            static const char msg[] =
-                "alDopplerVelocity is deprecated in AL1.1, use alSpeedOfSound";
-            const ALsizei msglen{sizeof(msg)-1};
-            (*context->mEventCb)(AL_EVENT_TYPE_DEPRECATED_SOFT, 0, 0, msglen, msg,
-                context->mEventParam);
-        }
-    }
+    if(!context) UNLIKELY return;
 
     if(!(value >= 0.0f && std::isfinite(value)))
         context->setError(AL_INVALID_VALUE, "Doppler velocity %f out of range", value);
@@ -761,11 +836,11 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alSpeedOfSound(ALfloat value)
+AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
     if(!(value > 0.0f && std::isfinite(value)))
         context->setError(AL_INVALID_VALUE, "Speed of sound %f out of range", value);
@@ -778,44 +853,43 @@ START_API_FUNC
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alDistanceModel(ALenum value)
+AL_API void AL_APIENTRY alDistanceModel(ALenum value)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
-    if(!(value == AL_INVERSE_DISTANCE || value == AL_INVERSE_DISTANCE_CLAMPED ||
-         value == AL_LINEAR_DISTANCE || value == AL_LINEAR_DISTANCE_CLAMPED ||
-         value == AL_EXPONENT_DISTANCE || value == AL_EXPONENT_DISTANCE_CLAMPED ||
-         value == AL_NONE))
-        context->setError(AL_INVALID_VALUE, "Distance model 0x%04x out of range", value);
-    else
+    if(auto model = DistanceModelFromALenum(value))
     {
         std::lock_guard<std::mutex> _{context->mPropLock};
-        context->mDistanceModel = static_cast<DistanceModel>(value);
+        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 ALvoid AL_APIENTRY alDeferUpdatesSOFT(void)
+AL_API void AL_APIENTRY alDeferUpdatesSOFT(void)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
+    std::lock_guard<std::mutex> _{context->mPropLock};
     context->deferUpdates();
 }
 END_API_FUNC
 
-AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void)
+AL_API void AL_APIENTRY alProcessUpdatesSOFT(void)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return;
+    if(!context) UNLIKELY return;
 
+    std::lock_guard<std::mutex> _{context->mPropLock};
     context->processUpdates();
 }
 END_API_FUNC
@@ -825,7 +899,7 @@ AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index)
 START_API_FUNC
 {
     ContextRef context{GetContextRef()};
-    if UNLIKELY(!context) return nullptr;
+    if(!context) UNLIKELY return nullptr;
 
     const ALchar *value{nullptr};
     switch(pname)
@@ -848,12 +922,12 @@ END_API_FUNC
 void UpdateContextProps(ALCcontext *context)
 {
     /* Get an unused proprty container, or allocate a new one as needed. */
-    ALcontextProps *props{context->mFreeContextProps.load(std::memory_order_acquire)};
+    ContextProps *props{context->mFreeContextProps.load(std::memory_order_acquire)};
     if(!props)
-        props = new ALcontextProps{};
+        props = new ContextProps{};
     else
     {
-        ALcontextProps *next;
+        ContextProps *next;
         do {
             next = props->next.load(std::memory_order_relaxed);
         } while(context->mFreeContextProps.compare_exchange_weak(props, next,
@@ -861,6 +935,15 @@ void UpdateContextProps(ALCcontext *context)
     }
 
     /* 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;
+
+    props->AirAbsorptionGainHF = context->mAirAbsorptionGainHF;
     props->DopplerFactor = context->mDopplerFactor;
     props->DopplerVelocity = context->mDopplerVelocity;
     props->SpeedOfSound = context->mSpeedOfSound;
@@ -869,7 +952,7 @@ void UpdateContextProps(ALCcontext *context)
     props->mDistanceModel = context->mDistanceModel;
 
     /* Set the new container for updating internal parameters. */
-    props = context->mUpdate.exchange(props, std::memory_order_acq_rel);
+    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
diff --git a/alc/alc.cpp b/alc/alc.cpp
index bee42fc5..af8ff55d 100644
--- a/alc/alc.cpp
+++ b/alc/alc.cpp
@@ -22,10 +22,16 @@
 
 #include "version.h"
 
-#include <exception>
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <bitset>
+#include <cassert>
 #include <cctype>
 #include <chrono>
 #include <cinttypes>
@@ -42,9 +48,10 @@
 #include <memory>
 #include <mutex>
 #include <new>
-#include <numeric>
+#include <stddef.h>
+#include <stdexcept>
 #include <string>
-#include <thread>
+#include <type_traits>
 #include <utility>
 
 #include "AL/al.h"
@@ -53,50 +60,55 @@
 #include "AL/efx.h"
 
 #include "al/auxeffectslot.h"
+#include "al/buffer.h"
 #include "al/effect.h"
-#include "al/event.h"
 #include "al/filter.h"
 #include "al/listener.h"
 #include "al/source.h"
-#include "alcmain.h"
+#include "albit.h"
 #include "albyte.h"
 #include "alconfig.h"
-#include "alcontext.h"
-#include "alexcpt.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "aloptional.h"
 #include "alspan.h"
 #include "alstring.h"
 #include "alu.h"
-#include "ambidefs.h"
 #include "atomic.h"
-#include "bformatdec.h"
-#include "bs2b.h"
-#include "compat.h"
-#include "cpu_caps.h"
-#include "devformat.h"
+#include "context.h"
+#include "core/ambidefs.h"
+#include "core/bformatdec.h"
+#include "core/bs2b.h"
+#include "core/context.h"
+#include "core/cpu_caps.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/except.h"
+#include "core/helpers.h"
+#include "core/mastering.h"
+#include "core/mixer/hrtfdefs.h"
+#include "core/fpu_ctrl.h"
+#include "core/front_stablizer.h"
+#include "core/logging.h"
+#include "core/uhjfilter.h"
+#include "core/voice.h"
+#include "core/voice_change.h"
+#include "device.h"
 #include "effects/base.h"
-#include "filters/nfc.h"
-#include "filters/splitter.h"
-#include "fpu_modes.h"
-#include "hrtf.h"
 #include "inprogext.h"
 #include "intrusive_ptr.h"
-#include "logging.h"
-#include "mastering.h"
 #include "opthelpers.h"
-#include "pragmadefs.h"
-#include "ringbuffer.h"
 #include "strutils.h"
 #include "threads.h"
-#include "uhjfilter.h"
-#include "vecmat.h"
 #include "vector.h"
 
 #include "backends/base.h"
 #include "backends/null.h"
 #include "backends/loopback.h"
+#ifdef HAVE_PIPEWIRE
+#include "backends/pipewire.h"
+#endif
 #ifdef HAVE_JACK
 #include "backends/jack.h"
 #endif
@@ -115,6 +127,9 @@
 #ifdef HAVE_OPENSL
 #include "backends/opensl.h"
 #endif
+#ifdef HAVE_OBOE
+#include "backends/oboe.h"
+#endif
 #ifdef HAVE_SOLARIS
 #include "backends/solaris.h"
 #endif
@@ -124,9 +139,6 @@
 #ifdef HAVE_OSS
 #include "backends/oss.h"
 #endif
-#ifdef HAVE_QSA
-#include "backends/qsa.h"
-#endif
 #ifdef HAVE_DSOUND
 #include "backends/dsound.h"
 #endif
@@ -143,6 +155,36 @@
 #include "backends/wave.h"
 #endif
 
+#ifdef ALSOFT_EAX
+#include "al/eax/globals.h"
+#include "al/eax/x_ram.h"
+#endif // ALSOFT_EAX
+
+
+FILE *gLogFile{stderr};
+#ifdef _DEBUG
+LogLevel gLogLevel{LogLevel::Warning};
+#else
+LogLevel gLogLevel{LogLevel::Error};
+#endif
+
+/************************************************
+ * Library initialization
+ ************************************************/
+#if defined(_WIN32) && !defined(AL_LIBTYPE_STATIC)
+BOOL APIENTRY DllMain(HINSTANCE module, DWORD reason, LPVOID /*reserved*/)
+{
+    switch(reason)
+    {
+    case DLL_PROCESS_ATTACH:
+        /* Pin the DLL so we won't get unloaded until the process terminates */
+        GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+            reinterpret_cast<WCHAR*>(module), &module);
+        break;
+    }
+    return TRUE;
+}
+#endif
 
 namespace {
 
@@ -150,6 +192,9 @@ using namespace std::placeholders;
 using std::chrono::seconds;
 using std::chrono::nanoseconds;
 
+using voidp = void*;
+using float2 = std::array<float,2>;
+
 
 /************************************************
  * Backends
@@ -160,24 +205,27 @@ struct BackendInfo {
 };
 
 BackendInfo BackendList[] = {
-#ifdef HAVE_JACK
-    { "jack", JackBackendFactory::getFactory },
+#ifdef HAVE_PIPEWIRE
+    { "pipewire", PipeWireBackendFactory::getFactory },
 #endif
 #ifdef HAVE_PULSEAUDIO
     { "pulse", PulseBackendFactory::getFactory },
 #endif
-#ifdef HAVE_ALSA
-    { "alsa", AlsaBackendFactory::getFactory },
-#endif
 #ifdef HAVE_WASAPI
     { "wasapi", WasapiBackendFactory::getFactory },
 #endif
 #ifdef HAVE_COREAUDIO
     { "core", CoreAudioBackendFactory::getFactory },
 #endif
+#ifdef HAVE_OBOE
+    { "oboe", OboeBackendFactory::getFactory },
+#endif
 #ifdef HAVE_OPENSL
     { "opensl", OSLBackendFactory::getFactory },
 #endif
+#ifdef HAVE_ALSA
+    { "alsa", AlsaBackendFactory::getFactory },
+#endif
 #ifdef HAVE_SOLARIS
     { "solaris", SolarisBackendFactory::getFactory },
 #endif
@@ -187,8 +235,8 @@ BackendInfo BackendList[] = {
 #ifdef HAVE_OSS
     { "oss", OSSBackendFactory::getFactory },
 #endif
-#ifdef HAVE_QSA
-    { "qsa", QSABackendFactory::getFactory },
+#ifdef HAVE_JACK
+    { "jack", JackBackendFactory::getFactory },
 #endif
 #ifdef HAVE_DSOUND
     { "dsound", DSoundBackendFactory::getFactory },
@@ -208,7 +256,6 @@ BackendInfo BackendList[] = {
     { "wave", WaveBackendFactory::getFactory },
 #endif
 };
-auto BackendListEnd = std::end(BackendList);
 
 BackendFactory *PlaybackFactory{};
 BackendFactory *CaptureFactory{};
@@ -219,8 +266,8 @@ BackendFactory *CaptureFactory{};
  ************************************************/
 #define DECL(x) { #x, reinterpret_cast<void*>(x) }
 const struct {
-    const ALCchar *funcName;
-    ALCvoid *address;
+    const char *funcName;
+    void *address;
 } alcFunctions[] = {
     DECL(alcCreateContext),
     DECL(alcMakeContextCurrent),
@@ -258,6 +305,8 @@ const struct {
 
     DECL(alcGetInteger64vSOFT),
 
+    DECL(alcReopenDeviceSOFT),
+
     DECL(alEnable),
     DECL(alDisable),
     DECL(alIsEnabled),
@@ -393,6 +442,30 @@ const struct {
     DECL(alEventCallbackSOFT),
     DECL(alGetPointerSOFT),
     DECL(alGetPointervSOFT),
+
+    DECL(alBufferCallbackSOFT),
+    DECL(alGetBufferPtrSOFT),
+    DECL(alGetBuffer3PtrSOFT),
+    DECL(alGetBufferPtrvSOFT),
+
+    DECL(alAuxiliaryEffectSlotPlaySOFT),
+    DECL(alAuxiliaryEffectSlotPlayvSOFT),
+    DECL(alAuxiliaryEffectSlotStopSOFT),
+    DECL(alAuxiliaryEffectSlotStopvSOFT),
+
+    DECL(alSourcePlayAtTimeSOFT),
+    DECL(alSourcePlayAtTimevSOFT),
+
+    DECL(alBufferSubDataSOFT),
+
+    DECL(alBufferDataStatic),
+#ifdef ALSOFT_EAX
+}, eaxFunctions[] = {
+    DECL(EAXGet),
+    DECL(EAXSet),
+    DECL(EAXGetBufferMode),
+    DECL(EAXSetBufferMode),
+#endif
 };
 #undef DECL
 
@@ -470,6 +543,21 @@ constexpr struct {
 
     DECL(ALC_OUTPUT_LIMITER_SOFT),
 
+    DECL(ALC_DEVICE_CLOCK_SOFT),
+    DECL(ALC_DEVICE_LATENCY_SOFT),
+    DECL(ALC_DEVICE_CLOCK_LATENCY_SOFT),
+    DECL(AL_SAMPLE_OFFSET_CLOCK_SOFT),
+    DECL(AL_SEC_OFFSET_CLOCK_SOFT),
+
+    DECL(ALC_OUTPUT_MODE_SOFT),
+    DECL(ALC_ANY_SOFT),
+    DECL(ALC_STEREO_BASIC_SOFT),
+    DECL(ALC_STEREO_UHJ_SOFT),
+    DECL(ALC_STEREO_HRTF_SOFT),
+    DECL(ALC_SURROUND_5_1_SOFT),
+    DECL(ALC_SURROUND_6_1_SOFT),
+    DECL(ALC_SURROUND_7_1_SOFT),
+
     DECL(ALC_NO_ERROR),
     DECL(ALC_INVALID_DEVICE),
     DECL(ALC_INVALID_CONTEXT),
@@ -588,6 +676,9 @@ constexpr struct {
 
     DECL(AL_SOURCE_RADIUS),
 
+    DECL(AL_SAMPLE_OFFSET_LATENCY_SOFT),
+    DECL(AL_SEC_OFFSET_LATENCY_SOFT),
+
     DECL(AL_STEREO_ANGLES),
 
     DECL(AL_UNUSED),
@@ -762,6 +853,8 @@ constexpr struct {
     DECL(AL_VOCAL_MORPHER_WAVEFORM),
     DECL(AL_VOCAL_MORPHER_RATE),
 
+    DECL(AL_EFFECTSLOT_TARGET_SOFT),
+
     DECL(AL_NUM_RESAMPLERS_SOFT),
     DECL(AL_DEFAULT_RESAMPLER_SOFT),
     DECL(AL_SOURCE_RESAMPLER_SOFT),
@@ -779,9 +872,59 @@ constexpr struct {
     DECL(AL_EVENT_CALLBACK_USER_PARAM_SOFT),
     DECL(AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT),
     DECL(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT),
-    DECL(AL_EVENT_TYPE_ERROR_SOFT),
-    DECL(AL_EVENT_TYPE_PERFORMANCE_SOFT),
-    DECL(AL_EVENT_TYPE_DEPRECATED_SOFT),
+    DECL(AL_EVENT_TYPE_DISCONNECTED_SOFT),
+
+    DECL(AL_DROP_UNMATCHED_SOFT),
+    DECL(AL_REMIX_UNMATCHED_SOFT),
+
+    DECL(AL_AMBISONIC_LAYOUT_SOFT),
+    DECL(AL_AMBISONIC_SCALING_SOFT),
+    DECL(AL_FUMA_SOFT),
+    DECL(AL_ACN_SOFT),
+    DECL(AL_SN3D_SOFT),
+    DECL(AL_N3D_SOFT),
+
+    DECL(AL_BUFFER_CALLBACK_FUNCTION_SOFT),
+    DECL(AL_BUFFER_CALLBACK_USER_PARAM_SOFT),
+
+    DECL(AL_UNPACK_AMBISONIC_ORDER_SOFT),
+
+    DECL(AL_EFFECT_CONVOLUTION_REVERB_SOFT),
+    DECL(AL_EFFECTSLOT_STATE_SOFT),
+
+    DECL(AL_FORMAT_UHJ2CHN8_SOFT),
+    DECL(AL_FORMAT_UHJ2CHN16_SOFT),
+    DECL(AL_FORMAT_UHJ2CHN_FLOAT32_SOFT),
+    DECL(AL_FORMAT_UHJ3CHN8_SOFT),
+    DECL(AL_FORMAT_UHJ3CHN16_SOFT),
+    DECL(AL_FORMAT_UHJ3CHN_FLOAT32_SOFT),
+    DECL(AL_FORMAT_UHJ4CHN8_SOFT),
+    DECL(AL_FORMAT_UHJ4CHN16_SOFT),
+    DECL(AL_FORMAT_UHJ4CHN_FLOAT32_SOFT),
+    DECL(AL_STEREO_MODE_SOFT),
+    DECL(AL_NORMAL_SOFT),
+    DECL(AL_SUPER_STEREO_SOFT),
+    DECL(AL_SUPER_STEREO_WIDTH_SOFT),
+
+    DECL(AL_FORMAT_UHJ2CHN_MULAW_SOFT),
+    DECL(AL_FORMAT_UHJ2CHN_ALAW_SOFT),
+    DECL(AL_FORMAT_UHJ2CHN_IMA4_SOFT),
+    DECL(AL_FORMAT_UHJ2CHN_MSADPCM_SOFT),
+    DECL(AL_FORMAT_UHJ3CHN_MULAW_SOFT),
+    DECL(AL_FORMAT_UHJ3CHN_ALAW_SOFT),
+    DECL(AL_FORMAT_UHJ4CHN_MULAW_SOFT),
+    DECL(AL_FORMAT_UHJ4CHN_ALAW_SOFT),
+
+    DECL(AL_STOP_SOURCES_ON_DISCONNECT_SOFT),
+
+#ifdef ALSOFT_EAX
+}, eaxEnumerations[] = {
+    DECL(AL_EAX_RAM_SIZE),
+    DECL(AL_EAX_RAM_FREE),
+    DECL(AL_STORAGE_AUTOMATIC),
+    DECL(AL_STORAGE_HARDWARE),
+    DECL(AL_STORAGE_ACCESSIBLE),
+#endif // ALSOFT_EAX
 };
 #undef DECL
 
@@ -804,82 +947,24 @@ std::string alcAllDevicesList;
 std::string alcCaptureDeviceList;
 
 /* Default is always the first in the list */
-al::string alcDefaultAllDevicesSpecifier;
-al::string alcCaptureDefaultDeviceSpecifier;
-
-/* Default context extensions */
-constexpr ALchar alExtList[] =
-    "AL_EXT_ALAW "
-    "AL_EXT_BFORMAT "
-    "AL_EXT_DOUBLE "
-    "AL_EXT_EXPONENT_DISTANCE "
-    "AL_EXT_FLOAT32 "
-    "AL_EXT_IMA4 "
-    "AL_EXT_LINEAR_DISTANCE "
-    "AL_EXT_MCFORMATS "
-    "AL_EXT_MULAW "
-    "AL_EXT_MULAW_BFORMAT "
-    "AL_EXT_MULAW_MCFORMATS "
-    "AL_EXT_OFFSET "
-    "AL_EXT_source_distance_model "
-    "AL_EXT_SOURCE_RADIUS "
-    "AL_EXT_STEREO_ANGLES "
-    "AL_LOKI_quadriphonic "
-    "AL_SOFT_block_alignment "
-    "AL_SOFT_deferred_updates "
-    "AL_SOFT_direct_channels "
-    "AL_SOFTX_effect_chain "
-    "AL_SOFTX_events "
-    "AL_SOFTX_filter_gain_ex "
-    "AL_SOFT_gain_clamp_ex "
-    "AL_SOFT_loop_points "
-    "AL_SOFTX_map_buffer "
-    "AL_SOFT_MSADPCM "
-    "AL_SOFT_source_latency "
-    "AL_SOFT_source_length "
-    "AL_SOFT_source_resampler "
-    "AL_SOFT_source_spatialize";
+std::string alcDefaultAllDevicesSpecifier;
+std::string alcCaptureDefaultDeviceSpecifier;
 
 std::atomic<ALCenum> LastNullDeviceError{ALC_NO_ERROR};
 
-/* Thread-local current context */
-class ThreadCtx {
-    ALCcontext *ctx{nullptr};
-
-public:
-    ~ThreadCtx()
-    {
-        if(ctx)
-        {
-            const bool result{ctx->releaseIfNoDelete()};
-            ERR("Context %p current for thread being destroyed%s!\n",
-                decltype(std::declval<void*>()){ctx}, result ? "" : ", leak detected");
-        }
-    }
-
-    ALCcontext *get() const noexcept { return ctx; }
-    void set(ALCcontext *ctx_) noexcept { ctx = ctx_; }
-};
-thread_local ThreadCtx LocalContext;
-/* Process-wide current context */
-std::atomic<ALCcontext*> GlobalContext{nullptr};
-
 /* Flag to trap ALC device errors */
 bool TrapALCError{false};
 
 /* One-time configuration init control */
 std::once_flag alc_config_once{};
 
-/* Default effect that applies to sources that don't have an effect on send 0 */
-ALeffect DefaultEffect;
-
 /* Flag to specify if alcSuspendContext/alcProcessContext should defer/process
  * updates.
  */
 bool SuspendDefers{true};
 
 /* Initial seed for dithering. */
-constexpr ALuint DitherRNGSeed{22222u};
+constexpr uint DitherRNGSeed{22222u};
 
 
 /************************************************
@@ -889,8 +974,11 @@ constexpr ALCchar alcNoDeviceExtList[] =
     "ALC_ENUMERATE_ALL_EXT "
     "ALC_ENUMERATION_EXT "
     "ALC_EXT_CAPTURE "
+    "ALC_EXT_EFX "
     "ALC_EXT_thread_local_context "
-    "ALC_SOFT_loopback";
+    "ALC_SOFT_loopback "
+    "ALC_SOFT_loopback_bformat "
+    "ALC_SOFT_reopen_device";
 constexpr ALCchar alcExtensionList[] =
     "ALC_ENUMERATE_ALL_EXT "
     "ALC_ENUMERATION_EXT "
@@ -902,23 +990,16 @@ constexpr ALCchar alcExtensionList[] =
     "ALC_SOFT_device_clock "
     "ALC_SOFT_HRTF "
     "ALC_SOFT_loopback "
+    "ALC_SOFT_loopback_bformat "
     "ALC_SOFT_output_limiter "
-    "ALC_SOFT_pause_device";
-constexpr ALCint alcMajorVersion = 1;
-constexpr ALCint alcMinorVersion = 1;
+    "ALC_SOFT_output_mode "
+    "ALC_SOFT_pause_device "
+    "ALC_SOFT_reopen_device";
+constexpr int alcMajorVersion{1};
+constexpr int alcMinorVersion{1};
 
-constexpr ALCint alcEFXMajorVersion = 1;
-constexpr ALCint alcEFXMinorVersion = 0;
-
-
-/* To avoid extraneous allocations, a 0-sized FlexArray<ALCcontext*> is defined
- * globally as a sharable object. MSVC warns that a zero-sized array will have
- * zero objects here, so silence that.
- */
-DIAGNOSTIC_PUSH
-msc_pragma(warning(disable : 4815))
-al::FlexArray<ALCcontext*> EmptyContextArray{0u};
-DIAGNOSTIC_POP
+constexpr int alcEFXMajorVersion{1};
+constexpr int alcEFXMinorVersion{0};
 
 
 using DeviceRef = al::intrusive_ptr<ALCdevice>;
@@ -927,8 +1008,8 @@ using DeviceRef = al::intrusive_ptr<ALCdevice>;
 /************************************************
  * Device lists
  ************************************************/
-al::vector<DeviceRef> DeviceList;
-al::vector<ContextRef> ContextList;
+al::vector<ALCdevice*> DeviceList;
+al::vector<ALCcontext*> ContextList;
 
 std::recursive_mutex ListLock;
 
@@ -938,33 +1019,45 @@ void alc_initconfig(void)
     if(auto loglevel = al::getenv("ALSOFT_LOGLEVEL"))
     {
         long lvl = strtol(loglevel->c_str(), nullptr, 0);
-        if(lvl >= NoLog && lvl <= LogRef)
+        if(lvl >= static_cast<long>(LogLevel::Trace))
+            gLogLevel = LogLevel::Trace;
+        else if(lvl <= static_cast<long>(LogLevel::Disable))
+            gLogLevel = LogLevel::Disable;
+        else
             gLogLevel = static_cast<LogLevel>(lvl);
     }
 
-    if(auto logfile = al::getenv("ALSOFT_LOGFILE"))
-    {
 #ifdef _WIN32
-        std::wstring wname{utf8_to_wstr(logfile->c_str())};
-        FILE *logf{_wfopen(wname.c_str(), L"wt")};
+    if(const auto logfile = al::getenv(L"ALSOFT_LOGFILE"))
+    {
+        FILE *logf{_wfopen(logfile->c_str(), L"wt")};
+        if(logf) gLogFile = logf;
+        else
+        {
+            auto u8name = wstr_to_utf8(logfile->c_str());
+            ERR("Failed to open log file '%s'\n", u8name.c_str());
+        }
+    }
 #else
+    if(const auto logfile = al::getenv("ALSOFT_LOGFILE"))
+    {
         FILE *logf{fopen(logfile->c_str(), "wt")};
-#endif
         if(logf) gLogFile = logf;
         else ERR("Failed to open log file '%s'\n", logfile->c_str());
     }
+#endif
 
     TRACE("Initializing library v%s-%s %s\n", ALSOFT_VERSION, ALSOFT_GIT_COMMIT_HASH,
         ALSOFT_GIT_BRANCH);
     {
-        al::string names;
-        if(std::begin(BackendList) == BackendListEnd)
-            names += "(none)";
+        std::string names;
+        if(al::size(BackendList) < 1)
+            names = "(none)";
         else
         {
-            const al::span<const BackendInfo> infos{std::begin(BackendList), BackendListEnd};
-            names += infos[0].name;
-            for(const auto &backend : infos.subspan(1))
+            const al::span<const BackendInfo> infos{BackendList};
+            names = infos[0].name;
+            for(const auto &backend : infos.subspan<1>())
             {
                 names += ", ";
                 names += backend.name;
@@ -1033,18 +1126,79 @@ void alc_initconfig(void)
             } while(next++);
         }
     }
-    FillCPUCaps(capfilter);
+    if(auto cpuopt = GetCPUInfo())
+    {
+        if(!cpuopt->mVendor.empty() || !cpuopt->mName.empty())
+        {
+            TRACE("Vendor ID: \"%s\"\n", cpuopt->mVendor.c_str());
+            TRACE("Name: \"%s\"\n", cpuopt->mName.c_str());
+        }
+        const int caps{cpuopt->mCaps};
+        TRACE("Extensions:%s%s%s%s%s%s\n",
+            ((capfilter&CPU_CAP_SSE)    ? ((caps&CPU_CAP_SSE)    ? " +SSE"    : " -SSE")    : ""),
+            ((capfilter&CPU_CAP_SSE2)   ? ((caps&CPU_CAP_SSE2)   ? " +SSE2"   : " -SSE2")   : ""),
+            ((capfilter&CPU_CAP_SSE3)   ? ((caps&CPU_CAP_SSE3)   ? " +SSE3"   : " -SSE3")   : ""),
+            ((capfilter&CPU_CAP_SSE4_1) ? ((caps&CPU_CAP_SSE4_1) ? " +SSE4.1" : " -SSE4.1") : ""),
+            ((capfilter&CPU_CAP_NEON)   ? ((caps&CPU_CAP_NEON)   ? " +NEON"   : " -NEON")   : ""),
+            ((!capfilter) ? " -none-" : ""));
+        CPUCapFlags = caps & capfilter;
+    }
 
-#ifdef _WIN32
-#define DEF_MIXER_PRIO 1
-#else
-#define DEF_MIXER_PRIO 0
-#endif
-    RTPrioLevel = ConfigValueInt(nullptr, nullptr, "rt-prio").value_or(DEF_MIXER_PRIO);
-#undef DEF_MIXER_PRIO
+    if(auto priopt = ConfigValueInt(nullptr, nullptr, "rt-prio"))
+        RTPrioLevel = *priopt;
+    if(auto limopt = ConfigValueBool(nullptr, nullptr, "rt-time-limit"))
+        AllowRTTimeLimit = *limopt;
 
-    aluInit();
-    aluInitMixer();
+    {
+        CompatFlagBitset compatflags{};
+        auto checkflag = [](const char *envname, const char *optname) -> bool
+        {
+            if(auto optval = al::getenv(envname))
+            {
+                if(al::strcasecmp(optval->c_str(), "true") == 0
+                    || strtol(optval->c_str(), nullptr, 0) == 1)
+                    return true;
+                return false;
+            }
+            return GetConfigValueBool(nullptr, "game_compat", optname, false);
+        };
+        sBufferSubDataCompat = checkflag("__ALSOFT_ENABLE_SUB_DATA_EXT", "enable-sub-data-ext");
+        compatflags.set(CompatFlags::ReverseX, checkflag("__ALSOFT_REVERSE_X", "reverse-x"));
+        compatflags.set(CompatFlags::ReverseY, checkflag("__ALSOFT_REVERSE_Y", "reverse-y"));
+        compatflags.set(CompatFlags::ReverseZ, checkflag("__ALSOFT_REVERSE_Z", "reverse-z"));
+
+        aluInit(compatflags, ConfigValueFloat(nullptr, "game_compat", "nfc-scale").value_or(1.0f));
+    }
+    Voice::InitMixer(ConfigValueStr(nullptr, nullptr, "resampler"));
+
+    auto uhjfiltopt = ConfigValueStr(nullptr, "uhj", "decode-filter");
+    if(!uhjfiltopt)
+    {
+        if((uhjfiltopt = ConfigValueStr(nullptr, "uhj", "filter")))
+            WARN("uhj/filter is deprecated, please use uhj/decode-filter\n");
+    }
+    if(uhjfiltopt)
+    {
+        if(al::strcasecmp(uhjfiltopt->c_str(), "fir256") == 0)
+            UhjDecodeQuality = UhjQualityType::FIR256;
+        else if(al::strcasecmp(uhjfiltopt->c_str(), "fir512") == 0)
+            UhjDecodeQuality = UhjQualityType::FIR512;
+        else if(al::strcasecmp(uhjfiltopt->c_str(), "iir") == 0)
+            UhjDecodeQuality = UhjQualityType::IIR;
+        else
+            WARN("Unsupported uhj/decode-filter: %s\n", uhjfiltopt->c_str());
+    }
+    if((uhjfiltopt = ConfigValueStr(nullptr, "uhj", "encode-filter")))
+    {
+        if(al::strcasecmp(uhjfiltopt->c_str(), "fir256") == 0)
+            UhjEncodeQuality = UhjQualityType::FIR256;
+        else if(al::strcasecmp(uhjfiltopt->c_str(), "fir512") == 0)
+            UhjEncodeQuality = UhjQualityType::FIR512;
+        else if(al::strcasecmp(uhjfiltopt->c_str(), "iir") == 0)
+            UhjEncodeQuality = UhjQualityType::IIR;
+        else
+            WARN("Unsupported uhj/encode-filter: %s\n", uhjfiltopt->c_str());
+    }
 
     auto traperr = al::getenv("ALSOFT_TRAP_ERROR");
     if(traperr && (al::strcasecmp(traperr->c_str(), "true") == 0
@@ -1076,6 +1230,7 @@ void alc_initconfig(void)
         ReverbBoost *= std::pow(10.0f, valf / 20.0f);
     }
 
+    auto BackendListEnd = std::end(BackendList);
     auto devopt = al::getenv("ALSOFT_DRIVERS");
     if(devopt || (devopt=ConfigValueStr(nullptr, nullptr, "drivers")))
     {
@@ -1130,16 +1285,16 @@ void alc_initconfig(void)
             BackendListEnd = backendlist_cur;
     }
 
-    auto init_backend = [](BackendInfo &backend) -> bool
+    auto init_backend = [](BackendInfo &backend) -> void
     {
         if(PlaybackFactory && CaptureFactory)
-            return true;
+            return;
 
         BackendFactory &factory = backend.getFactory();
         if(!factory.init())
         {
             WARN("Failed to initialize backend \"%s\"\n", backend.name);
-            return true;
+            return;
         }
 
         TRACE("Initialized backend \"%s\"\n", backend.name);
@@ -1153,9 +1308,8 @@ void alc_initconfig(void)
             CaptureFactory = &factory;
             TRACE("Added \"%s\" for capture\n", backend.name);
         }
-        return false;
     };
-    BackendListEnd = std::remove_if(std::begin(BackendList), BackendListEnd, init_backend);
+    std::for_each(std::begin(BackendList), BackendListEnd, init_backend);
 
     LoopbackBackendFactory::getFactory().init();
 
@@ -1179,17 +1333,44 @@ void alc_initconfig(void)
             {
                 if(len == strlen(effectitem.name) &&
                    strncmp(effectitem.name, str, len) == 0)
-                    DisabledEffects[effectitem.type] = AL_TRUE;
+                    DisabledEffects[effectitem.type] = true;
             }
         } while(next++);
     }
 
-    InitEffect(&DefaultEffect);
+    InitEffect(&ALCcontext::sDefaultEffect);
     auto defrevopt = al::getenv("ALSOFT_DEFAULT_REVERB");
     if(defrevopt || (defrevopt=ConfigValueStr(nullptr, nullptr, "default-reverb")))
-        LoadReverbPreset(defrevopt->c_str(), &DefaultEffect);
+        LoadReverbPreset(defrevopt->c_str(), &ALCcontext::sDefaultEffect);
+
+#ifdef ALSOFT_EAX
+    {
+        static constexpr char eax_block_name[] = "eax";
+
+        if(const auto eax_enable_opt = ConfigValueBool(nullptr, eax_block_name, "enable"))
+        {
+            eax_g_is_enabled = *eax_enable_opt;
+            if(!eax_g_is_enabled)
+                TRACE("%s\n", "EAX disabled by a configuration.");
+        }
+        else
+            eax_g_is_enabled = true;
+
+        if((DisabledEffects[EAXREVERB_EFFECT] || DisabledEffects[CHORUS_EFFECT])
+            && eax_g_is_enabled)
+        {
+            eax_g_is_enabled = false;
+            TRACE("EAX disabled because %s disabled.\n",
+                (DisabledEffects[EAXREVERB_EFFECT] && DisabledEffects[CHORUS_EFFECT])
+                    ? "EAXReverb and Chorus are" :
+                DisabledEffects[EAXREVERB_EFFECT] ? "EAXReverb is" :
+                DisabledEffects[CHORUS_EFFECT] ? "Chorus is" : "");
+        }
+    }
+#endif // ALSOFT_EAX
 }
-#define DO_INITCONFIG() std::call_once(alc_config_once, [](){alc_initconfig();})
+inline void InitConfig()
+{ std::call_once(alc_config_once, [](){alc_initconfig();}); }
 
 
 /************************************************
@@ -1197,118 +1378,36 @@ void alc_initconfig(void)
  ************************************************/
 void ProbeAllDevicesList()
 {
-    DO_INITCONFIG();
+    InitConfig();
 
     std::lock_guard<std::recursive_mutex> _{ListLock};
-    alcAllDevicesList.clear();
-    if(PlaybackFactory)
-        PlaybackFactory->probe(DevProbe::Playback, &alcAllDevicesList);
+    if(!PlaybackFactory)
+        decltype(alcAllDevicesList){}.swap(alcAllDevicesList);
+    else
+    {
+        std::string names{PlaybackFactory->probe(BackendType::Playback)};
+        if(names.empty()) names += '\0';
+        names.swap(alcAllDevicesList);
+    }
 }
 void ProbeCaptureDeviceList()
 {
-    DO_INITCONFIG();
+    InitConfig();
 
     std::lock_guard<std::recursive_mutex> _{ListLock};
-    alcCaptureDeviceList.clear();
-    if(CaptureFactory)
-        CaptureFactory->probe(DevProbe::Capture, &alcCaptureDeviceList);
-}
-
-} // namespace
-
-/* Mixing thread piority level */
-ALint RTPrioLevel;
-
-FILE *gLogFile{stderr};
-#ifdef _DEBUG
-LogLevel gLogLevel{LogWarning};
-#else
-LogLevel gLogLevel{LogError};
-#endif
-
-/************************************************
- * Library initialization
- ************************************************/
-#if defined(_WIN32) && !defined(AL_LIBTYPE_STATIC)
-BOOL APIENTRY DllMain(HINSTANCE module, DWORD reason, LPVOID /*reserved*/)
-{
-    switch(reason)
-    {
-    case DLL_PROCESS_ATTACH:
-        /* Pin the DLL so we won't get unloaded until the process terminates */
-        GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-            reinterpret_cast<WCHAR*>(module), &module);
-        break;
-    }
-    return TRUE;
-}
-#endif
-
-/************************************************
- * Device format information
- ************************************************/
-const ALCchar *DevFmtTypeString(DevFmtType type) noexcept
-{
-    switch(type)
-    {
-    case DevFmtByte: return "Signed Byte";
-    case DevFmtUByte: return "Unsigned Byte";
-    case DevFmtShort: return "Signed Short";
-    case DevFmtUShort: return "Unsigned Short";
-    case DevFmtInt: return "Signed Int";
-    case DevFmtUInt: return "Unsigned Int";
-    case DevFmtFloat: return "Float";
-    }
-    return "(unknown type)";
-}
-const ALCchar *DevFmtChannelsString(DevFmtChannels chans) noexcept
-{
-    switch(chans)
+    if(!CaptureFactory)
+        decltype(alcCaptureDeviceList){}.swap(alcCaptureDeviceList);
+    else
     {
-    case DevFmtMono: return "Mono";
-    case DevFmtStereo: return "Stereo";
-    case DevFmtQuad: return "Quadraphonic";
-    case DevFmtX51: return "5.1 Surround";
-    case DevFmtX51Rear: return "5.1 Surround (Rear)";
-    case DevFmtX61: return "6.1 Surround";
-    case DevFmtX71: return "7.1 Surround";
-    case DevFmtAmbi3D: return "Ambisonic 3D";
+        std::string names{CaptureFactory->probe(BackendType::Capture)};
+        if(names.empty()) names += '\0';
+        names.swap(alcCaptureDeviceList);
     }
-    return "(unknown channels)";
 }
 
-ALuint BytesFromDevFmt(DevFmtType type) noexcept
-{
-    switch(type)
-    {
-    case DevFmtByte: return sizeof(ALbyte);
-    case DevFmtUByte: return sizeof(ALubyte);
-    case DevFmtShort: return sizeof(ALshort);
-    case DevFmtUShort: return sizeof(ALushort);
-    case DevFmtInt: return sizeof(ALint);
-    case DevFmtUInt: return sizeof(ALuint);
-    case DevFmtFloat: return sizeof(ALfloat);
-    }
-    return 0;
-}
-ALuint ChannelsFromDevFmt(DevFmtChannels chans, ALuint ambiorder) noexcept
-{
-    switch(chans)
-    {
-    case DevFmtMono: return 1;
-    case DevFmtStereo: return 2;
-    case DevFmtQuad: return 4;
-    case DevFmtX51: return 6;
-    case DevFmtX51Rear: return 6;
-    case DevFmtX61: return 7;
-    case DevFmtX71: return 8;
-    case DevFmtAmbi3D: return (ambiorder+1) * (ambiorder+1);
-    }
-    return 0;
-}
 
 struct DevFmtPair { DevFmtChannels chans; DevFmtType type; };
-static al::optional<DevFmtPair> DecomposeDevFormat(ALenum format)
+al::optional<DevFmtPair> DecomposeDevFormat(ALenum format)
 {
     static const struct {
         ALenum format;
@@ -1343,236 +1442,191 @@ static al::optional<DevFmtPair> DecomposeDevFormat(ALenum format)
     for(const auto &item : list)
     {
         if(item.format == format)
-            return al::make_optional(DevFmtPair{item.channels, item.type});
+            return al::make_optional<DevFmtPair>({item.channels, item.type});
     }
 
     return al::nullopt;
 }
 
-static ALCboolean IsValidALCType(ALCenum type)
+al::optional<DevFmtType> DevFmtTypeFromEnum(ALCenum type)
 {
     switch(type)
     {
-        case ALC_BYTE_SOFT:
-        case ALC_UNSIGNED_BYTE_SOFT:
-        case ALC_SHORT_SOFT:
-        case ALC_UNSIGNED_SHORT_SOFT:
-        case ALC_INT_SOFT:
-        case ALC_UNSIGNED_INT_SOFT:
-        case ALC_FLOAT_SOFT:
-            return ALC_TRUE;
+    case ALC_BYTE_SOFT: return DevFmtByte;
+    case ALC_UNSIGNED_BYTE_SOFT: return DevFmtUByte;
+    case ALC_SHORT_SOFT: return DevFmtShort;
+    case ALC_UNSIGNED_SHORT_SOFT: return DevFmtUShort;
+    case ALC_INT_SOFT: return DevFmtInt;
+    case ALC_UNSIGNED_INT_SOFT: return DevFmtUInt;
+    case ALC_FLOAT_SOFT: return DevFmtFloat;
     }
-    return ALC_FALSE;
+    WARN("Unsupported format type: 0x%04x\n", type);
+    return al::nullopt;
+}
+ALCenum EnumFromDevFmt(DevFmtType type)
+{
+    switch(type)
+    {
+    case DevFmtByte: return ALC_BYTE_SOFT;
+    case DevFmtUByte: return ALC_UNSIGNED_BYTE_SOFT;
+    case DevFmtShort: return ALC_SHORT_SOFT;
+    case DevFmtUShort: return ALC_UNSIGNED_SHORT_SOFT;
+    case DevFmtInt: return ALC_INT_SOFT;
+    case DevFmtUInt: return ALC_UNSIGNED_INT_SOFT;
+    case DevFmtFloat: return ALC_FLOAT_SOFT;
+    }
+    throw std::runtime_error{"Invalid DevFmtType: "+std::to_string(int(type))};
 }
 
-static ALCboolean IsValidALCChannels(ALCenum channels)
+al::optional<DevFmtChannels> DevFmtChannelsFromEnum(ALCenum channels)
 {
     switch(channels)
     {
-        case ALC_MONO_SOFT:
-        case ALC_STEREO_SOFT:
-        case ALC_QUAD_SOFT:
-        case ALC_5POINT1_SOFT:
-        case ALC_6POINT1_SOFT:
-        case ALC_7POINT1_SOFT:
-        case ALC_BFORMAT3D_SOFT:
-            return ALC_TRUE;
+    case ALC_MONO_SOFT: return DevFmtMono;
+    case ALC_STEREO_SOFT: return DevFmtStereo;
+    case ALC_QUAD_SOFT: return DevFmtQuad;
+    case ALC_5POINT1_SOFT: return DevFmtX51;
+    case ALC_6POINT1_SOFT: return DevFmtX61;
+    case ALC_7POINT1_SOFT: return DevFmtX71;
+    case ALC_BFORMAT3D_SOFT: return DevFmtAmbi3D;
     }
-    return ALC_FALSE;
+    WARN("Unsupported format channels: 0x%04x\n", channels);
+    return al::nullopt;
 }
-
-static ALCboolean IsValidAmbiLayout(ALCenum layout)
+ALCenum EnumFromDevFmt(DevFmtChannels channels)
 {
-    switch(layout)
+    switch(channels)
     {
-        case ALC_ACN_SOFT:
-        case ALC_FUMA_SOFT:
-            return ALC_TRUE;
+    case DevFmtMono: return ALC_MONO_SOFT;
+    case DevFmtStereo: return ALC_STEREO_SOFT;
+    case DevFmtQuad: return ALC_QUAD_SOFT;
+    case DevFmtX51: return ALC_5POINT1_SOFT;
+    case DevFmtX61: return ALC_6POINT1_SOFT;
+    case DevFmtX71: return ALC_7POINT1_SOFT;
+    case DevFmtAmbi3D: return ALC_BFORMAT3D_SOFT;
+    /* FIXME: Shouldn't happen. */
+    case DevFmtX714:
+    case DevFmtX3D71: break;
     }
-    return ALC_FALSE;
+    throw std::runtime_error{"Invalid DevFmtChannels: "+std::to_string(int(channels))};
 }
 
-static ALCboolean IsValidAmbiScaling(ALCenum scaling)
+al::optional<DevAmbiLayout> DevAmbiLayoutFromEnum(ALCenum layout)
 {
-    switch(scaling)
+    switch(layout)
     {
-        case ALC_N3D_SOFT:
-        case ALC_SN3D_SOFT:
-        case ALC_FUMA_SOFT:
-            return ALC_TRUE;
+    case ALC_FUMA_SOFT: return DevAmbiLayout::FuMa;
+    case ALC_ACN_SOFT: return DevAmbiLayout::ACN;
     }
-    return ALC_FALSE;
+    WARN("Unsupported ambisonic layout: 0x%04x\n", layout);
+    return al::nullopt;
 }
-
-/************************************************
- * Miscellaneous ALC helpers
- ************************************************/
-
-/* SetDefaultWFXChannelOrder
- *
- * Sets the default channel order used by WaveFormatEx.
- */
-void SetDefaultWFXChannelOrder(ALCdevice *device)
+ALCenum EnumFromDevAmbi(DevAmbiLayout layout)
 {
-    device->RealOut.ChannelIndex.fill(INVALID_CHANNEL_INDEX);
-
-    switch(device->FmtChans)
+    switch(layout)
     {
-    case DevFmtMono:
-        device->RealOut.ChannelIndex[FrontCenter] = 0;
-        break;
-    case DevFmtStereo:
-        device->RealOut.ChannelIndex[FrontLeft]  = 0;
-        device->RealOut.ChannelIndex[FrontRight] = 1;
-        break;
-    case DevFmtQuad:
-        device->RealOut.ChannelIndex[FrontLeft]  = 0;
-        device->RealOut.ChannelIndex[FrontRight] = 1;
-        device->RealOut.ChannelIndex[BackLeft]   = 2;
-        device->RealOut.ChannelIndex[BackRight]  = 3;
-        break;
-    case DevFmtX51:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[FrontCenter] = 2;
-        device->RealOut.ChannelIndex[LFE]         = 3;
-        device->RealOut.ChannelIndex[SideLeft]    = 4;
-        device->RealOut.ChannelIndex[SideRight]   = 5;
-        break;
-    case DevFmtX51Rear:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[FrontCenter] = 2;
-        device->RealOut.ChannelIndex[LFE]         = 3;
-        device->RealOut.ChannelIndex[BackLeft]    = 4;
-        device->RealOut.ChannelIndex[BackRight]   = 5;
-        break;
-    case DevFmtX61:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[FrontCenter] = 2;
-        device->RealOut.ChannelIndex[LFE]         = 3;
-        device->RealOut.ChannelIndex[BackCenter]  = 4;
-        device->RealOut.ChannelIndex[SideLeft]    = 5;
-        device->RealOut.ChannelIndex[SideRight]   = 6;
-        break;
-    case DevFmtX71:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[FrontCenter] = 2;
-        device->RealOut.ChannelIndex[LFE]         = 3;
-        device->RealOut.ChannelIndex[BackLeft]    = 4;
-        device->RealOut.ChannelIndex[BackRight]   = 5;
-        device->RealOut.ChannelIndex[SideLeft]    = 6;
-        device->RealOut.ChannelIndex[SideRight]   = 7;
-        break;
-    case DevFmtAmbi3D:
-        device->RealOut.ChannelIndex[Aux0] = 0;
-        if(device->mAmbiOrder > 0)
-        {
-            device->RealOut.ChannelIndex[Aux1] = 1;
-            device->RealOut.ChannelIndex[Aux2] = 2;
-            device->RealOut.ChannelIndex[Aux3] = 3;
-        }
-        if(device->mAmbiOrder > 1)
-        {
-            device->RealOut.ChannelIndex[Aux4] = 4;
-            device->RealOut.ChannelIndex[Aux5] = 5;
-            device->RealOut.ChannelIndex[Aux6] = 6;
-            device->RealOut.ChannelIndex[Aux7] = 7;
-            device->RealOut.ChannelIndex[Aux8] = 8;
-        }
-        if(device->mAmbiOrder > 2)
-        {
-            device->RealOut.ChannelIndex[Aux9]  = 9;
-            device->RealOut.ChannelIndex[Aux10] = 10;
-            device->RealOut.ChannelIndex[Aux11] = 11;
-            device->RealOut.ChannelIndex[Aux12] = 12;
-            device->RealOut.ChannelIndex[Aux13] = 13;
-            device->RealOut.ChannelIndex[Aux14] = 14;
-            device->RealOut.ChannelIndex[Aux15] = 15;
-        }
-        break;
+    case DevAmbiLayout::FuMa: return ALC_FUMA_SOFT;
+    case DevAmbiLayout::ACN: return ALC_ACN_SOFT;
     }
+    throw std::runtime_error{"Invalid DevAmbiLayout: "+std::to_string(int(layout))};
 }
 
-/* SetDefaultChannelOrder
- *
- * Sets the default channel order used by most non-WaveFormatEx-based APIs.
- */
-void SetDefaultChannelOrder(ALCdevice *device)
+al::optional<DevAmbiScaling> DevAmbiScalingFromEnum(ALCenum scaling)
 {
-    device->RealOut.ChannelIndex.fill(INVALID_CHANNEL_INDEX);
-
-    switch(device->FmtChans)
+    switch(scaling)
     {
-    case DevFmtX51Rear:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[BackLeft]    = 2;
-        device->RealOut.ChannelIndex[BackRight]   = 3;
-        device->RealOut.ChannelIndex[FrontCenter] = 4;
-        device->RealOut.ChannelIndex[LFE]         = 5;
-        return;
-    case DevFmtX71:
-        device->RealOut.ChannelIndex[FrontLeft]   = 0;
-        device->RealOut.ChannelIndex[FrontRight]  = 1;
-        device->RealOut.ChannelIndex[BackLeft]    = 2;
-        device->RealOut.ChannelIndex[BackRight]   = 3;
-        device->RealOut.ChannelIndex[FrontCenter] = 4;
-        device->RealOut.ChannelIndex[LFE]         = 5;
-        device->RealOut.ChannelIndex[SideLeft]    = 6;
-        device->RealOut.ChannelIndex[SideRight]   = 7;
-        return;
-
-    /* Same as WFX order */
-    case DevFmtMono:
-    case DevFmtStereo:
-    case DevFmtQuad:
-    case DevFmtX51:
-    case DevFmtX61:
-    case DevFmtAmbi3D:
-        SetDefaultWFXChannelOrder(device);
-        break;
+    case ALC_FUMA_SOFT: return DevAmbiScaling::FuMa;
+    case ALC_SN3D_SOFT: return DevAmbiScaling::SN3D;
+    case ALC_N3D_SOFT: return DevAmbiScaling::N3D;
     }
+    WARN("Unsupported ambisonic scaling: 0x%04x\n", scaling);
+    return al::nullopt;
 }
-
-
-void ALCcontext::processUpdates()
+ALCenum EnumFromDevAmbi(DevAmbiScaling scaling)
 {
-    std::lock_guard<std::mutex> _{mPropLock};
-    if(mDeferUpdates.exchange(false))
+    switch(scaling)
     {
-        /* Tell the mixer to stop applying updates, then wait for any active
-         * updating to finish, before providing updates.
-         */
-        mHoldUpdates.store(true, std::memory_order_release);
-        while((mUpdateCount.load(std::memory_order_acquire)&1) != 0)
-            std::this_thread::yield();
-
-        if(!mPropsClean.test_and_set(std::memory_order_acq_rel))
-            UpdateContextProps(this);
-        if(!mListener.PropsClean.test_and_set(std::memory_order_acq_rel))
-            UpdateListenerProps(this);
-        UpdateAllEffectSlotProps(this);
-        UpdateAllSourceProps(this);
-
-        /* Now with all updates declared, let the mixer continue applying them
-         * so they all happen at once.
-         */
-        mHoldUpdates.store(false, std::memory_order_release);
+    case DevAmbiScaling::FuMa: return ALC_FUMA_SOFT;
+    case DevAmbiScaling::SN3D: return ALC_SN3D_SOFT;
+    case DevAmbiScaling::N3D: return ALC_N3D_SOFT;
     }
+    throw std::runtime_error{"Invalid DevAmbiScaling: "+std::to_string(int(scaling))};
 }
 
 
-/* alcSetError
- *
- * Stores the latest ALC device error
+/* Downmixing channel arrays, to map the given format's missing channels to
+ * existing ones. Based on Wine's DSound downmix values, which are based on
+ * PulseAudio's.
  */
-static void alcSetError(ALCdevice *device, ALCenum errorCode)
+constexpr std::array<InputRemixMap::TargetMix,2> FrontStereoSplit{{
+    {FrontLeft, 0.5f}, {FrontRight, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,1> FrontLeft9{{
+    {FrontLeft, 1.0f/9.0f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,1> FrontRight9{{
+    {FrontRight, 1.0f/9.0f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> BackMonoToFrontSplit{{
+    {FrontLeft, 0.5f/9.0f}, {FrontRight, 0.5f/9.0f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> LeftStereoSplit{{
+    {FrontLeft, 0.5f}, {BackLeft, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> RightStereoSplit{{
+    {FrontRight, 0.5f}, {BackRight, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> BackStereoSplit{{
+    {BackLeft, 0.5f}, {BackRight, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> SideStereoSplit{{
+    {SideLeft, 0.5f}, {SideRight, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,1> ToSideLeft{{
+    {SideLeft, 1.0f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,1> ToSideRight{{
+    {SideRight, 1.0f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> BackLeftSplit{{
+    {SideLeft, 0.5f}, {BackCenter, 0.5f}
+}};
+constexpr std::array<InputRemixMap::TargetMix,2> BackRightSplit{{
+    {SideRight, 0.5f}, {BackCenter, 0.5f}
+}};
+
+const std::array<InputRemixMap,6> StereoDownmix{{
+    { FrontCenter, FrontStereoSplit },
+    { SideLeft,    FrontLeft9 },
+    { SideRight,   FrontRight9 },
+    { BackLeft,    FrontLeft9 },
+    { BackRight,   FrontRight9 },
+    { BackCenter,  BackMonoToFrontSplit },
+}};
+const std::array<InputRemixMap,4> QuadDownmix{{
+    { FrontCenter, FrontStereoSplit },
+    { SideLeft,    LeftStereoSplit },
+    { SideRight,   RightStereoSplit },
+    { BackCenter,  BackStereoSplit },
+}};
+const std::array<InputRemixMap,3> X51Downmix{{
+    { BackLeft,   ToSideLeft },
+    { BackRight,  ToSideRight },
+    { BackCenter, SideStereoSplit },
+}};
+const std::array<InputRemixMap,2> X61Downmix{{
+    { BackLeft,  BackLeftSplit },
+    { BackRight, BackRightSplit },
+}};
+const std::array<InputRemixMap,1> X71Downmix{{
+    { BackCenter, BackStereoSplit },
+}};
+
+
+/** Stores the latest ALC device error. */
+void alcSetError(ALCdevice *device, ALCenum errorCode)
 {
-    WARN("Error generated on device %p, code 0x%04x\n", decltype(std::declval<void*>()){device},
-        errorCode);
+    WARN("Error generated on device %p, code 0x%04x\n", voidp{device}, errorCode);
     if(TrapALCError)
     {
 #ifdef _WIN32
@@ -1591,21 +1645,34 @@ static void alcSetError(ALCdevice *device, ALCenum errorCode)
 }
 
 
-static std::unique_ptr<Compressor> CreateDeviceLimiter(const ALCdevice *device, const ALfloat threshold)
+std::unique_ptr<Compressor> CreateDeviceLimiter(const ALCdevice *device, const float threshold)
 {
-    return CompressorInit(static_cast<ALuint>(device->RealOut.Buffer.size()),
-        static_cast<float>(device->Frequency), AL_TRUE, AL_TRUE, AL_TRUE, AL_TRUE, AL_TRUE, 0.001f,
-        0.002f, 0.0f, 0.0f, threshold, INFINITY, 0.0f, 0.020f, 0.200f);
+    static constexpr bool AutoKnee{true};
+    static constexpr bool AutoAttack{true};
+    static constexpr bool AutoRelease{true};
+    static constexpr bool AutoPostGain{true};
+    static constexpr bool AutoDeclip{true};
+    static constexpr float LookAheadTime{0.001f};
+    static constexpr float HoldTime{0.002f};
+    static constexpr float PreGainDb{0.0f};
+    static constexpr float PostGainDb{0.0f};
+    static constexpr float Ratio{std::numeric_limits<float>::infinity()};
+    static constexpr float KneeDb{0.0f};
+    static constexpr float AttackTime{0.02f};
+    static constexpr float ReleaseTime{0.2f};
+
+    return Compressor::Create(device->RealOut.Buffer.size(), static_cast<float>(device->Frequency),
+        AutoKnee, AutoAttack, AutoRelease, AutoPostGain, AutoDeclip, LookAheadTime, HoldTime,
+        PreGainDb, PostGainDb, threshold, Ratio, KneeDb, AttackTime, ReleaseTime);
 }
 
-/* UpdateClockBase
- *
+/**
  * Updates the device's base clock time with however many samples have been
  * done. This is used so frequency changes on the device don't cause the time
  * to jump forward or back. Must not be called while the device is running/
  * mixing.
  */
-static inline void UpdateClockBase(ALCdevice *device)
+inline void UpdateClockBase(ALCdevice *device)
 {
     IncrementRef(device->MixCount);
     device->ClockBase += nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
@@ -1613,117 +1680,248 @@ static inline void UpdateClockBase(ALCdevice *device)
     IncrementRef(device->MixCount);
 }
 
-/* UpdateDeviceParams
- *
+/**
  * Updates device parameters according to the attribute list (caller is
  * responsible for holding the list lock).
  */
-static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
+ALCenum UpdateDeviceParams(ALCdevice *device, const int *attrList)
 {
-    HrtfRequestMode hrtf_userreq{Hrtf_Default};
-    HrtfRequestMode hrtf_appreq{Hrtf_Default};
-    ALCenum gainLimiter{device->LimiterState};
-    const ALCuint old_sends{device->NumAuxSends};
-    ALCuint new_sends{device->NumAuxSends};
-    DevFmtChannels oldChans;
-    DevFmtType oldType;
-    ALboolean update_failed;
-    ALCsizei hrtf_id{-1};
-    ALCuint oldFreq;
-
-    if((!attrList || !attrList[0]) && device->Type == Loopback)
+    if((!attrList || !attrList[0]) && device->Type == DeviceType::Loopback)
     {
         WARN("Missing attributes for loopback device\n");
         return ALC_INVALID_VALUE;
     }
 
-    // Check for attributes
+    uint numMono{device->NumMonoSources};
+    uint numStereo{device->NumStereoSources};
+    uint numSends{device->NumAuxSends};
+    al::optional<StereoEncoding> stereomode;
+    al::optional<bool> optlimit;
+    al::optional<uint> optsrate;
+    al::optional<DevFmtChannels> optchans;
+    al::optional<DevFmtType> opttype;
+    al::optional<DevAmbiLayout> optlayout;
+    al::optional<DevAmbiScaling> optscale;
+    uint period_size{DEFAULT_UPDATE_SIZE};
+    uint buffer_size{DEFAULT_UPDATE_SIZE * DEFAULT_NUM_UPDATES};
+    int hrtf_id{-1};
+    uint aorder{0u};
+
+    if(device->Type != DeviceType::Loopback)
+    {
+        /* Get default settings from the user configuration */
+
+        if(auto freqopt = device->configValue<uint>(nullptr, "frequency"))
+        {
+            optsrate = clampu(*freqopt, MIN_OUTPUT_RATE, MAX_OUTPUT_RATE);
+
+            const double scale{static_cast<double>(*optsrate) / DEFAULT_OUTPUT_RATE};
+            period_size = static_cast<uint>(period_size*scale + 0.5);
+        }
+
+        if(auto persizeopt = device->configValue<uint>(nullptr, "period_size"))
+            period_size = clampu(*persizeopt, 64, 8192);
+        if(auto numperopt = device->configValue<uint>(nullptr, "periods"))
+            buffer_size = clampu(*numperopt, 2, 16) * period_size;
+        else
+            buffer_size = period_size * DEFAULT_NUM_UPDATES;
+
+        if(auto typeopt = device->configValue<std::string>(nullptr, "sample-type"))
+        {
+            static constexpr struct TypeMap {
+                const char name[8];
+                DevFmtType type;
+            } typelist[] = {
+                { "int8",    DevFmtByte   },
+                { "uint8",   DevFmtUByte  },
+                { "int16",   DevFmtShort  },
+                { "uint16",  DevFmtUShort },
+                { "int32",   DevFmtInt    },
+                { "uint32",  DevFmtUInt   },
+                { "float32", DevFmtFloat  },
+            };
+
+            const ALCchar *fmt{typeopt->c_str()};
+            auto iter = std::find_if(std::begin(typelist), std::end(typelist),
+                [fmt](const TypeMap &entry) -> bool
+                { return al::strcasecmp(entry.name, fmt) == 0; });
+            if(iter == std::end(typelist))
+                ERR("Unsupported sample-type: %s\n", fmt);
+            else
+                opttype = iter->type;
+        }
+        if(auto chanopt = device->configValue<std::string>(nullptr, "channels"))
+        {
+            static constexpr struct ChannelMap {
+                const char name[16];
+                DevFmtChannels chans;
+                uint8_t order;
+            } chanlist[] = {
+                { "mono",       DevFmtMono,   0 },
+                { "stereo",     DevFmtStereo, 0 },
+                { "quad",       DevFmtQuad,   0 },
+                { "surround51", DevFmtX51,    0 },
+                { "surround61", DevFmtX61,    0 },
+                { "surround71", DevFmtX71,    0 },
+                { "surround714", DevFmtX714,  0 },
+                { "surround3d71", DevFmtX3D71, 0 },
+                { "surround51rear", DevFmtX51, 0 },
+                { "ambi1", DevFmtAmbi3D, 1 },
+                { "ambi2", DevFmtAmbi3D, 2 },
+                { "ambi3", DevFmtAmbi3D, 3 },
+            };
+
+            const ALCchar *fmt{chanopt->c_str()};
+            auto iter = std::find_if(std::begin(chanlist), std::end(chanlist),
+                [fmt](const ChannelMap &entry) -> bool
+                { return al::strcasecmp(entry.name, fmt) == 0; });
+            if(iter == std::end(chanlist))
+                ERR("Unsupported channels: %s\n", fmt);
+            else
+            {
+                optchans = iter->chans;
+                aorder = iter->order;
+            }
+        }
+        if(auto ambiopt = device->configValue<std::string>(nullptr, "ambi-format"))
+        {
+            const ALCchar *fmt{ambiopt->c_str()};
+            if(al::strcasecmp(fmt, "fuma") == 0)
+            {
+                optlayout = DevAmbiLayout::FuMa;
+                optscale = DevAmbiScaling::FuMa;
+            }
+            else if(al::strcasecmp(fmt, "acn+fuma") == 0)
+            {
+                optlayout = DevAmbiLayout::ACN;
+                optscale = DevAmbiScaling::FuMa;
+            }
+            else if(al::strcasecmp(fmt, "ambix") == 0 || al::strcasecmp(fmt, "acn+sn3d") == 0)
+            {
+                optlayout = DevAmbiLayout::ACN;
+                optscale = DevAmbiScaling::SN3D;
+            }
+            else if(al::strcasecmp(fmt, "acn+n3d") == 0)
+            {
+                optlayout = DevAmbiLayout::ACN;
+                optscale = DevAmbiScaling::N3D;
+            }
+            else
+                ERR("Unsupported ambi-format: %s\n", fmt);
+        }
+
+        if(auto hrtfopt = device->configValue<std::string>(nullptr, "hrtf"))
+        {
+            WARN("general/hrtf is deprecated, please use stereo-encoding instead\n");
+
+            const char *hrtf{hrtfopt->c_str()};
+            if(al::strcasecmp(hrtf, "true") == 0)
+                stereomode = StereoEncoding::Hrtf;
+            else if(al::strcasecmp(hrtf, "false") == 0)
+            {
+                if(!stereomode || *stereomode == StereoEncoding::Hrtf)
+                    stereomode = StereoEncoding::Default;
+            }
+            else if(al::strcasecmp(hrtf, "auto") != 0)
+                ERR("Unexpected hrtf value: %s\n", hrtf);
+        }
+    }
+
+    if(auto encopt = device->configValue<std::string>(nullptr, "stereo-encoding"))
+    {
+        const char *mode{encopt->c_str()};
+        if(al::strcasecmp(mode, "basic") == 0 || al::strcasecmp(mode, "panpot") == 0)
+            stereomode = StereoEncoding::Basic;
+        else if(al::strcasecmp(mode, "uhj") == 0)
+            stereomode = StereoEncoding::Uhj;
+        else if(al::strcasecmp(mode, "hrtf") == 0)
+            stereomode = StereoEncoding::Hrtf;
+        else
+            ERR("Unexpected stereo-encoding: %s\n", mode);
+    }
+
+    // Check for app-specified attributes
     if(attrList && attrList[0])
     {
-        ALCenum alayout{AL_NONE};
-        ALCenum ascale{AL_NONE};
-        ALCenum schans{AL_NONE};
-        ALCenum stype{AL_NONE};
-        ALCsizei attrIdx{0};
-        ALCuint aorder{0};
-        ALCuint freq{0u};
-
-        ALuint numMono{device->NumMonoSources};
-        ALuint numStereo{device->NumStereoSources};
-        ALuint numSends{old_sends};
-
-#define TRACE_ATTR(a, v) TRACE("%s = %d\n", #a, v)
+        ALenum outmode{ALC_ANY_SOFT};
+        al::optional<bool> opthrtf;
+        int freqAttr{};
+
+#define ATTRIBUTE(a) a: TRACE("%s = %d\n", #a, attrList[attrIdx + 1]);
+        size_t attrIdx{0};
         while(attrList[attrIdx])
         {
             switch(attrList[attrIdx])
             {
-            case ALC_FORMAT_CHANNELS_SOFT:
-                schans = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_FORMAT_CHANNELS_SOFT, schans);
+            case ATTRIBUTE(ALC_FORMAT_CHANNELS_SOFT)
+                if(device->Type == DeviceType::Loopback)
+                    optchans = DevFmtChannelsFromEnum(attrList[attrIdx + 1]);
                 break;
 
-            case ALC_FORMAT_TYPE_SOFT:
-                stype = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_FORMAT_TYPE_SOFT, stype);
+            case ATTRIBUTE(ALC_FORMAT_TYPE_SOFT)
+                if(device->Type == DeviceType::Loopback)
+                    opttype = DevFmtTypeFromEnum(attrList[attrIdx + 1]);
                 break;
 
-            case ALC_FREQUENCY:
-                freq = static_cast<ALuint>(attrList[attrIdx + 1]);
-                TRACE_ATTR(ALC_FREQUENCY, freq);
+            case ATTRIBUTE(ALC_FREQUENCY)
+                freqAttr = attrList[attrIdx + 1];
                 break;
 
-            case ALC_AMBISONIC_LAYOUT_SOFT:
-                alayout = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_AMBISONIC_LAYOUT_SOFT, alayout);
+            case ATTRIBUTE(ALC_AMBISONIC_LAYOUT_SOFT)
+                if(device->Type == DeviceType::Loopback)
+                    optlayout = DevAmbiLayoutFromEnum(attrList[attrIdx + 1]);
                 break;
 
-            case ALC_AMBISONIC_SCALING_SOFT:
-                ascale = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_AMBISONIC_SCALING_SOFT, ascale);
+            case ATTRIBUTE(ALC_AMBISONIC_SCALING_SOFT)
+                if(device->Type == DeviceType::Loopback)
+                    optscale = DevAmbiScalingFromEnum(attrList[attrIdx + 1]);
                 break;
 
-            case ALC_AMBISONIC_ORDER_SOFT:
-                aorder = static_cast<ALuint>(attrList[attrIdx + 1]);
-                TRACE_ATTR(ALC_AMBISONIC_ORDER_SOFT, aorder);
+            case ATTRIBUTE(ALC_AMBISONIC_ORDER_SOFT)
+                if(device->Type == DeviceType::Loopback)
+                    aorder = static_cast<uint>(attrList[attrIdx + 1]);
                 break;
 
-            case ALC_MONO_SOURCES:
-                numMono = static_cast<ALuint>(attrList[attrIdx + 1]);
-                TRACE_ATTR(ALC_MONO_SOURCES, numMono);
+            case ATTRIBUTE(ALC_MONO_SOURCES)
+                numMono = static_cast<uint>(attrList[attrIdx + 1]);
                 if(numMono > INT_MAX) numMono = 0;
                 break;
 
-            case ALC_STEREO_SOURCES:
-                numStereo = static_cast<ALuint>(attrList[attrIdx + 1]);
-                TRACE_ATTR(ALC_STEREO_SOURCES, numStereo);
+            case ATTRIBUTE(ALC_STEREO_SOURCES)
+                numStereo = static_cast<uint>(attrList[attrIdx + 1]);
                 if(numStereo > INT_MAX) numStereo = 0;
                 break;
 
-            case ALC_MAX_AUXILIARY_SENDS:
-                numSends = static_cast<ALuint>(attrList[attrIdx + 1]);
-                TRACE_ATTR(ALC_MAX_AUXILIARY_SENDS, numSends);
+            case ATTRIBUTE(ALC_MAX_AUXILIARY_SENDS)
+                numSends = static_cast<uint>(attrList[attrIdx + 1]);
                 if(numSends > INT_MAX) numSends = 0;
                 else numSends = minu(numSends, MAX_SENDS);
                 break;
 
-            case ALC_HRTF_SOFT:
-                TRACE_ATTR(ALC_HRTF_SOFT, attrList[attrIdx + 1]);
+            case ATTRIBUTE(ALC_HRTF_SOFT)
                 if(attrList[attrIdx + 1] == ALC_FALSE)
-                    hrtf_appreq = Hrtf_Disable;
+                    opthrtf = false;
                 else if(attrList[attrIdx + 1] == ALC_TRUE)
-                    hrtf_appreq = Hrtf_Enable;
-                else
-                    hrtf_appreq = Hrtf_Default;
+                    opthrtf = true;
+                else if(attrList[attrIdx + 1] == ALC_DONT_CARE_SOFT)
+                    opthrtf = al::nullopt;
                 break;
 
-            case ALC_HRTF_ID_SOFT:
+            case ATTRIBUTE(ALC_HRTF_ID_SOFT)
                 hrtf_id = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
                 break;
 
-            case ALC_OUTPUT_LIMITER_SOFT:
-                gainLimiter = attrList[attrIdx + 1];
-                TRACE_ATTR(ALC_OUTPUT_LIMITER_SOFT, gainLimiter);
+            case ATTRIBUTE(ALC_OUTPUT_LIMITER_SOFT)
+                if(attrList[attrIdx + 1] == ALC_FALSE)
+                    optlimit = false;
+                else if(attrList[attrIdx + 1] == ALC_TRUE)
+                    optlimit = true;
+                else if(attrList[attrIdx + 1] == ALC_DONT_CARE_SOFT)
+                    optlimit = al::nullopt;
+                break;
+
+            case ATTRIBUTE(ALC_OUTPUT_MODE_SOFT)
+                outmode = attrList[attrIdx + 1];
                 break;
 
             default:
@@ -1734,131 +1932,129 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
 
             attrIdx += 2;
         }
-#undef TRACE_ATTR
+#undef ATTRIBUTE
 
-        const bool loopback{device->Type == Loopback};
-        if(loopback)
+        if(device->Type == DeviceType::Loopback)
         {
-            if(!schans || !stype || !freq)
-            {
-                WARN("Missing format for loopback device\n");
+            if(!optchans || !opttype)
                 return ALC_INVALID_VALUE;
-            }
-            if(!IsValidALCChannels(schans) || !IsValidALCType(stype) || freq < MIN_OUTPUT_RATE)
+            if(freqAttr < MIN_OUTPUT_RATE || freqAttr > MAX_OUTPUT_RATE)
                 return ALC_INVALID_VALUE;
-            if(schans == ALC_BFORMAT3D_SOFT)
+            if(*optchans == DevFmtAmbi3D)
             {
-                if(!alayout || !ascale || !aorder)
-                {
-                    WARN("Missing ambisonic info for loopback device\n");
+                if(!optlayout || !optscale)
                     return ALC_INVALID_VALUE;
-                }
-                if(!IsValidAmbiLayout(alayout) || !IsValidAmbiScaling(ascale))
+                if(aorder < 1 || aorder > MaxAmbiOrder)
                     return ALC_INVALID_VALUE;
-                if(aorder < 1 || aorder > MAX_AMBI_ORDER)
-                    return ALC_INVALID_VALUE;
-                if((alayout == ALC_FUMA_SOFT || ascale == ALC_FUMA_SOFT) && aorder > 3)
+                if((*optlayout == DevAmbiLayout::FuMa || *optscale == DevAmbiScaling::FuMa)
+                    && aorder > 3)
                     return ALC_INVALID_VALUE;
             }
-        }
-
-        /* If a context is already running on the device, stop playback so the
-         * device attributes can be updated.
-         */
-        if(device->Flags.get<DeviceRunning>())
-            device->Backend->stop();
-        device->Flags.unset<DeviceRunning>();
-
-        UpdateClockBase(device);
-
-        const char *devname{nullptr};
-        if(!loopback)
-        {
-            devname = device->DeviceName.c_str();
-
-            device->BufferSize = DEFAULT_UPDATE_SIZE * DEFAULT_NUM_UPDATES;
-            device->UpdateSize = DEFAULT_UPDATE_SIZE;
-            device->Frequency = DEFAULT_OUTPUT_RATE;
-
-            freq = ConfigValueUInt(devname, nullptr, "frequency").value_or(freq);
-            if(freq < 1)
-                device->Flags.unset<FrequencyRequest>();
-            else
+            else if(*optchans == DevFmtStereo)
             {
-                freq = maxu(freq, MIN_OUTPUT_RATE);
-
-                device->UpdateSize = (device->UpdateSize*freq + device->Frequency/2) /
-                    device->Frequency;
-                device->BufferSize = (device->BufferSize*freq + device->Frequency/2) /
-                    device->Frequency;
+                if(opthrtf)
+                {
+                    if(*opthrtf)
+                        stereomode = StereoEncoding::Hrtf;
+                    else
+                    {
+                        if(stereomode.value_or(StereoEncoding::Hrtf) == StereoEncoding::Hrtf)
+                            stereomode = StereoEncoding::Default;
+                    }
+                }
 
-                device->Frequency = freq;
-                device->Flags.set<FrequencyRequest>();
+                if(outmode == ALC_STEREO_BASIC_SOFT)
+                    stereomode = StereoEncoding::Basic;
+                else if(outmode == ALC_STEREO_UHJ_SOFT)
+                    stereomode = StereoEncoding::Uhj;
+                else if(outmode == ALC_STEREO_HRTF_SOFT)
+                    stereomode = StereoEncoding::Hrtf;
             }
 
-            if(auto persizeopt = ConfigValueUInt(devname, nullptr, "period_size"))
-                device->UpdateSize = clampu(*persizeopt, 64, 8192);
-
-            if(auto peropt = ConfigValueUInt(devname, nullptr, "periods"))
-                device->BufferSize = device->UpdateSize * clampu(*peropt, 2, 16);
-            else
-                device->BufferSize = maxu(device->BufferSize, device->UpdateSize*2);
+            optsrate = static_cast<uint>(freqAttr);
         }
         else
         {
-            device->Frequency = freq;
-            device->FmtChans = static_cast<DevFmtChannels>(schans);
-            device->FmtType = static_cast<DevFmtType>(stype);
-            if(schans == ALC_BFORMAT3D_SOFT)
+            if(opthrtf)
             {
-                device->mAmbiOrder = aorder;
-                device->mAmbiLayout = static_cast<AmbiLayout>(alayout);
-                device->mAmbiScale = static_cast<AmbiNorm>(ascale);
+                if(*opthrtf)
+                    stereomode = StereoEncoding::Hrtf;
+                else
+                {
+                    if(stereomode.value_or(StereoEncoding::Hrtf) == StereoEncoding::Hrtf)
+                        stereomode = StereoEncoding::Default;
+                }
             }
-        }
 
-        if(numMono > INT_MAX-numStereo)
-            numMono = INT_MAX-numStereo;
-        numMono += numStereo;
-        if(auto srcsopt = ConfigValueUInt(devname, nullptr, "sources"))
-        {
-            if(*srcsopt <= 0) numMono = 256;
-            else numMono = *srcsopt;
+            if(outmode != ALC_ANY_SOFT)
+            {
+                using OutputMode = ALCdevice::OutputMode;
+                switch(OutputMode(outmode))
+                {
+                case OutputMode::Any: break;
+                case OutputMode::Mono: optchans = DevFmtMono; break;
+                case OutputMode::Stereo: optchans = DevFmtStereo; break;
+                case OutputMode::StereoBasic:
+                    optchans = DevFmtStereo;
+                    stereomode = StereoEncoding::Basic;
+                    break;
+                case OutputMode::Uhj2:
+                    optchans = DevFmtStereo;
+                    stereomode = StereoEncoding::Uhj;
+                    break;
+                case OutputMode::Hrtf:
+                    optchans = DevFmtStereo;
+                    stereomode = StereoEncoding::Hrtf;
+                    break;
+                case OutputMode::Quad: optchans = DevFmtQuad; break;
+                case OutputMode::X51: optchans = DevFmtX51; break;
+                case OutputMode::X61: optchans = DevFmtX61; break;
+                case OutputMode::X71: optchans = DevFmtX71; break;
+                }
+            }
+
+            if(freqAttr)
+            {
+                uint oldrate = optsrate.value_or(DEFAULT_OUTPUT_RATE);
+                freqAttr = clampi(freqAttr, MIN_OUTPUT_RATE, MAX_OUTPUT_RATE);
+
+                const double scale{static_cast<double>(freqAttr) / oldrate};
+                period_size = static_cast<uint>(period_size*scale + 0.5);
+                buffer_size = static_cast<uint>(buffer_size*scale + 0.5);
+                optsrate = static_cast<uint>(freqAttr);
+            }
         }
-        else
-            numMono = maxu(numMono, 256);
-        numStereo = minu(numStereo, numMono);
-        numMono -= numStereo;
-        device->SourcesMax = numMono + numStereo;
 
-        device->NumMonoSources = numMono;
-        device->NumStereoSources = numStereo;
+        /* If a context is already running on the device, stop playback so the
+         * device attributes can be updated.
+         */
+        if(device->Flags.test(DeviceRunning))
+            device->Backend->stop();
+        device->Flags.reset(DeviceRunning);
 
-        if(auto sendsopt = ConfigValueInt(devname, nullptr, "sends"))
-            new_sends = minu(numSends, static_cast<ALuint>(clampi(*sendsopt, 0, MAX_SENDS)));
-        else
-            new_sends = numSends;
+        UpdateClockBase(device);
     }
 
-    if(device->Flags.get<DeviceRunning>())
+    if(device->Flags.test(DeviceRunning))
         return ALC_NO_ERROR;
 
     device->AvgSpeakerDist = 0.0f;
-    device->Uhj_Encoder = nullptr;
+    device->mNFCtrlFilter = NfcFilter{};
+    device->mUhjEncoder = nullptr;
     device->AmbiDecoder = nullptr;
     device->Bs2b = nullptr;
     device->PostProcess = nullptr;
 
-    device->Stablizer = nullptr;
     device->Limiter = nullptr;
-    device->ChannelDelay.clear();
+    device->ChannelDelays = nullptr;
 
     std::fill(std::begin(device->HrtfAccumData), std::end(device->HrtfAccumData), float2{});
 
     device->Dry.AmbiMap.fill(BFChannelConfig{});
     device->Dry.Buffer = {};
     std::fill(std::begin(device->NumChannelsPerOrder), std::end(device->NumChannelsPerOrder), 0u);
-    device->RealOut.ChannelIndex.fill(INVALID_CHANNEL_INDEX);
+    device->RealOut.RemixMap = {};
+    device->RealOut.ChannelIndex.fill(InvalidChannelIndex);
     device->RealOut.Buffer = {};
     device->MixBuffer.clear();
     device->MixBuffer.shrink_to_fit();
@@ -1869,166 +2065,188 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
     device->DitherDepth = 0.0f;
     device->DitherSeed = DitherRNGSeed;
 
+    device->mHrtfStatus = ALC_HRTF_DISABLED_SOFT;
+
     /*************************************************************************
-     * Update device format request if HRTF is requested
+     * Update device format request
      */
-    device->HrtfStatus = ALC_HRTF_DISABLED_SOFT;
-    if(device->Type != Loopback)
+
+    if(device->Type == DeviceType::Loopback)
     {
-        if(auto hrtfopt = ConfigValueStr(device->DeviceName.c_str(), nullptr, "hrtf"))
+        device->Frequency = *optsrate;
+        device->FmtChans = *optchans;
+        device->FmtType = *opttype;
+        if(device->FmtChans == DevFmtAmbi3D)
         {
-            const char *hrtf{hrtfopt->c_str()};
-            if(al::strcasecmp(hrtf, "true") == 0)
-                hrtf_userreq = Hrtf_Enable;
-            else if(al::strcasecmp(hrtf, "false") == 0)
-                hrtf_userreq = Hrtf_Disable;
-            else if(al::strcasecmp(hrtf, "auto") != 0)
-                ERR("Unexpected hrtf value: %s\n", hrtf);
+            device->mAmbiOrder = aorder;
+            device->mAmbiLayout = *optlayout;
+            device->mAmbiScale = *optscale;
         }
-
-        if(hrtf_userreq == Hrtf_Enable || (hrtf_userreq != Hrtf_Disable && hrtf_appreq == Hrtf_Enable))
+        device->Flags.set(FrequencyRequest).set(ChannelsRequest).set(SampleTypeRequest);
+    }
+    else
+    {
+        device->FmtType = opttype.value_or(DevFmtTypeDefault);
+        device->FmtChans = optchans.value_or(DevFmtChannelsDefault);
+        device->mAmbiOrder = 0;
+        device->BufferSize = buffer_size;
+        device->UpdateSize = period_size;
+        device->Frequency = optsrate.value_or(DEFAULT_OUTPUT_RATE);
+        device->Flags.set(FrequencyRequest, optsrate.has_value())
+            .set(ChannelsRequest, optchans.has_value())
+            .set(SampleTypeRequest, opttype.has_value());
+
+        if(device->FmtChans == DevFmtAmbi3D)
         {
-            HrtfEntry *hrtf{nullptr};
-            if(device->HrtfList.empty())
-                device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
-            if(!device->HrtfList.empty())
-            {
-                if(hrtf_id >= 0 && static_cast<ALuint>(hrtf_id) < device->HrtfList.size())
-                    hrtf = GetLoadedHrtf(device->HrtfList[static_cast<ALuint>(hrtf_id)].hrtf);
-                else
-                    hrtf = GetLoadedHrtf(device->HrtfList.front().hrtf);
-            }
-
-            if(hrtf)
-            {
-                device->FmtChans = DevFmtStereo;
-                device->Frequency = hrtf->sampleRate;
-                device->Flags.set<ChannelsRequest, FrequencyRequest>();
-                if(HrtfEntry *oldhrtf{device->mHrtf})
-                    oldhrtf->DecRef();
-                device->mHrtf = hrtf;
-            }
-            else
+            device->mAmbiOrder = clampu(aorder, 1, MaxAmbiOrder);
+            device->mAmbiLayout = optlayout.value_or(DevAmbiLayout::Default);
+            device->mAmbiScale = optscale.value_or(DevAmbiScaling::Default);
+            if(device->mAmbiOrder > 3
+                && (device->mAmbiLayout == DevAmbiLayout::FuMa
+                    || device->mAmbiScale == DevAmbiScaling::FuMa))
             {
-                hrtf_userreq = Hrtf_Default;
-                hrtf_appreq = Hrtf_Disable;
-                device->HrtfStatus = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
+                ERR("FuMa is incompatible with %d%s order ambisonics (up to 3rd order only)\n",
+                    device->mAmbiOrder,
+                    (((device->mAmbiOrder%100)/10) == 1) ? "th" :
+                    ((device->mAmbiOrder%10) == 1) ? "st" :
+                    ((device->mAmbiOrder%10) == 2) ? "nd" :
+                    ((device->mAmbiOrder%10) == 3) ? "rd" : "th");
+                device->mAmbiOrder = 3;
             }
         }
     }
 
-    oldFreq  = device->Frequency;
-    oldChans = device->FmtChans;
-    oldType  = device->FmtType;
-
     TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u / %u buffer\n",
-        device->Flags.get<ChannelsRequest>()?"*":"", DevFmtChannelsString(device->FmtChans),
-        device->Flags.get<SampleTypeRequest>()?"*":"", DevFmtTypeString(device->FmtType),
-        device->Flags.get<FrequencyRequest>()?"*":"", device->Frequency,
+        device->Flags.test(ChannelsRequest)?"*":"", DevFmtChannelsString(device->FmtChans),
+        device->Flags.test(SampleTypeRequest)?"*":"", DevFmtTypeString(device->FmtType),
+        device->Flags.test(FrequencyRequest)?"*":"", device->Frequency,
         device->UpdateSize, device->BufferSize);
 
+    const uint oldFreq{device->Frequency};
+    const DevFmtChannels oldChans{device->FmtChans};
+    const DevFmtType oldType{device->FmtType};
     try {
-        if(device->Backend->reset() == false)
-            return ALC_INVALID_DEVICE;
+        auto backend = device->Backend.get();
+        if(!backend->reset())
+            throw al::backend_exception{al::backend_error::DeviceError, "Device reset failure"};
     }
     catch(std::exception &e) {
-        ERR("Device reset failed: %s\n", e.what());
+        ERR("Device error: %s\n", e.what());
+        device->handleDisconnect("%s", e.what());
         return ALC_INVALID_DEVICE;
     }
 
-    if(device->FmtChans != oldChans && device->Flags.get<ChannelsRequest>())
+    if(device->FmtChans != oldChans && device->Flags.test(ChannelsRequest))
     {
         ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
             DevFmtChannelsString(device->FmtChans));
-        device->Flags.unset<ChannelsRequest>();
+        device->Flags.reset(ChannelsRequest);
     }
-    if(device->FmtType != oldType && device->Flags.get<SampleTypeRequest>())
+    if(device->FmtType != oldType && device->Flags.test(SampleTypeRequest))
     {
         ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
             DevFmtTypeString(device->FmtType));
-        device->Flags.unset<SampleTypeRequest>();
+        device->Flags.reset(SampleTypeRequest);
     }
-    if(device->Frequency != oldFreq && device->Flags.get<FrequencyRequest>())
+    if(device->Frequency != oldFreq && device->Flags.test(FrequencyRequest))
     {
         WARN("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
-        device->Flags.unset<FrequencyRequest>();
+        device->Flags.reset(FrequencyRequest);
     }
 
     TRACE("Post-reset: %s, %s, %uhz, %u / %u buffer\n",
         DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
         device->Frequency, device->UpdateSize, device->BufferSize);
 
-    aluInitRenderer(device, hrtf_id, hrtf_appreq, hrtf_userreq);
+    if(device->Type != DeviceType::Loopback)
+    {
+        if(auto modeopt = device->configValue<std::string>(nullptr, "stereo-mode"))
+        {
+            const char *mode{modeopt->c_str()};
+            if(al::strcasecmp(mode, "headphones") == 0)
+                device->Flags.set(DirectEar);
+            else if(al::strcasecmp(mode, "speakers") == 0)
+                device->Flags.reset(DirectEar);
+            else if(al::strcasecmp(mode, "auto") != 0)
+                ERR("Unexpected stereo-mode: %s\n", mode);
+        }
+    }
+
+    aluInitRenderer(device, hrtf_id, stereomode);
+
+    /* Calculate the max number of sources, and split them between the mono and
+     * stereo count given the requested number of stereo sources.
+     */
+    if(auto srcsopt = device->configValue<uint>(nullptr, "sources"))
+    {
+        if(*srcsopt <= 0) numMono = 256;
+        else numMono = maxu(*srcsopt, 16);
+    }
+    else
+    {
+        numMono = minu(numMono, INT_MAX-numStereo);
+        numMono = maxu(numMono+numStereo, 256);
+    }
+    numStereo = minu(numStereo, numMono);
+    numMono -= numStereo;
+    device->SourcesMax = numMono + numStereo;
+    device->NumMonoSources = numMono;
+    device->NumStereoSources = numStereo;
+
+    if(auto sendsopt = device->configValue<int>(nullptr, "sends"))
+        numSends = minu(numSends, static_cast<uint>(clampi(*sendsopt, 0, MAX_SENDS)));
+    device->NumAuxSends = numSends;
 
-    device->NumAuxSends = new_sends;
     TRACE("Max sources: %d (%d + %d), effect slots: %d, sends: %d\n",
         device->SourcesMax, device->NumMonoSources, device->NumStereoSources,
         device->AuxiliaryEffectSlotMax, device->NumAuxSends);
 
-    /* Enable the stablizer only for formats that have front-left, front-right,
-     * and front-center outputs.
-     */
     switch(device->FmtChans)
     {
-    case DevFmtX51:
-    case DevFmtX51Rear:
-    case DevFmtX61:
-    case DevFmtX71:
-        if(GetConfigValueBool(device->DeviceName.c_str(), nullptr, "front-stablizer", 0))
-        {
-            auto stablizer = al::make_unique<FrontStablizer>();
-            /* Initialize band-splitting filters for the front-left and front-
-             * right channels, with a crossover at 5khz (could be higher).
-             */
-            const ALfloat scale{5000.0f / static_cast<ALfloat>(device->Frequency)};
-
-            stablizer->LFilter.init(scale);
-            stablizer->RFilter = stablizer->LFilter;
-
-            device->Stablizer = std::move(stablizer);
-            /* NOTE: Don't know why this has to be "copied" into a local static
-             * constexpr variable to avoid a reference on
-             * FrontStablizer::DelayLength...
-             */
-            constexpr size_t StablizerDelay{FrontStablizer::DelayLength};
-            device->FixedLatency += nanoseconds{seconds{StablizerDelay}} / device->Frequency;
-        }
-        break;
-    case DevFmtMono:
+    case DevFmtMono: break;
     case DevFmtStereo:
-    case DevFmtQuad:
-    case DevFmtAmbi3D:
+        if(!device->mUhjEncoder)
+            device->RealOut.RemixMap = StereoDownmix;
         break;
+    case DevFmtQuad: device->RealOut.RemixMap = QuadDownmix; break;
+    case DevFmtX51: device->RealOut.RemixMap = X51Downmix; break;
+    case DevFmtX61: device->RealOut.RemixMap = X61Downmix; break;
+    case DevFmtX71: device->RealOut.RemixMap = X71Downmix; break;
+    case DevFmtX714: device->RealOut.RemixMap = X71Downmix; break;
+    case DevFmtX3D71: device->RealOut.RemixMap = X51Downmix; break;
+    case DevFmtAmbi3D: break;
     }
-    TRACE("Front stablizer %s\n", device->Stablizer ? "enabled" : "disabled");
 
-    if(GetConfigValueBool(device->DeviceName.c_str(), nullptr, "dither", 1))
+    nanoseconds::rep sample_delay{0};
+    if(auto *encoder{device->mUhjEncoder.get()})
+        sample_delay += encoder->getDelay();
+
+    if(device->getConfigValueBool(nullptr, "dither", true))
     {
-        ALint depth{
-            ConfigValueInt(device->DeviceName.c_str(), nullptr, "dither-depth").value_or(0)};
+        int depth{device->configValue<int>(nullptr, "dither-depth").value_or(0)};
         if(depth <= 0)
         {
             switch(device->FmtType)
             {
-                case DevFmtByte:
-                case DevFmtUByte:
-                    depth = 8;
-                    break;
-                case DevFmtShort:
-                case DevFmtUShort:
-                    depth = 16;
-                    break;
-                case DevFmtInt:
-                case DevFmtUInt:
-                case DevFmtFloat:
-                    break;
+            case DevFmtByte:
+            case DevFmtUByte:
+                depth = 8;
+                break;
+            case DevFmtShort:
+            case DevFmtUShort:
+                depth = 16;
+                break;
+            case DevFmtInt:
+            case DevFmtUInt:
+            case DevFmtFloat:
+                break;
             }
         }
 
         if(depth > 0)
         {
             depth = clampi(depth, 2, 24);
-            device->DitherDepth = std::pow(2.0f, static_cast<ALfloat>(depth-1));
+            device->DitherDepth = std::pow(2.0f, static_cast<float>(depth-1));
         }
     }
     if(!(device->DitherDepth > 0.0f))
@@ -2037,522 +2255,309 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
         TRACE("Dithering enabled (%d-bit, %g)\n", float2int(std::log2(device->DitherDepth)+0.5f)+1,
               device->DitherDepth);
 
-    device->LimiterState = gainLimiter;
-    if(auto limopt = ConfigValueBool(device->DeviceName.c_str(), nullptr, "output-limiter"))
-        gainLimiter = *limopt ? ALC_TRUE : ALC_FALSE;
+    if(!optlimit)
+        optlimit = device->configValue<bool>(nullptr, "output-limiter");
 
-    /* Valid values for gainLimiter are ALC_DONT_CARE_SOFT, ALC_TRUE, and
-     * ALC_FALSE. For ALC_DONT_CARE_SOFT, use the limiter for integer-based
-     * output (where samples must be clamped), and don't for floating-point
-     * (which can take unclamped samples).
+    /* If the gain limiter is unset, use the limiter for integer-based output
+     * (where samples must be clamped), and don't for floating-point (which can
+     * take unclamped samples).
      */
-    if(gainLimiter == ALC_DONT_CARE_SOFT)
+    if(!optlimit)
     {
         switch(device->FmtType)
         {
-            case DevFmtByte:
-            case DevFmtUByte:
-            case DevFmtShort:
-            case DevFmtUShort:
-            case DevFmtInt:
-            case DevFmtUInt:
-                gainLimiter = ALC_TRUE;
-                break;
-            case DevFmtFloat:
-                gainLimiter = ALC_FALSE;
-                break;
+        case DevFmtByte:
+        case DevFmtUByte:
+        case DevFmtShort:
+        case DevFmtUShort:
+        case DevFmtInt:
+        case DevFmtUInt:
+            optlimit = true;
+            break;
+        case DevFmtFloat:
+            break;
         }
     }
-    if(gainLimiter == ALC_FALSE)
+    if(optlimit.value_or(false) == false)
         TRACE("Output limiter disabled\n");
     else
     {
-        ALfloat thrshld = 1.0f;
+        float thrshld{1.0f};
         switch(device->FmtType)
         {
-            case DevFmtByte:
-            case DevFmtUByte:
-                thrshld = 127.0f / 128.0f;
-                break;
-            case DevFmtShort:
-            case DevFmtUShort:
-                thrshld = 32767.0f / 32768.0f;
-                break;
-            case DevFmtInt:
-            case DevFmtUInt:
-            case DevFmtFloat:
-                break;
+        case DevFmtByte:
+        case DevFmtUByte:
+            thrshld = 127.0f / 128.0f;
+            break;
+        case DevFmtShort:
+        case DevFmtUShort:
+            thrshld = 32767.0f / 32768.0f;
+            break;
+        case DevFmtInt:
+        case DevFmtUInt:
+        case DevFmtFloat:
+            break;
         }
         if(device->DitherDepth > 0.0f)
             thrshld -= 1.0f / device->DitherDepth;
 
         const float thrshld_dB{std::log10(thrshld) * 20.0f};
         auto limiter = CreateDeviceLimiter(device, thrshld_dB);
-        /* Convert the lookahead from samples to nanosamples to nanoseconds. */
-        device->FixedLatency += nanoseconds{seconds{limiter->getLookAhead()}} / device->Frequency;
+
+        sample_delay += limiter->getLookAhead();
         device->Limiter = std::move(limiter);
         TRACE("Output limiter enabled, %.4fdB limit\n", thrshld_dB);
     }
 
+    /* Convert the sample delay from samples to nanosamples to nanoseconds. */
+    device->FixedLatency += nanoseconds{seconds{sample_delay}} / device->Frequency;
     TRACE("Fixed device latency: %" PRId64 "ns\n", int64_t{device->FixedLatency.count()});
 
-    /* Need to delay returning failure until replacement Send arrays have been
-     * allocated with the appropriate size.
-     */
-    update_failed = AL_FALSE;
     FPUCtl mixer_mode{};
-    for(ALCcontext *context : *device->mContexts.load())
+    for(ContextBase *ctxbase : *device->mContexts.load())
     {
-        if(context->mDefaultSlot)
+        auto *context = static_cast<ALCcontext*>(ctxbase);
+
+        std::unique_lock<std::mutex> proplock{context->mPropLock};
+        std::unique_lock<std::mutex> slotlock{context->mEffectSlotLock};
+
+        /* Clear out unused effect slot clusters. */
+        auto slot_cluster_not_in_use = [](ContextBase::EffectSlotCluster &cluster)
+        {
+            for(size_t i{0};i < ContextBase::EffectSlotClusterSize;++i)
+            {
+                if(cluster[i].InUse)
+                    return false;
+            }
+            return true;
+        };
+        auto slotcluster_iter = std::remove_if(context->mEffectSlotClusters.begin(),
+            context->mEffectSlotClusters.end(), slot_cluster_not_in_use);
+        context->mEffectSlotClusters.erase(slotcluster_iter, context->mEffectSlotClusters.end());
+
+        /* Free all wet buffers. Any in use will be reallocated with an updated
+         * configuration in aluInitEffectPanning.
+         */
+        for(auto&& slots : context->mEffectSlotClusters)
         {
-            ALeffectslot *slot = context->mDefaultSlot.get();
-            aluInitEffectPanning(slot, device);
+            for(size_t i{0};i < ContextBase::EffectSlotClusterSize;++i)
+            {
+                slots[i].mWetBuffer.clear();
+                slots[i].mWetBuffer.shrink_to_fit();
+                slots[i].Wet.Buffer = {};
+            }
+        }
 
-            EffectState *state{slot->Effect.State};
+        if(ALeffectslot *slot{context->mDefaultSlot.get()})
+        {
+            aluInitEffectPanning(slot->mSlot, context);
+
+            EffectState *state{slot->Effect.State.get()};
             state->mOutTarget = device->Dry.Buffer;
-            if(state->deviceUpdate(device) == AL_FALSE)
-                update_failed = AL_TRUE;
-            else
-                UpdateEffectSlotProps(slot, context);
+            state->deviceUpdate(device, slot->Buffer);
+            slot->updateProps(context);
         }
 
-        std::unique_lock<std::mutex> proplock{context->mPropLock};
-        std::unique_lock<std::mutex> slotlock{context->mEffectSlotLock};
+        if(EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_relaxed)})
+            std::fill_n(curarray->end(), curarray->size(), nullptr);
         for(auto &sublist : context->mEffectSlotList)
         {
-            uint64_t usemask = ~sublist.FreeMask;
+            uint64_t usemask{~sublist.FreeMask};
             while(usemask)
             {
-                ALsizei idx = CTZ64(usemask);
-                ALeffectslot *slot = sublist.EffectSlots + idx;
-
+                const int idx{al::countr_zero(usemask)};
+                ALeffectslot *slot{sublist.EffectSlots + idx};
                 usemask &= ~(1_u64 << idx);
 
-                aluInitEffectPanning(slot, device);
+                aluInitEffectPanning(slot->mSlot, context);
 
-                EffectState *state{slot->Effect.State};
+                EffectState *state{slot->Effect.State.get()};
                 state->mOutTarget = device->Dry.Buffer;
-                if(state->deviceUpdate(device) == AL_FALSE)
-                    update_failed = AL_TRUE;
-                else
-                    UpdateEffectSlotProps(slot, context);
+                state->deviceUpdate(device, slot->Buffer);
+                slot->updateProps(context);
             }
         }
         slotlock.unlock();
 
+        const uint num_sends{device->NumAuxSends};
         std::unique_lock<std::mutex> srclock{context->mSourceLock};
         for(auto &sublist : context->mSourceList)
         {
-            uint64_t usemask = ~sublist.FreeMask;
+            uint64_t usemask{~sublist.FreeMask};
             while(usemask)
             {
-                ALsizei idx = CTZ64(usemask);
-                ALsource *source = sublist.Sources + idx;
-
+                const int idx{al::countr_zero(usemask)};
+                ALsource *source{sublist.Sources + idx};
                 usemask &= ~(1_u64 << idx);
 
-                if(old_sends != device->NumAuxSends)
+                auto clear_send = [](ALsource::SendData &send) -> void
                 {
-                    if(source->Send.size() > device->NumAuxSends)
-                    {
-                        auto clear_send = [](ALsource::SendData &send) -> void
-                        {
-                            if(send.Slot)
-                                DecrementRef(send.Slot->ref);
-                            send.Slot = nullptr;
-                        };
-                        auto send_begin = source->Send.begin() +
-                            static_cast<ptrdiff_t>(device->NumAuxSends);
-                        std::for_each(send_begin, source->Send.end(), clear_send);
-                    }
-
-                    source->Send.resize(device->NumAuxSends,
-                        {nullptr, 1.0f, 1.0f, LOWPASSFREQREF, 1.0f, HIGHPASSFREQREF});
-                    source->Send.shrink_to_fit();
-                }
+                    if(send.Slot)
+                        DecrementRef(send.Slot->ref);
+                    send.Slot = nullptr;
+                    send.Gain = 1.0f;
+                    send.GainHF = 1.0f;
+                    send.HFReference = LOWPASSFREQREF;
+                    send.GainLF = 1.0f;
+                    send.LFReference = HIGHPASSFREQREF;
+                };
+                auto send_begin = source->Send.begin() + static_cast<ptrdiff_t>(num_sends);
+                std::for_each(send_begin, source->Send.end(), clear_send);
 
-                source->PropsClean.clear(std::memory_order_release);
+                source->mPropsDirty = true;
             }
         }
 
-        /* Clear any pre-existing voice property structs, in case the number of
-         * auxiliary sends is changing. Active sources will have updates
-         * respecified in UpdateAllSourceProps.
-         */
-        ALvoiceProps *vprops{context->mFreeVoiceProps.exchange(nullptr, std::memory_order_acq_rel)};
-        while(vprops)
-        {
-            ALvoiceProps *next = vprops->next.load(std::memory_order_relaxed);
-            delete vprops;
-            vprops = next;
-        }
-
-        if(device->NumAuxSends < old_sends)
+        auto voicelist = context->getVoicesSpan();
+        for(Voice *voice : voicelist)
         {
-            const ALuint num_sends{device->NumAuxSends};
             /* Clear extraneous property set sends. */
-            auto clear_sends = [num_sends](ALvoice &voice) -> void
+            std::fill(std::begin(voice->mProps.Send)+num_sends, std::end(voice->mProps.Send),
+                VoiceProps::SendData{});
+
+            std::fill(voice->mSend.begin()+num_sends, voice->mSend.end(), Voice::TargetData{});
+            for(auto &chandata : voice->mChans)
             {
-                std::fill(std::begin(voice.mProps.Send)+num_sends, std::end(voice.mProps.Send),
-                    ALvoiceProps::SendData{});
+                std::fill(chandata.mWetParams.begin()+num_sends, chandata.mWetParams.end(),
+                    SendParams{});
+            }
 
-                std::fill(voice.mSend.begin()+num_sends, voice.mSend.end(), ALvoice::TargetData{});
-                auto clear_chan_sends = [num_sends](ALvoice::ChannelData &chandata) -> void
-                {
-                    std::fill(chandata.mWetParams.begin()+num_sends, chandata.mWetParams.end(),
-                        SendParams{});
-                };
-                std::for_each(voice.mChans.begin(), voice.mChans.end(), clear_chan_sends);
-            };
-            std::for_each(context->mVoices.begin(), context->mVoices.end(), clear_sends);
-        }
-        auto reset_voice = [device](ALvoice &voice) -> void
-        {
-            delete voice.mUpdate.exchange(nullptr, std::memory_order_acq_rel);
+            if(VoicePropsItem *props{voice->mUpdate.exchange(nullptr, std::memory_order_relaxed)})
+                AtomicReplaceHead(context->mFreeVoiceProps, props);
 
             /* Force the voice to stopped if it was stopping. */
-            ALvoice::State vstate{ALvoice::Stopping};
-            voice.mPlayState.compare_exchange_strong(vstate, ALvoice::Stopped,
+            Voice::State vstate{Voice::Stopping};
+            voice->mPlayState.compare_exchange_strong(vstate, Voice::Stopped,
                 std::memory_order_acquire, std::memory_order_acquire);
-            if(voice.mSourceID.load(std::memory_order_relaxed) == 0u)
-                return;
+            if(voice->mSourceID.load(std::memory_order_relaxed) == 0u)
+                continue;
 
-            if(device->AvgSpeakerDist > 0.0f)
-            {
-                /* Reinitialize the NFC filters for new parameters. */
-                const ALfloat w1{SPEEDOFSOUNDMETRESPERSEC /
-                    (device->AvgSpeakerDist * static_cast<float>(device->Frequency))};
-                auto init_nfc = [w1](ALvoice::ChannelData &chandata) -> void
-                { chandata.mDryParams.NFCtrlFilter.init(w1); };
-                std::for_each(voice.mChans.begin(), voice.mChans.begin()+voice.mNumChannels,
-                    init_nfc);
-            }
-        };
-        std::for_each(context->mVoices.begin(), context->mVoices.end(), reset_voice);
+            voice->prepare(device);
+        }
+        /* Clear all voice props to let them get allocated again. */
+        context->mVoicePropClusters.clear();
+        context->mFreeVoiceProps.store(nullptr, std::memory_order_relaxed);
         srclock.unlock();
 
-        context->mPropsClean.test_and_set(std::memory_order_release);
+        context->mPropsDirty = false;
         UpdateContextProps(context);
-        context->mListener.PropsClean.test_and_set(std::memory_order_release);
-        UpdateListenerProps(context);
         UpdateAllSourceProps(context);
     }
     mixer_mode.leave();
-    if(update_failed)
-        return ALC_INVALID_DEVICE;
 
-    if(!device->Flags.get<DevicePaused>())
+    if(!device->Flags.test(DevicePaused))
     {
         try {
             auto backend = device->Backend.get();
-            if(!backend->start())
-                throw al::backend_exception{ALC_INVALID_DEVICE, "Backend error"};
-            device->Flags.set<DeviceRunning>();
+            backend->start();
+            device->Flags.set(DeviceRunning);
         }
         catch(al::backend_exception& e) {
-            WARN("Failed to start playback: %s\n", e.what());
+            ERR("%s\n", e.what());
+            device->handleDisconnect("%s", e.what());
             return ALC_INVALID_DEVICE;
         }
+        TRACE("Post-start: %s, %s, %uhz, %u / %u buffer\n",
+            DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
+            device->Frequency, device->UpdateSize, device->BufferSize);
     }
 
     return ALC_NO_ERROR;
 }
 
-
-ALCdevice::ALCdevice(DeviceType type) : Type{type}, mContexts{&EmptyContextArray}
-{
-}
-
-/* ALCdevice::~ALCdevice
- *
- * Frees the device structure, and destroys any objects the app failed to
- * delete. Called once there's no more references on the device.
- */
-ALCdevice::~ALCdevice()
-{
-    TRACE("Freeing device %p\n", decltype(std::declval<void*>()){this});
-
-    Backend = nullptr;
-
-    size_t count{std::accumulate(BufferList.cbegin(), BufferList.cend(), size_t{0u},
-        [](size_t cur, const BufferSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(~sublist.FreeMask)); }
-    )};
-    if(count > 0)
-        WARN("%zu Buffer%s not deleted\n", count, (count==1)?"":"s");
-
-    count = std::accumulate(EffectList.cbegin(), EffectList.cend(), size_t{0u},
-        [](size_t cur, const EffectSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(~sublist.FreeMask)); }
-    );
-    if(count > 0)
-        WARN("%zu Effect%s not deleted\n", count, (count==1)?"":"s");
-
-    count = std::accumulate(FilterList.cbegin(), FilterList.cend(), size_t{0u},
-        [](size_t cur, const FilterSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(~sublist.FreeMask)); }
-    );
-    if(count > 0)
-        WARN("%zu Filter%s not deleted\n", count, (count==1)?"":"s");
-
-    if(mHrtf)
-        mHrtf->DecRef();
-    mHrtf = nullptr;
-
-    auto *oldarray = mContexts.exchange(nullptr, std::memory_order_relaxed);
-    if(oldarray != &EmptyContextArray) delete oldarray;
-}
-
-
-/* VerifyDevice
- *
- * Checks if the device handle is valid, and returns a new reference if so.
+/**
+ * Updates device parameters as above, and also first clears the disconnected
+ * status, if set.
  */
-static DeviceRef VerifyDevice(ALCdevice *device)
-{
-    std::lock_guard<std::recursive_mutex> _{ListLock};
-    auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device);
-    if(iter != DeviceList.cend() && *iter == device)
-        return *iter;
-    return nullptr;
-}
-
-
-ALCcontext::ALCcontext(al::intrusive_ptr<ALCdevice> device) : mDevice{std::move(device)}
+bool ResetDeviceParams(ALCdevice *device, const int *attrList)
 {
-    mPropsClean.test_and_set(std::memory_order_relaxed);
-}
-
-ALCcontext::~ALCcontext()
-{
-    TRACE("Freeing context %p\n", decltype(std::declval<void*>()){this});
-
-    size_t count{0};
-    ALcontextProps *cprops{mUpdate.exchange(nullptr, std::memory_order_relaxed)};
-    if(cprops)
-    {
-        ++count;
-        delete cprops;
-    }
-    cprops = mFreeContextProps.exchange(nullptr, std::memory_order_acquire);
-    while(cprops)
+    /* If the device was disconnected, reset it since we're opened anew. */
+    if(!device->Connected.load(std::memory_order_relaxed)) UNLIKELY
     {
-        ALcontextProps *next{cprops->next.load(std::memory_order_relaxed)};
-        delete cprops;
-        cprops = next;
-        ++count;
-    }
-    TRACE("Freed %zu context property object%s\n", count, (count==1)?"":"s");
-
-    count = std::accumulate(mSourceList.cbegin(), mSourceList.cend(), size_t{0u},
-        [](size_t cur, const SourceSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(~sublist.FreeMask)); }
-    );
-    if(count > 0)
-        WARN("%zu Source%s not deleted\n", count, (count==1)?"":"s");
-    mSourceList.clear();
-    mNumSources = 0;
-
-    count = 0;
-    ALeffectslotProps *eprops{mFreeEffectslotProps.exchange(nullptr, std::memory_order_acquire)};
-    while(eprops)
-    {
-        ALeffectslotProps *next{eprops->next.load(std::memory_order_relaxed)};
-        if(eprops->State) eprops->State->release();
-        delete eprops;
-        eprops = next;
-        ++count;
-    }
-    TRACE("Freed %zu AuxiliaryEffectSlot property object%s\n", count, (count==1)?"":"s");
-
-    delete mActiveAuxSlots.exchange(nullptr, std::memory_order_relaxed);
-    mDefaultSlot = nullptr;
-
-    count = std::accumulate(mEffectSlotList.cbegin(), mEffectSlotList.cend(), size_t{0u},
-        [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
-        { return cur + static_cast<ALuint>(POPCNT64(~sublist.FreeMask)); }
-    );
-    if(count > 0)
-        WARN("%zu AuxiliaryEffectSlot%s not deleted\n", count, (count==1)?"":"s");
-    mEffectSlotList.clear();
-    mNumEffectSlots = 0;
-
-    count = 0;
-    ALvoiceProps *vprops{mFreeVoiceProps.exchange(nullptr, std::memory_order_acquire)};
-    while(vprops)
-    {
-        ALvoiceProps *next{vprops->next.load(std::memory_order_relaxed)};
-        delete vprops;
-        vprops = next;
-        ++count;
-    }
-    TRACE("Freed %zu voice property object%s\n", count, (count==1)?"":"s");
-
-    mVoices.clear();
+        /* Make sure disconnection is finished before continuing on. */
+        device->waitForMix();
 
-    count = 0;
-    ALlistenerProps *lprops{mListener.Params.Update.exchange(nullptr, std::memory_order_relaxed)};
-    if(lprops)
-    {
-        ++count;
-        delete lprops;
-    }
-    lprops = mFreeListenerProps.exchange(nullptr, std::memory_order_acquire);
-    while(lprops)
-    {
-        ALlistenerProps *next{lprops->next.load(std::memory_order_relaxed)};
-        delete lprops;
-        lprops = next;
-        ++count;
-    }
-    TRACE("Freed %zu listener property object%s\n", count, (count==1)?"":"s");
-
-    if(mAsyncEvents)
-    {
-        count = 0;
-        auto evt_vec = mAsyncEvents->getReadVector();
-        if(evt_vec.first.len > 0)
+        for(ContextBase *ctxbase : *device->mContexts.load(std::memory_order_acquire))
         {
-            al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf), evt_vec.first.len);
-            count += evt_vec.first.len;
-        }
-        if(evt_vec.second.len > 0)
-        {
-            al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.second.buf), evt_vec.second.len);
-            count += evt_vec.second.len;
-        }
-        if(count > 0)
-            TRACE("Destructed %zu orphaned event%s\n", count, (count==1)?"":"s");
-        mAsyncEvents->readAdvance(count);
-    }
-}
+            auto *ctx = static_cast<ALCcontext*>(ctxbase);
+            if(!ctx->mStopVoicesOnDisconnect.load(std::memory_order_acquire))
+                continue;
 
-void ALCcontext::init()
-{
-    if(DefaultEffect.type != AL_EFFECT_NULL && mDevice->Type == Playback)
-    {
-        mDefaultSlot = std::unique_ptr<ALeffectslot>{new ALeffectslot{}};
-        if(InitEffectSlot(mDefaultSlot.get()) == AL_NO_ERROR)
-            aluInitEffectPanning(mDefaultSlot.get(), mDevice.get());
-        else
-        {
-            mDefaultSlot = nullptr;
-            ERR("Failed to initialize the default effect slot\n");
+            /* Clear any pending voice changes and reallocate voices to get a
+             * clean restart.
+             */
+            std::lock_guard<std::mutex> __{ctx->mSourceLock};
+            auto *vchg = ctx->mCurrentVoiceChange.load(std::memory_order_acquire);
+            while(auto *next = vchg->mNext.load(std::memory_order_acquire))
+                vchg = next;
+            ctx->mCurrentVoiceChange.store(vchg, std::memory_order_release);
+
+            ctx->mVoicePropClusters.clear();
+            ctx->mFreeVoiceProps.store(nullptr, std::memory_order_relaxed);
+
+            ctx->mVoiceClusters.clear();
+            ctx->allocVoices(std::max<size_t>(256,
+                ctx->mActiveVoiceCount.load(std::memory_order_relaxed)));
         }
-    }
 
-    ALeffectslotArray *auxslots;
-    if(!mDefaultSlot)
-        auxslots = ALeffectslot::CreatePtrArray(0);
-    else
-    {
-        auxslots = ALeffectslot::CreatePtrArray(1);
-        (*auxslots)[0] = mDefaultSlot.get();
+        device->Connected.store(true);
     }
-    mActiveAuxSlots.store(auxslots, std::memory_order_relaxed);
-
-    mExtensionList = alExtList;
-
-
-    mListener.Params.Matrix = alu::Matrix::Identity();
-    mListener.Params.Velocity = alu::Vector{};
-    mListener.Params.Gain = mListener.Gain;
-    mListener.Params.MetersPerUnit = mListener.mMetersPerUnit;
-    mListener.Params.DopplerFactor = mDopplerFactor;
-    mListener.Params.SpeedOfSound = mSpeedOfSound * mDopplerVelocity;
-    mListener.Params.SourceDistanceModel = mSourceDistanceModel;
-    mListener.Params.mDistanceModel = mDistanceModel;
-
-
-    mAsyncEvents = CreateRingBuffer(511, sizeof(AsyncEvent), false);
-    StartEventThrd(this);
 
+    ALCenum err{UpdateDeviceParams(device, attrList)};
+    if(err == ALC_NO_ERROR) LIKELY return ALC_TRUE;
 
-    mVoices.reserve(256);
-    mVoices.resize(64);
+    alcSetError(device, err);
+    return ALC_FALSE;
 }
 
-bool ALCcontext::deinit()
-{
-    if(LocalContext.get() == this)
-    {
-        WARN("%p released while current on thread\n", decltype(std::declval<void*>()){this});
-        LocalContext.set(nullptr);
-        release();
-    }
-
-    ALCcontext *origctx{this};
-    if(GlobalContext.compare_exchange_strong(origctx, nullptr))
-        release();
 
-    bool ret{};
-    /* First make sure this context exists in the device's list. */
-    auto *oldarray = mDevice->mContexts.load(std::memory_order_acquire);
-    if(auto toremove = static_cast<size_t>(std::count(oldarray->begin(), oldarray->end(), this)))
+/** Checks if the device handle is valid, and returns a new reference if so. */
+DeviceRef VerifyDevice(ALCdevice *device)
+{
+    std::lock_guard<std::recursive_mutex> _{ListLock};
+    auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device);
+    if(iter != DeviceList.end() && *iter == device)
     {
-        using ContextArray = al::FlexArray<ALCcontext*>;
-        auto alloc_ctx_array = [](const size_t count) -> ContextArray*
-        {
-            if(count == 0) return &EmptyContextArray;
-            return ContextArray::Create(count).release();
-        };
-        auto *newarray = alloc_ctx_array(oldarray->size() - toremove);
-
-        /* Copy the current/old context handles to the new array, excluding the
-         * given context.
-         */
-        std::copy_if(oldarray->begin(), oldarray->end(), newarray->begin(),
-            std::bind(std::not_equal_to<ALCcontext*>{}, _1, this));
-
-        /* Store the new context array in the device. Wait for any current mix
-         * to finish before deleting the old array.
-         */
-        mDevice->mContexts.store(newarray);
-        if(oldarray != &EmptyContextArray)
-        {
-            while((mDevice->MixCount.load(std::memory_order_acquire)&1))
-                std::this_thread::yield();
-            delete oldarray;
-        }
-
-        ret = !newarray->empty();
+        (*iter)->add_ref();
+        return DeviceRef{*iter};
     }
-    else
-        ret = !oldarray->empty();
-
-    StopEventThrd(this);
-
-    return ret;
+    return nullptr;
 }
 
 
-/* VerifyContext
- *
+/**
  * Checks if the given context is valid, returning a new reference to it if so.
  */
-static ContextRef VerifyContext(ALCcontext *context)
+ContextRef VerifyContext(ALCcontext *context)
 {
     std::lock_guard<std::recursive_mutex> _{ListLock};
-    auto iter = std::lower_bound(ContextList.cbegin(), ContextList.cend(), context);
-    if(iter != ContextList.cend() && *iter == context)
-        return *iter;
+    auto iter = std::lower_bound(ContextList.begin(), ContextList.end(), context);
+    if(iter != ContextList.end() && *iter == context)
+    {
+        (*iter)->add_ref();
+        return ContextRef{*iter};
+    }
     return nullptr;
 }
 
-/* GetContextRef
- *
- * Returns a new reference to the currently active context for this thread.
- */
+} // namespace
+
+/** Returns a new reference to the currently active context for this thread. */
 ContextRef GetContextRef(void)
 {
-    ALCcontext *context{LocalContext.get()};
+    ALCcontext *context{ALCcontext::getThreadContext()};
     if(context)
         context->add_ref();
     else
     {
-        std::lock_guard<std::recursive_mutex> _{ListLock};
-        context = GlobalContext.load(std::memory_order_acquire);
-        if(context) context->add_ref();
+        while(ALCcontext::sGlobalContextLock.exchange(true, std::memory_order_acquire)) {
+            /* Wait to make sure another thread isn't trying to change the
+             * current context and bring its refcount to 0.
+             */
+        }
+        context = ALCcontext::sGlobalContext.load(std::memory_order_acquire);
+        if(context) LIKELY context->add_ref();
+        ALCcontext::sGlobalContextLock.store(false, std::memory_order_release);
     }
     return ContextRef{context};
 }
@@ -2562,10 +2567,6 @@ ContextRef GetContextRef(void)
  * Standard ALC functions
  ************************************************/
 
-/* alcGetError
- *
- * Return last ALC generated error code for the given device
- */
 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
 START_API_FUNC
 {
@@ -2576,11 +2577,7 @@ START_API_FUNC
 END_API_FUNC
 
 
-/* alcSuspendContext
- *
- * Suspends updates for the given context
- */
-ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
+ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context)
 START_API_FUNC
 {
     if(!SuspendDefers)
@@ -2590,15 +2587,14 @@ START_API_FUNC
     if(!ctx)
         alcSetError(nullptr, ALC_INVALID_CONTEXT);
     else
+    {
+        std::lock_guard<std::mutex> _{ctx->mPropLock};
         ctx->deferUpdates();
+    }
 }
 END_API_FUNC
 
-/* alcProcessContext
- *
- * Resumes processing updates for the given context
- */
-ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
+ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context)
 START_API_FUNC
 {
     if(!SuspendDefers)
@@ -2608,19 +2604,18 @@ START_API_FUNC
     if(!ctx)
         alcSetError(nullptr, ALC_INVALID_CONTEXT);
     else
+    {
+        std::lock_guard<std::mutex> _{ctx->mPropLock};
         ctx->processUpdates();
+    }
 }
 END_API_FUNC
 
 
-/* alcGetString
- *
- * Returns information about the device, and error strings
- */
 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
 START_API_FUNC
 {
-    const ALCchar *value = nullptr;
+    const ALCchar *value{nullptr};
 
     switch(param)
     {
@@ -2654,7 +2649,17 @@ START_API_FUNC
 
     case ALC_ALL_DEVICES_SPECIFIER:
         if(DeviceRef dev{VerifyDevice(Device)})
-            value = dev->DeviceName.c_str();
+        {
+            if(dev->Type == DeviceType::Capture)
+                alcSetError(dev.get(), ALC_INVALID_ENUM);
+            else if(dev->Type == DeviceType::Loopback)
+                value = alcDefaultName;
+            else
+            {
+                std::lock_guard<std::mutex> _{dev->StateLock};
+                value = dev->DeviceName.c_str();
+            }
+        }
         else
         {
             ProbeAllDevicesList();
@@ -2664,7 +2669,15 @@ START_API_FUNC
 
     case ALC_CAPTURE_DEVICE_SPECIFIER:
         if(DeviceRef dev{VerifyDevice(Device)})
-            value = dev->DeviceName.c_str();
+        {
+            if(dev->Type != DeviceType::Capture)
+                alcSetError(dev.get(), ALC_INVALID_ENUM);
+            else
+            {
+                std::lock_guard<std::mutex> _{dev->StateLock};
+                value = dev->DeviceName.c_str();
+            }
+        }
         else
         {
             ProbeCaptureDeviceList();
@@ -2706,7 +2719,7 @@ START_API_FUNC
         if(DeviceRef dev{VerifyDevice(Device)})
         {
             std::lock_guard<std::mutex> _{dev->StateLock};
-            value = (dev->mHrtf ? dev->HrtfName.c_str() : "");
+            value = (dev->mHrtf ? dev->mHrtfName.c_str() : "");
         }
         else
             alcSetError(nullptr, ALC_INVALID_DEVICE);
@@ -2722,16 +2735,7 @@ START_API_FUNC
 END_API_FUNC
 
 
-static inline ALCsizei NumAttrsForDevice(ALCdevice *device)
-{
-    if(device->Type == Capture) return 9;
-    if(device->Type != Loopback) return 29;
-    if(device->FmtChans == DevFmtAmbi3D)
-        return 35;
-    return 29;
-}
-
-static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCint> values)
+static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<int> values)
 {
     size_t i;
 
@@ -2752,6 +2756,16 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
             values[0] = alcMinorVersion;
             return 1;
 
+        case ALC_EFX_MAJOR_VERSION:
+            values[0] = alcEFXMajorVersion;
+            return 1;
+        case ALC_EFX_MINOR_VERSION:
+            values[0] = alcEFXMinorVersion;
+            return 1;
+        case ALC_MAX_AUXILIARY_SENDS:
+            values[0] = MAX_SENDS;
+            return 1;
+
         case ALC_ATTRIBUTES_SIZE:
         case ALC_ALL_ATTRIBUTES:
         case ALC_FREQUENCY:
@@ -2771,26 +2785,25 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
 
         default:
             alcSetError(nullptr, ALC_INVALID_ENUM);
-            return 0;
         }
         return 0;
     }
 
-    if(device->Type == Capture)
+    std::lock_guard<std::mutex> _{device->StateLock};
+    if(device->Type == DeviceType::Capture)
     {
+        static constexpr int MaxCaptureAttributes{9};
         switch(param)
         {
         case ALC_ATTRIBUTES_SIZE:
-            values[0] = NumAttrsForDevice(device);
+            values[0] = MaxCaptureAttributes;
             return 1;
-
         case ALC_ALL_ATTRIBUTES:
             i = 0;
-            if(values.size() < static_cast<size_t>(NumAttrsForDevice(device)))
+            if(values.size() < MaxCaptureAttributes)
                 alcSetError(device, ALC_INVALID_VALUE);
             else
             {
-                std::lock_guard<std::mutex> _{device->StateLock};
                 values[i++] = ALC_MAJOR_VERSION;
                 values[i++] = alcMajorVersion;
                 values[i++] = ALC_MINOR_VERSION;
@@ -2800,6 +2813,7 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
                 values[i++] = ALC_CONNECTED;
                 values[i++] = device->Connected.load(std::memory_order_relaxed);
                 values[i++] = 0;
+                assert(i == MaxCaptureAttributes);
             }
             return i;
 
@@ -2811,17 +2825,11 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
             return 1;
 
         case ALC_CAPTURE_SAMPLES:
-            {
-                std::lock_guard<std::mutex> _{device->StateLock};
-                values[0] = static_cast<int>(device->Backend->availableSamples());
-            }
+            values[0] = static_cast<int>(device->Backend->availableSamples());
             return 1;
 
         case ALC_CONNECTED:
-            {
-                std::lock_guard<std::mutex> _{device->StateLock};
-                values[0] = device->Connected.load(std::memory_order_acquire);
-            }
+            values[0] = device->Connected.load(std::memory_order_acquire);
             return 1;
 
         default:
@@ -2831,6 +2839,12 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
     }
 
     /* render device */
+    auto NumAttrsForDevice = [](ALCdevice *aldev) noexcept
+    {
+        if(aldev->Type == DeviceType::Loopback && aldev->FmtChans == DevFmtAmbi3D)
+            return 37;
+        return 31;
+    };
     switch(param)
     {
     case ALC_ATTRIBUTES_SIZE:
@@ -2843,7 +2857,6 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
             alcSetError(device, ALC_INVALID_VALUE);
         else
         {
-            std::lock_guard<std::mutex> _{device->StateLock};
             values[i++] = ALC_MAJOR_VERSION;
             values[i++] = alcMajorVersion;
             values[i++] = ALC_MINOR_VERSION;
@@ -2855,7 +2868,7 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
 
             values[i++] = ALC_FREQUENCY;
             values[i++] = static_cast<int>(device->Frequency);
-            if(device->Type != Loopback)
+            if(device->Type != DeviceType::Loopback)
             {
                 values[i++] = ALC_REFRESH;
                 values[i++] = static_cast<int>(device->Frequency / device->UpdateSize);
@@ -2868,20 +2881,20 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
                 if(device->FmtChans == DevFmtAmbi3D)
                 {
                     values[i++] = ALC_AMBISONIC_LAYOUT_SOFT;
-                    values[i++] = static_cast<ALCint>(device->mAmbiLayout);
+                    values[i++] = EnumFromDevAmbi(device->mAmbiLayout);
 
                     values[i++] = ALC_AMBISONIC_SCALING_SOFT;
-                    values[i++] = static_cast<ALCint>(device->mAmbiScale);
+                    values[i++] = EnumFromDevAmbi(device->mAmbiScale);
 
                     values[i++] = ALC_AMBISONIC_ORDER_SOFT;
-                    values[i++] = static_cast<ALCint>(device->mAmbiOrder);
+                    values[i++] = static_cast<int>(device->mAmbiOrder);
                 }
 
                 values[i++] = ALC_FORMAT_CHANNELS_SOFT;
-                values[i++] = device->FmtChans;
+                values[i++] = EnumFromDevFmt(device->FmtChans);
 
                 values[i++] = ALC_FORMAT_TYPE_SOFT;
-                values[i++] = device->FmtType;
+                values[i++] = EnumFromDevFmt(device->FmtType);
             }
 
             values[i++] = ALC_MONO_SOURCES;
@@ -2891,19 +2904,22 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
             values[i++] = static_cast<int>(device->NumStereoSources);
 
             values[i++] = ALC_MAX_AUXILIARY_SENDS;
-            values[i++] = static_cast<ALCint>(device->NumAuxSends);
+            values[i++] = static_cast<int>(device->NumAuxSends);
 
             values[i++] = ALC_HRTF_SOFT;
             values[i++] = (device->mHrtf ? ALC_TRUE : ALC_FALSE);
 
             values[i++] = ALC_HRTF_STATUS_SOFT;
-            values[i++] = device->HrtfStatus;
+            values[i++] = device->mHrtfStatus;
 
             values[i++] = ALC_OUTPUT_LIMITER_SOFT;
             values[i++] = device->Limiter ? ALC_TRUE : ALC_FALSE;
 
             values[i++] = ALC_MAX_AMBISONIC_ORDER_SOFT;
-            values[i++] = MAX_AMBI_ORDER;
+            values[i++] = MaxAmbiOrder;
+
+            values[i++] = ALC_OUTPUT_MODE_SOFT;
+            values[i++] = static_cast<ALCenum>(device->getOutputMode1());
 
             values[i++] = 0;
         }
@@ -2930,19 +2946,16 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
         return 1;
 
     case ALC_REFRESH:
-        if(device->Type == Loopback)
+        if(device->Type == DeviceType::Loopback)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
         }
-        {
-            std::lock_guard<std::mutex> _{device->StateLock};
-            values[0] = static_cast<int>(device->Frequency / device->UpdateSize);
-        }
+        values[0] = static_cast<int>(device->Frequency / device->UpdateSize);
         return 1;
 
     case ALC_SYNC:
-        if(device->Type == Loopback)
+        if(device->Type == DeviceType::Loopback)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
@@ -2951,43 +2964,43 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
         return 1;
 
     case ALC_FORMAT_CHANNELS_SOFT:
-        if(device->Type != Loopback)
+        if(device->Type != DeviceType::Loopback)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
         }
-        values[0] = device->FmtChans;
+        values[0] = EnumFromDevFmt(device->FmtChans);
         return 1;
 
     case ALC_FORMAT_TYPE_SOFT:
-        if(device->Type != Loopback)
+        if(device->Type != DeviceType::Loopback)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
         }
-        values[0] = device->FmtType;
+        values[0] = EnumFromDevFmt(device->FmtType);
         return 1;
 
     case ALC_AMBISONIC_LAYOUT_SOFT:
-        if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
+        if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
         }
-        values[0] = static_cast<ALCint>(device->mAmbiLayout);
+        values[0] = EnumFromDevAmbi(device->mAmbiLayout);
         return 1;
 
     case ALC_AMBISONIC_SCALING_SOFT:
-        if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
+        if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
         }
-        values[0] = static_cast<ALCint>(device->mAmbiScale);
+        values[0] = EnumFromDevAmbi(device->mAmbiScale);
         return 1;
 
     case ALC_AMBISONIC_ORDER_SOFT:
-        if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
+        if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D)
         {
             alcSetError(device, ALC_INVALID_DEVICE);
             return 0;
@@ -3004,14 +3017,11 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
         return 1;
 
     case ALC_MAX_AUXILIARY_SENDS:
-        values[0] = static_cast<ALCint>(device->NumAuxSends);
+        values[0] = static_cast<int>(device->NumAuxSends);
         return 1;
 
     case ALC_CONNECTED:
-        {
-            std::lock_guard<std::mutex> _{device->StateLock};
-            values[0] = device->Connected.load(std::memory_order_acquire);
-        }
+        values[0] = device->Connected.load(std::memory_order_acquire);
         return 1;
 
     case ALC_HRTF_SOFT:
@@ -3019,16 +3029,13 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
         return 1;
 
     case ALC_HRTF_STATUS_SOFT:
-        values[0] = device->HrtfStatus;
+        values[0] = device->mHrtfStatus;
         return 1;
 
     case ALC_NUM_HRTF_SPECIFIERS_SOFT:
-        {
-            std::lock_guard<std::mutex> _{device->StateLock};
-            device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
-            values[0] = static_cast<ALCint>(minz(device->HrtfList.size(),
-                std::numeric_limits<ALCint>::max()));
-        }
+        device->enumerateHrtfs();
+        values[0] = static_cast<int>(minz(device->mHrtfList.size(),
+            std::numeric_limits<int>::max()));
         return 1;
 
     case ALC_OUTPUT_LIMITER_SOFT:
@@ -3036,7 +3043,11 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
         return 1;
 
     case ALC_MAX_AMBISONIC_ORDER_SOFT:
-        values[0] = MAX_AMBI_ORDER;
+        values[0] = MaxAmbiOrder;
+        return 1;
+
+    case ALC_OUTPUT_MODE_SOFT:
+        values[0] = static_cast<ALCenum>(device->getOutputMode1());
         return 1;
 
     default:
@@ -3045,10 +3056,6 @@ static size_t GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCin
     return 0;
 }
 
-/* alcGetIntegerv
- *
- * Returns information about the device and the version of OpenAL
- */
 ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
 START_API_FUNC
 {
@@ -3056,7 +3063,7 @@ START_API_FUNC
     if(size <= 0 || values == nullptr)
         alcSetError(dev.get(), ALC_INVALID_VALUE);
     else
-        GetIntegerv(dev.get(), param, {values, values+size});
+        GetIntegerv(dev.get(), param, {values, static_cast<uint>(size)});
 }
 END_API_FUNC
 
@@ -3065,32 +3072,41 @@ START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
     if(size <= 0 || values == nullptr)
+    {
         alcSetError(dev.get(), ALC_INVALID_VALUE);
-    else if(!dev || dev->Type == Capture)
+        return;
+    }
+    if(!dev || dev->Type == DeviceType::Capture)
     {
-        auto ivals = al::vector<ALCint>(static_cast<ALuint>(size));
-        size_t got{GetIntegerv(dev.get(), pname, {ivals.data(), ivals.size()})};
-        std::copy_n(ivals.begin(), got, values);
+        auto ivals = al::vector<int>(static_cast<uint>(size));
+        if(size_t got{GetIntegerv(dev.get(), pname, ivals)})
+            std::copy_n(ivals.begin(), got, values);
         return;
     }
     /* render device */
+    auto NumAttrsForDevice = [](ALCdevice *aldev) noexcept
+    {
+        if(aldev->Type == DeviceType::Loopback && aldev->FmtChans == DevFmtAmbi3D)
+            return 41;
+        return 35;
+    };
+    std::lock_guard<std::mutex> _{dev->StateLock};
     switch(pname)
     {
     case ALC_ATTRIBUTES_SIZE:
-        *values = NumAttrsForDevice(dev.get())+4;
+        *values = NumAttrsForDevice(dev.get());
         break;
 
     case ALC_ALL_ATTRIBUTES:
-        if(size < NumAttrsForDevice(dev.get())+4)
+        if(size < NumAttrsForDevice(dev.get()))
             alcSetError(dev.get(), ALC_INVALID_VALUE);
         else
         {
             size_t i{0};
-            std::lock_guard<std::mutex> _{dev->StateLock};
             values[i++] = ALC_FREQUENCY;
             values[i++] = dev->Frequency;
 
-            if(dev->Type != Loopback)
+            if(dev->Type != DeviceType::Loopback)
             {
                 values[i++] = ALC_REFRESH;
                 values[i++] = dev->Frequency / dev->UpdateSize;
@@ -3100,23 +3116,23 @@ START_API_FUNC
             }
             else
             {
+                values[i++] = ALC_FORMAT_CHANNELS_SOFT;
+                values[i++] = EnumFromDevFmt(dev->FmtChans);
+
+                values[i++] = ALC_FORMAT_TYPE_SOFT;
+                values[i++] = EnumFromDevFmt(dev->FmtType);
+
                 if(dev->FmtChans == DevFmtAmbi3D)
                 {
                     values[i++] = ALC_AMBISONIC_LAYOUT_SOFT;
-                    values[i++] = static_cast<ALCint64SOFT>(dev->mAmbiLayout);
+                    values[i++] = EnumFromDevAmbi(dev->mAmbiLayout);
 
                     values[i++] = ALC_AMBISONIC_SCALING_SOFT;
-                    values[i++] = static_cast<ALCint64SOFT>(dev->mAmbiScale);
+                    values[i++] = EnumFromDevAmbi(dev->mAmbiScale);
 
                     values[i++] = ALC_AMBISONIC_ORDER_SOFT;
                     values[i++] = dev->mAmbiOrder;
                 }
-
-                values[i++] = ALC_FORMAT_CHANNELS_SOFT;
-                values[i++] = dev->FmtChans;
-
-                values[i++] = ALC_FORMAT_TYPE_SOFT;
-                values[i++] = dev->FmtType;
             }
 
             values[i++] = ALC_MONO_SOURCES;
@@ -3132,30 +3148,31 @@ START_API_FUNC
             values[i++] = (dev->mHrtf ? ALC_TRUE : ALC_FALSE);
 
             values[i++] = ALC_HRTF_STATUS_SOFT;
-            values[i++] = dev->HrtfStatus;
+            values[i++] = dev->mHrtfStatus;
 
             values[i++] = ALC_OUTPUT_LIMITER_SOFT;
             values[i++] = dev->Limiter ? ALC_TRUE : ALC_FALSE;
 
-            ClockLatency clock{GetClockLatency(dev.get())};
+            ClockLatency clock{GetClockLatency(dev.get(), dev->Backend.get())};
             values[i++] = ALC_DEVICE_CLOCK_SOFT;
             values[i++] = clock.ClockTime.count();
 
             values[i++] = ALC_DEVICE_LATENCY_SOFT;
             values[i++] = clock.Latency.count();
 
+            values[i++] = ALC_OUTPUT_MODE_SOFT;
+            values[i++] = static_cast<ALCenum>(device->getOutputMode1());
+
             values[i++] = 0;
         }
         break;
 
     case ALC_DEVICE_CLOCK_SOFT:
-        { std::lock_guard<std::mutex> _{dev->StateLock};
+        {
+            uint samplecount, refcount;
             nanoseconds basecount;
-            ALuint samplecount;
-            ALuint refcount;
             do {
-                while(((refcount=ReadRef(dev->MixCount))&1) != 0)
-                    std::this_thread::yield();
+                refcount = dev->waitForMix();
                 basecount = dev->ClockBase;
                 samplecount = dev->SamplesDone;
             } while(refcount != ReadRef(dev->MixCount));
@@ -3165,10 +3182,7 @@ START_API_FUNC
         break;
 
     case ALC_DEVICE_LATENCY_SOFT:
-        { std::lock_guard<std::mutex> _{dev->StateLock};
-            ClockLatency clock{GetClockLatency(dev.get())};
-            *values = clock.Latency.count();
-        }
+        *values = GetClockLatency(dev.get(), dev->Backend.get()).Latency.count();
         break;
 
     case ALC_DEVICE_CLOCK_LATENCY_SOFT:
@@ -3176,27 +3190,22 @@ START_API_FUNC
             alcSetError(dev.get(), ALC_INVALID_VALUE);
         else
         {
-            std::lock_guard<std::mutex> _{dev->StateLock};
-            ClockLatency clock{GetClockLatency(dev.get())};
+            ClockLatency clock{GetClockLatency(dev.get(), dev->Backend.get())};
             values[0] = clock.ClockTime.count();
             values[1] = clock.Latency.count();
         }
         break;
 
     default:
-        auto ivals = al::vector<ALCint>(static_cast<ALuint>(size));
-        size_t got{GetIntegerv(dev.get(), pname, {ivals.data(), ivals.size()})};
-        std::copy_n(ivals.begin(), got, values);
+        auto ivals = al::vector<int>(static_cast<uint>(size));
+        if(size_t got{GetIntegerv(dev.get(), pname, ivals)})
+            std::copy_n(ivals.begin(), got, values);
         break;
     }
 }
 END_API_FUNC
 
 
-/* alcIsExtensionPresent
- *
- * Determines if there is support for a particular extension
- */
 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
 START_API_FUNC
 {
@@ -3225,10 +3234,6 @@ START_API_FUNC
 END_API_FUNC
 
 
-/* alcGetProcAddress
- *
- * Retrieves the function address for a particular extension function
- */
 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
 START_API_FUNC
 {
@@ -3236,24 +3241,28 @@ START_API_FUNC
     {
         DeviceRef dev{VerifyDevice(device)};
         alcSetError(dev.get(), ALC_INVALID_VALUE);
+        return nullptr;
     }
-    else
+#ifdef ALSOFT_EAX
+    if(eax_g_is_enabled)
     {
-        for(const auto &func : alcFunctions)
+        for(const auto &func : eaxFunctions)
         {
             if(strcmp(func.funcName, funcName) == 0)
                 return func.address;
         }
     }
+#endif
+    for(const auto &func : alcFunctions)
+    {
+        if(strcmp(func.funcName, funcName) == 0)
+            return func.address;
+    }
     return nullptr;
 }
 END_API_FUNC
 
 
-/* alcGetEnumValue
- *
- * Get the value for a particular ALC enumeration name
- */
 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
 START_API_FUNC
 {
@@ -3261,24 +3270,29 @@ START_API_FUNC
     {
         DeviceRef dev{VerifyDevice(device)};
         alcSetError(dev.get(), ALC_INVALID_VALUE);
+        return 0;
     }
-    else
+#ifdef ALSOFT_EAX
+    if(eax_g_is_enabled)
     {
-        for(const auto &enm : alcEnumerations)
+        for(const auto &enm : eaxEnumerations)
         {
             if(strcmp(enm.enumName, enumName) == 0)
                 return enm.value;
         }
     }
+#endif
+    for(const auto &enm : alcEnumerations)
+    {
+        if(strcmp(enm.enumName, enumName) == 0)
+            return enm.value;
+    }
+
     return 0;
 }
 END_API_FUNC
 
 
-/* alcCreateContext
- *
- * Create and attach a context to the given device.
- */
 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
 START_API_FUNC
 {
@@ -3288,7 +3302,7 @@ START_API_FUNC
      */
     std::unique_lock<std::recursive_mutex> listlock{ListLock};
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type == Capture || !dev->Connected.load(std::memory_order_relaxed))
+    if(!dev || dev->Type == DeviceType::Capture || !dev->Connected.load(std::memory_order_relaxed))
     {
         listlock.unlock();
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
@@ -3303,32 +3317,29 @@ START_API_FUNC
     if(err != ALC_NO_ERROR)
     {
         alcSetError(dev.get(), err);
-        if(err == ALC_INVALID_DEVICE)
-            aluHandleDisconnect(dev.get(), "Device update failure");
         return nullptr;
     }
 
     ContextRef context{new ALCcontext{dev}};
     context->init();
 
-    if(auto volopt = ConfigValueFloat(dev->DeviceName.c_str(), nullptr, "volume-adjust"))
+    if(auto volopt = dev->configValue<float>(nullptr, "volume-adjust"))
     {
-        const ALfloat valf{*volopt};
+        const float valf{*volopt};
         if(!std::isfinite(valf))
             ERR("volume-adjust must be finite: %f\n", valf);
         else
         {
-            const ALfloat db{clampf(valf, -24.0f, 24.0f)};
+            const float db{clampf(valf, -24.0f, 24.0f)};
             if(db != valf)
                 WARN("volume-adjust clamped: %f, range: +/-%f\n", valf, 24.0f);
             context->mGainBoost = std::pow(10.0f, db/20.0f);
             TRACE("volume-adjust gain: %f\n", context->mGainBoost);
         }
     }
-    UpdateListenerProps(context.get());
 
     {
-        using ContextArray = al::FlexArray<ALCcontext*>;
+        using ContextArray = al::FlexArray<ContextBase*>;
 
         /* Allocate a new context array, which holds 1 more than the current/
          * old array.
@@ -3347,10 +3358,9 @@ START_API_FUNC
          * to finish before deleting the old array.
          */
         dev->mContexts.store(newarray.release());
-        if(oldarray != &EmptyContextArray)
+        if(oldarray != &DeviceBase::sEmptyContextArray)
         {
-            while((dev->MixCount.load(std::memory_order_acquire)&1))
-                std::this_thread::yield();
+            dev->waitForMix();
             delete oldarray;
         }
     }
@@ -3359,27 +3369,25 @@ START_API_FUNC
     {
         std::lock_guard<std::recursive_mutex> _{ListLock};
         auto iter = std::lower_bound(ContextList.cbegin(), ContextList.cend(), context.get());
-        ContextList.emplace(iter, context);
+        ContextList.emplace(iter, context.get());
     }
 
-    if(context->mDefaultSlot)
+    if(ALeffectslot *slot{context->mDefaultSlot.get()})
     {
-        if(InitializeEffect(context.get(), context->mDefaultSlot.get(), &DefaultEffect) == AL_NO_ERROR)
-            UpdateEffectSlotProps(context->mDefaultSlot.get(), context.get());
+        ALenum sloterr{slot->initEffect(ALCcontext::sDefaultEffect.type,
+            ALCcontext::sDefaultEffect.Props, context.get())};
+        if(sloterr == AL_NO_ERROR)
+            slot->updateProps(context.get());
         else
             ERR("Failed to initialize the default effect\n");
     }
 
-    TRACE("Created context %p\n", decltype(std::declval<void*>()){context.get()});
-    return context.get();
+    TRACE("Created context %p\n", voidp{context.get()});
+    return context.release();
 }
 END_API_FUNC
 
-/* alcDestroyContext
- *
- * Remove a context from its device
- */
-ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
+ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context)
 START_API_FUNC
 {
     std::unique_lock<std::recursive_mutex> listlock{ListLock};
@@ -3390,51 +3398,40 @@ START_API_FUNC
         alcSetError(nullptr, ALC_INVALID_CONTEXT);
         return;
     }
-    /* Hold an extra reference to this context so it remains valid until the
-     * ListLock is released.
+
+    /* Hold a reference to this context so it remains valid until the ListLock
+     * is released.
      */
-    ContextRef ctx{std::move(*iter)};
+    ContextRef ctx{*iter};
     ContextList.erase(iter);
 
-    ALCdevice *Device{ctx->mDevice.get()};
+    ALCdevice *Device{ctx->mALDevice.get()};
 
     std::lock_guard<std::mutex> _{Device->StateLock};
-    if(!ctx->deinit() && Device->Flags.get<DeviceRunning>())
+    if(!ctx->deinit() && Device->Flags.test(DeviceRunning))
     {
         Device->Backend->stop();
-        Device->Flags.unset<DeviceRunning>();
+        Device->Flags.reset(DeviceRunning);
     }
 }
 END_API_FUNC
 
 
-/* alcGetCurrentContext
- *
- * Returns the currently active context on the calling thread
- */
 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
 START_API_FUNC
 {
-    ALCcontext *Context{LocalContext.get()};
-    if(!Context) Context = GlobalContext.load();
+    ALCcontext *Context{ALCcontext::getThreadContext()};
+    if(!Context) Context = ALCcontext::sGlobalContext.load();
     return Context;
 }
 END_API_FUNC
 
-/* alcGetThreadContext
- *
- * Returns the currently active thread-local context
- */
+/** Returns the currently active thread-local context. */
 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
 START_API_FUNC
-{ return LocalContext.get(); }
+{ return ALCcontext::getThreadContext(); }
 END_API_FUNC
 
-/* alcMakeContextCurrent
- *
- * Makes the given context the active process-wide context, and removes the
- * thread-local context for the calling thread.
- */
 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
 START_API_FUNC
 {
@@ -3451,26 +3448,28 @@ START_API_FUNC
     }
     /* Release this reference (if any) to store it in the GlobalContext
      * pointer. Take ownership of the reference (if any) that was previously
-     * stored there.
+     * stored there, and let the reference go.
      */
-    ctx = ContextRef{GlobalContext.exchange(ctx.release())};
+    while(ALCcontext::sGlobalContextLock.exchange(true, std::memory_order_acquire)) {
+        /* Wait to make sure another thread isn't getting or trying to change
+         * the current context as its refcount is decremented.
+         */
+    }
+    ContextRef{ALCcontext::sGlobalContext.exchange(ctx.release())};
+    ALCcontext::sGlobalContextLock.store(false, std::memory_order_release);
 
-    /* Reset (decrement) the previous global reference by replacing it with the
-     * thread-local context. Take ownership of the thread-local context
-     * reference (if any), clearing the storage to null.
+    /* Take ownership of the thread-local context reference (if any), clearing
+     * the storage to null.
      */
-    ctx = ContextRef{LocalContext.get()};
-    if(ctx) LocalContext.set(nullptr);
+    ctx = ContextRef{ALCcontext::getThreadContext()};
+    if(ctx) ALCcontext::setThreadContext(nullptr);
     /* Reset (decrement) the previous thread-local reference. */
 
     return ALC_TRUE;
 }
 END_API_FUNC
 
-/* alcSetThreadContext
- *
- * Makes the given context the active context for the current thread
- */
+/** Makes the given context the active context for the current thread. */
 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
 START_API_FUNC
 {
@@ -3486,18 +3485,14 @@ START_API_FUNC
         }
     }
     /* context's reference count is already incremented */
-    ContextRef old{LocalContext.get()};
-    LocalContext.set(ctx.release());
+    ContextRef old{ALCcontext::getThreadContext()};
+    ALCcontext::setThreadContext(ctx.release());
 
     return ALC_TRUE;
 }
 END_API_FUNC
 
 
-/* alcGetContextsDevice
- *
- * Returns the device that a particular context is attached to
- */
 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
 START_API_FUNC
 {
@@ -3507,19 +3502,15 @@ START_API_FUNC
         alcSetError(nullptr, ALC_INVALID_CONTEXT);
         return nullptr;
     }
-    return ctx->mDevice.get();
+    return ctx->mALDevice.get();
 }
 END_API_FUNC
 
 
-/* alcOpenDevice
- *
- * Opens the named device.
- */
 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
 START_API_FUNC
 {
-    DO_INITCONFIG();
+    InitConfig();
 
     if(!PlaybackFactory)
     {
@@ -3529,6 +3520,7 @@ START_API_FUNC
 
     if(deviceName)
     {
+        TRACE("Opening playback device \"%s\"\n", deviceName);
         if(!deviceName[0] || al::strcasecmp(deviceName, alcDefaultName) == 0
 #ifdef _WIN32
             /* Some old Windows apps hardcode these expecting OpenAL to use a
@@ -3539,11 +3531,25 @@ START_API_FUNC
             || al::strcasecmp(deviceName, "DirectSound") == 0
             || al::strcasecmp(deviceName, "MMSYSTEM") == 0
 #endif
+            /* Some old Linux apps hardcode configuration strings that were
+             * supported by the OpenAL SI. We can't really do anything useful
+             * with them, so just ignore.
+             */
+            || (deviceName[0] == '\'' && deviceName[1] == '(')
             || al::strcasecmp(deviceName, "openal-soft") == 0)
             deviceName = nullptr;
     }
+    else
+        TRACE("Opening default playback device\n");
+
+    const uint DefaultSends{
+#ifdef ALSOFT_EAX
+        eax_g_is_enabled ? uint{EAX_MAX_FXSLOTS} :
+#endif // ALSOFT_EAX
+        DEFAULT_SENDS
+    };
 
-    DeviceRef device{new ALCdevice{Playback}};
+    DeviceRef device{new ALCdevice{DeviceType::Playback}};
 
     /* Set output format */
     device->FmtChans = DevFmtChannelsDefault;
@@ -3553,170 +3559,35 @@ START_API_FUNC
     device->BufferSize = DEFAULT_UPDATE_SIZE * DEFAULT_NUM_UPDATES;
 
     device->SourcesMax = 256;
+    device->NumStereoSources = 1;
+    device->NumMonoSources = device->SourcesMax - device->NumStereoSources;
     device->AuxiliaryEffectSlotMax = 64;
-    device->NumAuxSends = DEFAULT_SENDS;
+    device->NumAuxSends = DefaultSends;
 
     try {
         auto backend = PlaybackFactory->createBackend(device.get(), BackendType::Playback);
+        std::lock_guard<std::recursive_mutex> _{ListLock};
         backend->open(deviceName);
         device->Backend = std::move(backend);
     }
     catch(al::backend_exception &e) {
         WARN("Failed to open playback device: %s\n", e.what());
-        alcSetError(nullptr, e.errorCode());
+        alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory)
+            ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE);
         return nullptr;
     }
 
-    deviceName = device->DeviceName.c_str();
-    if(auto chanopt = ConfigValueStr(deviceName, nullptr, "channels"))
-    {
-        static const struct ChannelMap {
-            const char name[16];
-            DevFmtChannels chans;
-            ALuint order;
-        } chanlist[] = {
-            { "mono",       DevFmtMono,   0 },
-            { "stereo",     DevFmtStereo, 0 },
-            { "quad",       DevFmtQuad,   0 },
-            { "surround51", DevFmtX51,    0 },
-            { "surround61", DevFmtX61,    0 },
-            { "surround71", DevFmtX71,    0 },
-            { "surround51rear", DevFmtX51Rear, 0 },
-            { "ambi1", DevFmtAmbi3D, 1 },
-            { "ambi2", DevFmtAmbi3D, 2 },
-            { "ambi3", DevFmtAmbi3D, 3 },
-        };
-
-        const ALCchar *fmt{chanopt->c_str()};
-        auto iter = std::find_if(std::begin(chanlist), std::end(chanlist),
-            [fmt](const ChannelMap &entry) -> bool
-            { return al::strcasecmp(entry.name, fmt) == 0; }
-        );
-        if(iter == std::end(chanlist))
-            ERR("Unsupported channels: %s\n", fmt);
-        else
-        {
-            device->FmtChans = iter->chans;
-            device->mAmbiOrder = iter->order;
-            device->Flags.set<ChannelsRequest>();
-        }
-    }
-    if(auto typeopt = ConfigValueStr(deviceName, nullptr, "sample-type"))
-    {
-        static const struct TypeMap {
-            const char name[16];
-            DevFmtType type;
-        } typelist[] = {
-            { "int8",    DevFmtByte   },
-            { "uint8",   DevFmtUByte  },
-            { "int16",   DevFmtShort  },
-            { "uint16",  DevFmtUShort },
-            { "int32",   DevFmtInt    },
-            { "uint32",  DevFmtUInt   },
-            { "float32", DevFmtFloat  },
-        };
-
-        const ALCchar *fmt{typeopt->c_str()};
-        auto iter = std::find_if(std::begin(typelist), std::end(typelist),
-            [fmt](const TypeMap &entry) -> bool
-            { return al::strcasecmp(entry.name, fmt) == 0; }
-        );
-        if(iter == std::end(typelist))
-            ERR("Unsupported sample-type: %s\n", fmt);
-        else
-        {
-            device->FmtType = iter->type;
-            device->Flags.set<SampleTypeRequest>();
-        }
-    }
-
-    if(ALuint freq{ConfigValueUInt(deviceName, nullptr, "frequency").value_or(0)})
-    {
-        if(freq < MIN_OUTPUT_RATE)
-        {
-            ERR("%uhz request clamped to %uhz minimum\n", freq, MIN_OUTPUT_RATE);
-            freq = MIN_OUTPUT_RATE;
-        }
-        device->UpdateSize = (device->UpdateSize*freq + device->Frequency/2) / device->Frequency;
-        device->BufferSize = (device->BufferSize*freq + device->Frequency/2) / device->Frequency;
-        device->Frequency = freq;
-        device->Flags.set<FrequencyRequest>();
-    }
-
-    if(auto persizeopt = ConfigValueUInt(deviceName, nullptr, "period_size"))
-        device->UpdateSize = clampu(*persizeopt, 64, 8192);
-
-    if(auto peropt = ConfigValueUInt(deviceName, nullptr, "periods"))
-        device->BufferSize = device->UpdateSize * clampu(*peropt, 2, 16);
-    else
-        device->BufferSize = maxu(device->BufferSize, device->UpdateSize*2);
-
-    if(auto srcsopt = ConfigValueUInt(deviceName, nullptr, "sources"))
-    {
-        if(*srcsopt > 0) device->SourcesMax = *srcsopt;
-    }
-
-    if(auto slotsopt = ConfigValueUInt(deviceName, nullptr, "slots"))
-    {
-        if(*slotsopt > 0)
-            device->AuxiliaryEffectSlotMax = minu(*slotsopt, INT_MAX);
-    }
-
-    if(auto sendsopt = ConfigValueInt(deviceName, nullptr, "sends"))
-        device->NumAuxSends = clampu(DEFAULT_SENDS, 0,
-            static_cast<ALuint>(clampi(*sendsopt, 0, MAX_SENDS)));
-
-    device->NumStereoSources = 1;
-    device->NumMonoSources = device->SourcesMax - device->NumStereoSources;
-
-    if(auto ambiopt = ConfigValueStr(deviceName, nullptr, "ambi-format"))
-    {
-        const ALCchar *fmt{ambiopt->c_str()};
-        if(al::strcasecmp(fmt, "fuma") == 0)
-        {
-            if(device->mAmbiOrder > 3)
-                ERR("FuMa is incompatible with %d%s order ambisonics (up to third-order only)\n",
-                    device->mAmbiOrder,
-                    (((device->mAmbiOrder%100)/10) == 1) ? "th" :
-                    ((device->mAmbiOrder%10) == 1) ? "st" :
-                    ((device->mAmbiOrder%10) == 2) ? "nd" :
-                    ((device->mAmbiOrder%10) == 3) ? "rd" : "th");
-            else
-            {
-                device->mAmbiLayout = AmbiLayout::FuMa;
-                device->mAmbiScale = AmbiNorm::FuMa;
-            }
-        }
-        else if(al::strcasecmp(fmt, "ambix") == 0 || al::strcasecmp(fmt, "acn+sn3d") == 0)
-        {
-            device->mAmbiLayout = AmbiLayout::ACN;
-            device->mAmbiScale = AmbiNorm::SN3D;
-        }
-        else if(al::strcasecmp(fmt, "acn+n3d") == 0)
-        {
-            device->mAmbiLayout = AmbiLayout::ACN;
-            device->mAmbiScale = AmbiNorm::N3D;
-        }
-        else
-            ERR("Unsupported ambi-format: %s\n", fmt);
-    }
-
     {
         std::lock_guard<std::recursive_mutex> _{ListLock};
         auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
-        DeviceList.emplace(iter, device);
+        DeviceList.emplace(iter, device.get());
     }
 
-    TRACE("Created device %p, \"%s\"\n", decltype(std::declval<void*>()){device.get()},
-        device->DeviceName.c_str());
-    return device.get();
+    TRACE("Created device %p, \"%s\"\n", voidp{device.get()}, device->DeviceName.c_str());
+    return device.release();
 }
 END_API_FUNC
 
-/* alcCloseDevice
- *
- * Closes the given device.
- */
 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
 START_API_FUNC
 {
@@ -3727,26 +3598,26 @@ START_API_FUNC
         alcSetError(nullptr, ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
-    if((*iter)->Type == Capture)
+    if((*iter)->Type == DeviceType::Capture)
     {
-        alcSetError(iter->get(), ALC_INVALID_DEVICE);
+        alcSetError(*iter, ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
 
     /* Erase the device, and any remaining contexts left on it, from their
      * respective lists.
      */
-    DeviceRef dev{std::move(*iter)};
+    DeviceRef dev{*iter};
     DeviceList.erase(iter);
 
     std::unique_lock<std::mutex> statelock{dev->StateLock};
     al::vector<ContextRef> orphanctxs;
-    for(ALCcontext *ctx : *dev->mContexts.load())
+    for(ContextBase *ctx : *dev->mContexts.load())
     {
         auto ctxiter = std::lower_bound(ContextList.begin(), ContextList.end(), ctx);
         if(ctxiter != ContextList.end() && *ctxiter == ctx)
         {
-            orphanctxs.emplace_back(std::move(*ctxiter));
+            orphanctxs.emplace_back(ContextRef{*ctxiter});
             ContextList.erase(ctxiter);
         }
     }
@@ -3754,14 +3625,14 @@ START_API_FUNC
 
     for(ContextRef &context : orphanctxs)
     {
-        WARN("Releasing orphaned context %p\n", decltype(std::declval<void*>()){context.get()});
+        WARN("Releasing orphaned context %p\n", voidp{context.get()});
         context->deinit();
     }
     orphanctxs.clear();
 
-    if(dev->Flags.get<DeviceRunning>())
+    if(dev->Flags.test(DeviceRunning))
         dev->Backend->stop();
-    dev->Flags.unset<DeviceRunning>();
+    dev->Flags.reset(DeviceRunning);
 
     return ALC_TRUE;
 }
@@ -3774,7 +3645,7 @@ END_API_FUNC
 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
 START_API_FUNC
 {
-    DO_INITCONFIG();
+    InitConfig();
 
     if(!CaptureFactory)
     {
@@ -3790,12 +3661,15 @@ START_API_FUNC
 
     if(deviceName)
     {
+        TRACE("Opening capture device \"%s\"\n", deviceName);
         if(!deviceName[0] || al::strcasecmp(deviceName, alcDefaultName) == 0
             || al::strcasecmp(deviceName, "openal-soft") == 0)
             deviceName = nullptr;
     }
+    else
+        TRACE("Opening default capture device\n");
 
-    DeviceRef device{new ALCdevice{Capture}};
+    DeviceRef device{new ALCdevice{DeviceType::Capture}};
 
     auto decompfmt = DecomposeDevFormat(format);
     if(!decompfmt)
@@ -3807,10 +3681,12 @@ START_API_FUNC
     device->Frequency = frequency;
     device->FmtChans = decompfmt->chans;
     device->FmtType = decompfmt->type;
-    device->Flags.set<FrequencyRequest, ChannelsRequest, SampleTypeRequest>();
+    device->Flags.set(FrequencyRequest);
+    device->Flags.set(ChannelsRequest);
+    device->Flags.set(SampleTypeRequest);
 
-    device->UpdateSize = static_cast<ALuint>(samples);
-    device->BufferSize = static_cast<ALuint>(samples);
+    device->UpdateSize = static_cast<uint>(samples);
+    device->BufferSize = static_cast<uint>(samples);
 
     try {
         TRACE("Capture format: %s, %s, %uhz, %u / %u buffer\n",
@@ -3818,24 +3694,25 @@ START_API_FUNC
             device->Frequency, device->UpdateSize, device->BufferSize);
 
         auto backend = CaptureFactory->createBackend(device.get(), BackendType::Capture);
+        std::lock_guard<std::recursive_mutex> _{ListLock};
         backend->open(deviceName);
         device->Backend = std::move(backend);
     }
     catch(al::backend_exception &e) {
         WARN("Failed to open capture device: %s\n", e.what());
-        alcSetError(nullptr, e.errorCode());
+        alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory)
+            ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE);
         return nullptr;
     }
 
     {
         std::lock_guard<std::recursive_mutex> _{ListLock};
         auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
-        DeviceList.emplace(iter, device);
+        DeviceList.emplace(iter, device.get());
     }
 
-    TRACE("Created capture device %p, \"%s\"\n", decltype(std::declval<void*>()){device.get()},
-        device->DeviceName.c_str());
-    return device.get();
+    TRACE("Created capture device %p, \"%s\"\n", voidp{device.get()}, device->DeviceName.c_str());
+    return device.release();
 }
 END_API_FUNC
 
@@ -3849,20 +3726,20 @@ START_API_FUNC
         alcSetError(nullptr, ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
-    if((*iter)->Type != Capture)
+    if((*iter)->Type != DeviceType::Capture)
     {
-        alcSetError(iter->get(), ALC_INVALID_DEVICE);
+        alcSetError(*iter, ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
 
-    DeviceRef dev{std::move(*iter)};
+    DeviceRef dev{*iter};
     DeviceList.erase(iter);
     listlock.unlock();
 
     std::lock_guard<std::mutex> _{dev->StateLock};
-    if(dev->Flags.get<DeviceRunning>())
+    if(dev->Flags.test(DeviceRunning))
         dev->Backend->stop();
-    dev->Flags.unset<DeviceRunning>();
+    dev->Flags.reset(DeviceRunning);
 
     return ALC_TRUE;
 }
@@ -3872,7 +3749,7 @@ ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Capture)
+    if(!dev || dev->Type != DeviceType::Capture)
     {
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
         return;
@@ -3881,16 +3758,16 @@ START_API_FUNC
     std::lock_guard<std::mutex> _{dev->StateLock};
     if(!dev->Connected.load(std::memory_order_acquire))
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
-    else if(!dev->Flags.get<DeviceRunning>())
+    else if(!dev->Flags.test(DeviceRunning))
     {
         try {
             auto backend = dev->Backend.get();
-            if(!backend->start())
-                throw al::backend_exception{ALC_INVALID_DEVICE, "Device start failure"};
-            dev->Flags.set<DeviceRunning>();
+            backend->start();
+            dev->Flags.set(DeviceRunning);
         }
         catch(al::backend_exception& e) {
-            aluHandleDisconnect(dev.get(), "%s", e.what());
+            ERR("%s\n", e.what());
+            dev->handleDisconnect("%s", e.what());
             alcSetError(dev.get(), ALC_INVALID_DEVICE);
         }
     }
@@ -3901,14 +3778,14 @@ ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Capture)
+    if(!dev || dev->Type != DeviceType::Capture)
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
     else
     {
         std::lock_guard<std::mutex> _{dev->StateLock};
-        if(dev->Flags.get<DeviceRunning>())
+        if(dev->Flags.test(DeviceRunning))
             dev->Backend->stop();
-        dev->Flags.unset<DeviceRunning>();
+        dev->Flags.reset(DeviceRunning);
     }
 }
 END_API_FUNC
@@ -3917,7 +3794,7 @@ ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer,
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Capture)
+    if(!dev || dev->Type != DeviceType::Capture)
     {
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
         return;
@@ -3934,16 +3811,14 @@ START_API_FUNC
     std::lock_guard<std::mutex> _{dev->StateLock};
     BackendBase *backend{dev->Backend.get()};
 
-    const auto usamples = static_cast<ALCuint>(samples);
+    const auto usamples = static_cast<uint>(samples);
     if(usamples > backend->availableSamples())
     {
         alcSetError(dev.get(), ALC_INVALID_VALUE);
         return;
     }
 
-    auto *bbuffer = static_cast<al::byte*>(buffer);
-    if(ALCenum err{backend->captureSamples(bbuffer, usamples)})
-        alcSetError(dev.get(), err);
+    backend->captureSamples(static_cast<al::byte*>(buffer), usamples);
 }
 END_API_FUNC
 
@@ -3952,14 +3827,11 @@ END_API_FUNC
  * ALC loopback functions
  ************************************************/
 
-/* alcLoopbackOpenDeviceSOFT
- *
- * Open a loopback device, for manual rendering.
- */
+/** Open a loopback device, for manual rendering. */
 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
 START_API_FUNC
 {
-    DO_INITCONFIG();
+    InitConfig();
 
     /* Make sure the device name, if specified, is us. */
     if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
@@ -3968,11 +3840,18 @@ START_API_FUNC
         return nullptr;
     }
 
-    DeviceRef device{new ALCdevice{Loopback}};
+    const uint DefaultSends{
+#ifdef ALSOFT_EAX
+        eax_g_is_enabled ? uint{EAX_MAX_FXSLOTS} :
+#endif // ALSOFT_EAX
+        DEFAULT_SENDS
+    };
+
+    DeviceRef device{new ALCdevice{DeviceType::Loopback}};
 
     device->SourcesMax = 256;
     device->AuxiliaryEffectSlotMax = 64;
-    device->NumAuxSends = DEFAULT_SENDS;
+    device->NumAuxSends = DefaultSends;
 
     //Set output format
     device->BufferSize = 0;
@@ -3982,21 +3861,6 @@ START_API_FUNC
     device->FmtChans = DevFmtChannelsDefault;
     device->FmtType = DevFmtTypeDefault;
 
-    if(auto srcsopt = ConfigValueUInt(nullptr, nullptr, "sources"))
-    {
-        if(*srcsopt > 0) device->SourcesMax = *srcsopt;
-    }
-
-    if(auto slotsopt = ConfigValueUInt(nullptr, nullptr, "slots"))
-    {
-        if(*slotsopt > 0)
-            device->AuxiliaryEffectSlotMax = minu(*slotsopt, INT_MAX);
-    }
-
-    if(auto sendsopt = ConfigValueInt(nullptr, nullptr, "sends"))
-        device->NumAuxSends = clampu(DEFAULT_SENDS, 0,
-            static_cast<ALuint>(clampi(*sendsopt, 0, MAX_SENDS)));
-
     device->NumStereoSources = 1;
     device->NumMonoSources = device->SourcesMax - device->NumStereoSources;
 
@@ -4008,36 +3872,37 @@ START_API_FUNC
     }
     catch(al::backend_exception &e) {
         WARN("Failed to open loopback device: %s\n", e.what());
-        alcSetError(nullptr, e.errorCode());
+        alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory)
+            ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE);
         return nullptr;
     }
 
     {
         std::lock_guard<std::recursive_mutex> _{ListLock};
         auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
-        DeviceList.emplace(iter, device);
+        DeviceList.emplace(iter, device.get());
     }
 
-    TRACE("Created loopback device %p\n", decltype(std::declval<void*>()){device.get()});
-    return device.get();
+    TRACE("Created loopback device %p\n", voidp{device.get()});
+    return device.release();
 }
 END_API_FUNC
 
-/* alcIsRenderFormatSupportedSOFT
- *
+/**
  * Determines if the loopback device supports the given format for rendering.
  */
 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Loopback)
+    if(!dev || dev->Type != DeviceType::Loopback)
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
     else if(freq <= 0)
         alcSetError(dev.get(), ALC_INVALID_VALUE);
     else
     {
-        if(IsValidALCType(type) && IsValidALCChannels(channels) && freq >= MIN_OUTPUT_RATE)
+        if(DevFmtTypeFromEnum(type).has_value() && DevFmtChannelsFromEnum(channels).has_value()
+            && freq >= MIN_OUTPUT_RATE && freq <= MAX_OUTPUT_RATE)
             return ALC_TRUE;
     }
 
@@ -4045,24 +3910,19 @@ START_API_FUNC
 }
 END_API_FUNC
 
-/* alcRenderSamplesSOFT
- *
+/**
  * Renders some samples into a buffer, using the format last set by the
  * attributes given to alcCreateContext.
  */
 FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
 START_API_FUNC
 {
-    DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Loopback)
-        alcSetError(dev.get(), ALC_INVALID_DEVICE);
+    if(!device || device->Type != DeviceType::Loopback)
+        alcSetError(device, ALC_INVALID_DEVICE);
     else if(samples < 0 || (samples > 0 && buffer == nullptr))
-        alcSetError(dev.get(), ALC_INVALID_VALUE);
+        alcSetError(device, ALC_INVALID_VALUE);
     else
-    {
-        BackendLockGuard _{*dev->Backend};
-        aluMixData(dev.get(), buffer, static_cast<ALuint>(samples));
-    }
+        device->renderSamples(buffer, static_cast<uint>(samples), device->channelsFromFmt());
 }
 END_API_FUNC
 
@@ -4071,58 +3931,56 @@ END_API_FUNC
  * ALC DSP pause/resume functions
  ************************************************/
 
-/* alcDevicePauseSOFT
- *
- * Pause the DSP to stop audio processing.
- */
+/** Pause the DSP to stop audio processing. */
 ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Playback)
+    if(!dev || dev->Type != DeviceType::Playback)
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
     else
     {
         std::lock_guard<std::mutex> _{dev->StateLock};
-        if(dev->Flags.get<DeviceRunning>())
+        if(dev->Flags.test(DeviceRunning))
             dev->Backend->stop();
-        dev->Flags.unset<DeviceRunning>();
-        dev->Flags.set<DevicePaused>();
+        dev->Flags.reset(DeviceRunning);
+        dev->Flags.set(DevicePaused);
     }
 }
 END_API_FUNC
 
-/* alcDeviceResumeSOFT
- *
- * Resume the DSP to restart audio processing.
- */
+/** Resume the DSP to restart audio processing. */
 ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type != Playback)
+    if(!dev || dev->Type != DeviceType::Playback)
     {
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
         return;
     }
 
     std::lock_guard<std::mutex> _{dev->StateLock};
-    if(!dev->Flags.get<DevicePaused>())
+    if(!dev->Flags.test(DevicePaused))
         return;
-    dev->Flags.unset<DevicePaused>();
+    dev->Flags.reset(DevicePaused);
     if(dev->mContexts.load()->empty())
         return;
 
     try {
         auto backend = dev->Backend.get();
-        if(!backend->start())
-            throw al::backend_exception{ALC_INVALID_DEVICE, "Device start failure"};
-        dev->Flags.set<DeviceRunning>();
+        backend->start();
+        dev->Flags.set(DeviceRunning);
     }
     catch(al::backend_exception& e) {
-        aluHandleDisconnect(dev.get(), "%s", e.what());
+        ERR("%s\n", e.what());
+        dev->handleDisconnect("%s", e.what());
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
+        return;
     }
+    TRACE("Post-resume: %s, %s, %uhz, %u / %u buffer\n",
+        DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
+        device->Frequency, device->UpdateSize, device->BufferSize);
 }
 END_API_FUNC
 
@@ -4131,21 +3989,18 @@ END_API_FUNC
  * ALC HRTF functions
  ************************************************/
 
-/* alcGetStringiSOFT
- *
- * Gets a string parameter at the given index.
- */
+/** Gets a string parameter at the given index. */
 ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index)
 START_API_FUNC
 {
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type == Capture)
+    if(!dev || dev->Type == DeviceType::Capture)
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
     else switch(paramName)
     {
         case ALC_HRTF_SPECIFIER_SOFT:
-            if(index >= 0 && static_cast<size_t>(index) < dev->HrtfList.size())
-                return dev->HrtfList[static_cast<ALuint>(index)].name.c_str();
+            if(index >= 0 && static_cast<uint>(index) < dev->mHrtfList.size())
+                return dev->mHrtfList[static_cast<uint>(index)].c_str();
             alcSetError(dev.get(), ALC_INVALID_VALUE);
             break;
 
@@ -4158,16 +4013,13 @@ START_API_FUNC
 }
 END_API_FUNC
 
-/* alcResetDeviceSOFT
- *
- * Resets the given device output, using the specified attribute list.
- */
+/** Resets the given device output, using the specified attribute list. */
 ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs)
 START_API_FUNC
 {
     std::unique_lock<std::recursive_mutex> listlock{ListLock};
     DeviceRef dev{VerifyDevice(device)};
-    if(!dev || dev->Type == Capture)
+    if(!dev || dev->Type == DeviceType::Capture)
     {
         listlock.unlock();
         alcSetError(dev.get(), ALC_INVALID_DEVICE);
@@ -4179,17 +4031,95 @@ START_API_FUNC
     /* Force the backend to stop mixing first since we're resetting. Also reset
      * the connected state so lost devices can attempt recover.
      */
-    if(dev->Flags.get<DeviceRunning>())
+    if(dev->Flags.test(DeviceRunning))
         dev->Backend->stop();
-    dev->Flags.unset<DeviceRunning>();
-    device->Connected.store(true);
+    dev->Flags.reset(DeviceRunning);
 
-    ALCenum err{UpdateDeviceParams(dev.get(), attribs)};
-    if LIKELY(err == ALC_NO_ERROR) return ALC_TRUE;
+    return ResetDeviceParams(dev.get(), attribs) ? ALC_TRUE : ALC_FALSE;
+}
+END_API_FUNC
 
-    alcSetError(dev.get(), err);
-    if(err == ALC_INVALID_DEVICE)
-        aluHandleDisconnect(dev.get(), "Device start failure");
-    return ALC_FALSE;
+
+/************************************************
+ * ALC device reopen functions
+ ************************************************/
+
+/** Reopens the given device output, using the specified name and attribute list. */
+FORCE_ALIGN ALCboolean ALC_APIENTRY alcReopenDeviceSOFT(ALCdevice *device,
+    const ALCchar *deviceName, const ALCint *attribs)
+START_API_FUNC
+{
+    if(deviceName)
+    {
+        if(!deviceName[0] || al::strcasecmp(deviceName, alcDefaultName) == 0)
+            deviceName = nullptr;
+    }
+
+    std::unique_lock<std::recursive_mutex> listlock{ListLock};
+    DeviceRef dev{VerifyDevice(device)};
+    if(!dev || dev->Type != DeviceType::Playback)
+    {
+        listlock.unlock();
+        alcSetError(dev.get(), ALC_INVALID_DEVICE);
+        return ALC_FALSE;
+    }
+    std::lock_guard<std::mutex> _{dev->StateLock};
+
+    /* Force the backend to stop mixing first since we're reopening. */
+    if(dev->Flags.test(DeviceRunning))
+    {
+        auto backend = dev->Backend.get();
+        backend->stop();
+        dev->Flags.reset(DeviceRunning);
+    }
+
+    BackendPtr newbackend;
+    try {
+        newbackend = PlaybackFactory->createBackend(dev.get(), BackendType::Playback);
+        newbackend->open(deviceName);
+    }
+    catch(al::backend_exception &e) {
+        listlock.unlock();
+        newbackend = nullptr;
+
+        WARN("Failed to reopen playback device: %s\n", e.what());
+        alcSetError(dev.get(), (e.errorCode() == al::backend_error::OutOfMemory)
+            ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE);
+
+        /* If the device is connected, not paused, and has contexts, ensure it
+         * continues playing.
+         */
+        if(dev->Connected.load(std::memory_order_relaxed) && !dev->Flags.test(DevicePaused)
+            && !dev->mContexts.load(std::memory_order_relaxed)->empty())
+        {
+            try {
+                auto backend = dev->Backend.get();
+                backend->start();
+                dev->Flags.set(DeviceRunning);
+            }
+            catch(al::backend_exception &be) {
+                ERR("%s\n", be.what());
+                dev->handleDisconnect("%s", be.what());
+            }
+        }
+        return ALC_FALSE;
+    }
+    listlock.unlock();
+    dev->Backend = std::move(newbackend);
+    TRACE("Reopened device %p, \"%s\"\n", voidp{dev.get()}, dev->DeviceName.c_str());
+
+    /* Always return true even if resetting fails. It shouldn't fail, but this
+     * is primarily to avoid confusion by the app seeing the function return
+     * false while the device is on the new output anyway. We could try to
+     * restore the old backend if this fails, but the configuration would be
+     * changed with the new backend and would need to be reset again with the
+     * old one, and the provided attributes may not be appropriate or desirable
+     * for the old device.
+     *
+     * In this way, we essentially act as if the function succeeded, but
+     * immediately disconnects following it.
+     */
+    ResetDeviceParams(dev.get(), attribs);
+    return ALC_TRUE;
 }
 END_API_FUNC
diff --git a/alc/alcmain.h b/alc/alcmain.h
deleted file mode 100644
index 30c5b835..00000000
--- a/alc/alcmain.h
+++ /dev/null
@@ -1,390 +0,0 @@
-#ifndef ALC_MAIN_H
-#define ALC_MAIN_H
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <cstddef>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <utility>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "AL/alext.h"
-
-#include "albyte.h"
-#include "almalloc.h"
-#include "alnumeric.h"
-#include "alspan.h"
-#include "ambidefs.h"
-#include "atomic.h"
-#include "devformat.h"
-#include "filters/splitter.h"
-#include "hrtf.h"
-#include "inprogext.h"
-#include "intrusive_ptr.h"
-#include "vector.h"
-
-class BFormatDec;
-struct ALbuffer;
-struct ALeffect;
-struct ALfilter;
-struct BackendBase;
-struct Compressor;
-struct EffectState;
-struct Uhj2Encoder;
-struct bs2b;
-
-
-#define MIN_OUTPUT_RATE      8000
-#define DEFAULT_OUTPUT_RATE  44100
-#define DEFAULT_UPDATE_SIZE  882 /* 20ms */
-#define DEFAULT_NUM_UPDATES  3
-
-
-enum DeviceType {
-    Playback,
-    Capture,
-    Loopback
-};
-
-
-enum RenderMode {
-    NormalRender,
-    StereoPair,
-    HrtfRender
-};
-
-
-struct BufferSubList {
-    uint64_t FreeMask{~0_u64};
-    ALbuffer *Buffers{nullptr}; /* 64 */
-
-    BufferSubList() noexcept = default;
-    BufferSubList(const BufferSubList&) = delete;
-    BufferSubList(BufferSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Buffers{rhs.Buffers}
-    { rhs.FreeMask = ~0_u64; rhs.Buffers = nullptr; }
-    ~BufferSubList();
-
-    BufferSubList& operator=(const BufferSubList&) = delete;
-    BufferSubList& operator=(BufferSubList&& rhs) noexcept
-    { std::swap(FreeMask, rhs.FreeMask); std::swap(Buffers, rhs.Buffers); return *this; }
-};
-
-struct EffectSubList {
-    uint64_t FreeMask{~0_u64};
-    ALeffect *Effects{nullptr}; /* 64 */
-
-    EffectSubList() noexcept = default;
-    EffectSubList(const EffectSubList&) = delete;
-    EffectSubList(EffectSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Effects{rhs.Effects}
-    { rhs.FreeMask = ~0_u64; rhs.Effects = nullptr; }
-    ~EffectSubList();
-
-    EffectSubList& operator=(const EffectSubList&) = delete;
-    EffectSubList& operator=(EffectSubList&& rhs) noexcept
-    { std::swap(FreeMask, rhs.FreeMask); std::swap(Effects, rhs.Effects); return *this; }
-};
-
-struct FilterSubList {
-    uint64_t FreeMask{~0_u64};
-    ALfilter *Filters{nullptr}; /* 64 */
-
-    FilterSubList() noexcept = default;
-    FilterSubList(const FilterSubList&) = delete;
-    FilterSubList(FilterSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Filters{rhs.Filters}
-    { rhs.FreeMask = ~0_u64; rhs.Filters = nullptr; }
-    ~FilterSubList();
-
-    FilterSubList& operator=(const FilterSubList&) = delete;
-    FilterSubList& operator=(FilterSubList&& rhs) noexcept
-    { std::swap(FreeMask, rhs.FreeMask); std::swap(Filters, rhs.Filters); return *this; }
-};
-
-
-/* Maximum delay in samples for speaker distance compensation. */
-#define MAX_DELAY_LENGTH 1024
-
-class DistanceComp {
-public:
-    struct DistData {
-        ALfloat Gain{1.0f};
-        ALuint Length{0u}; /* Valid range is [0...MAX_DELAY_LENGTH). */
-        ALfloat *Buffer{nullptr};
-    };
-
-private:
-    std::array<DistData,MAX_OUTPUT_CHANNELS> mChannels;
-    al::vector<ALfloat,16> mSamples;
-
-public:
-    void setSampleCount(size_t new_size) { mSamples.resize(new_size); }
-    void clear() noexcept
-    {
-        for(auto &chan : mChannels)
-        {
-            chan.Gain = 1.0f;
-            chan.Length = 0;
-            chan.Buffer = nullptr;
-        }
-        using SampleVecT = decltype(mSamples);
-        SampleVecT{}.swap(mSamples);
-    }
-
-    ALfloat *getSamples() noexcept { return mSamples.data(); }
-
-    al::span<DistData,MAX_OUTPUT_CHANNELS> as_span() { return mChannels; }
-};
-
-struct BFChannelConfig {
-    ALfloat Scale;
-    ALuint Index;
-};
-
-/* Size for temporary storage of buffer data, in ALfloats. Larger values need
- * more memory, while smaller values may need more iterations. The value needs
- * to be a sensible size, however, as it constrains the max stepping value used
- * for mixing, as well as the maximum number of samples per mixing iteration.
- */
-#define BUFFERSIZE 1024
-
-using FloatBufferLine = std::array<float,BUFFERSIZE>;
-
-/* Maximum number of samples to pad on the ends of a buffer for resampling.
- * Note that the padding is symmetric (half at the beginning and half at the
- * end)!
- */
-#define MAX_RESAMPLER_PADDING 48
-
-
-struct FrontStablizer {
-    static constexpr size_t DelayLength{256u};
-
-    alignas(16) float DelayBuf[MAX_OUTPUT_CHANNELS][DelayLength];
-
-    BandSplitter LFilter, RFilter;
-    alignas(16) float LSplit[2][BUFFERSIZE];
-    alignas(16) float RSplit[2][BUFFERSIZE];
-
-    alignas(16) float TempBuf[BUFFERSIZE + DelayLength];
-
-    DEF_NEWDEL(FrontStablizer)
-};
-
-
-struct MixParams {
-    /* Coefficient channel mapping for mixing to the buffer. */
-    std::array<BFChannelConfig,MAX_OUTPUT_CHANNELS> AmbiMap{};
-
-    al::span<FloatBufferLine> Buffer;
-};
-
-struct RealMixParams {
-    std::array<ALuint,MaxChannels> ChannelIndex{};
-
-    al::span<FloatBufferLine> Buffer;
-};
-
-enum {
-    // Frequency was requested by the app or config file
-    FrequencyRequest,
-    // Channel configuration was requested by the config file
-    ChannelsRequest,
-    // Sample type was requested by the config file
-    SampleTypeRequest,
-
-    // Specifies if the DSP is paused at user request
-    DevicePaused,
-    // Specifies if the device is currently running
-    DeviceRunning,
-
-    DeviceFlagsCount
-};
-
-struct ALCdevice : public al::intrusive_ref<ALCdevice> {
-    std::atomic<bool> Connected{true};
-    const DeviceType Type{};
-
-    ALuint Frequency{};
-    ALuint UpdateSize{};
-    ALuint BufferSize{};
-
-    DevFmtChannels FmtChans{};
-    DevFmtType FmtType{};
-    ALboolean IsHeadphones{AL_FALSE};
-    ALuint mAmbiOrder{0};
-    /* For DevFmtAmbi* output only, specifies the channel order and
-     * normalization.
-     */
-    AmbiLayout mAmbiLayout{AmbiLayout::Default};
-    AmbiNorm   mAmbiScale{AmbiNorm::Default};
-
-    ALCenum LimiterState{ALC_DONT_CARE_SOFT};
-
-    std::string DeviceName;
-
-    // Device flags
-    al::bitfield<DeviceFlagsCount> Flags{};
-
-    std::string HrtfName;
-    al::vector<EnumeratedHrtf> HrtfList;
-    ALCenum HrtfStatus{ALC_FALSE};
-
-    std::atomic<ALCenum> LastError{ALC_NO_ERROR};
-
-    // Maximum number of sources that can be created
-    ALuint SourcesMax{};
-    // Maximum number of slots that can be created
-    ALuint AuxiliaryEffectSlotMax{};
-
-    ALCuint NumMonoSources{};
-    ALCuint NumStereoSources{};
-    ALCuint NumAuxSends{};
-
-    // Map of Buffers for this device
-    std::mutex BufferLock;
-    al::vector<BufferSubList> BufferList;
-
-    // Map of Effects for this device
-    std::mutex EffectLock;
-    al::vector<EffectSubList> EffectList;
-
-    // Map of Filters for this device
-    std::mutex FilterLock;
-    al::vector<FilterSubList> FilterList;
-
-    /* Rendering mode. */
-    RenderMode mRenderMode{NormalRender};
-
-    /* The average speaker distance as determined by the ambdec configuration,
-     * HRTF data set, or the NFC-HOA reference delay. Only used for NFC.
-     */
-    ALfloat AvgSpeakerDist{0.0f};
-
-    ALuint SamplesDone{0u};
-    std::chrono::nanoseconds ClockBase{0};
-    std::chrono::nanoseconds FixedLatency{0};
-
-    /* Temp storage used for mixer processing. */
-    alignas(16) ALfloat SourceData[BUFFERSIZE + MAX_RESAMPLER_PADDING];
-    alignas(16) ALfloat ResampledData[BUFFERSIZE];
-    alignas(16) ALfloat FilteredData[BUFFERSIZE];
-    union {
-        alignas(16) ALfloat HrtfSourceData[BUFFERSIZE + HRTF_HISTORY_LENGTH];
-        alignas(16) ALfloat NfcSampleData[BUFFERSIZE];
-    };
-
-    /* Persistent storage for HRTF mixing. */
-    alignas(16) float2 HrtfAccumData[BUFFERSIZE + HRIR_LENGTH];
-
-    /* Mixing buffer used by the Dry mix and Real output. */
-    al::vector<FloatBufferLine, 16> MixBuffer;
-
-    /* The "dry" path corresponds to the main output. */
-    MixParams Dry;
-    ALuint NumChannelsPerOrder[MAX_AMBI_ORDER+1]{};
-
-    /* "Real" output, which will be written to the device buffer. May alias the
-     * dry buffer.
-     */
-    RealMixParams RealOut;
-
-    /* HRTF state and info */
-    std::unique_ptr<DirectHrtfState> mHrtfState;
-    HrtfEntry *mHrtf{nullptr};
-
-    /* Ambisonic-to-UHJ encoder */
-    std::unique_ptr<Uhj2Encoder> Uhj_Encoder;
-
-    /* Ambisonic decoder for speakers */
-    std::unique_ptr<BFormatDec> AmbiDecoder;
-
-    /* Stereo-to-binaural filter */
-    std::unique_ptr<bs2b> Bs2b;
-
-    using PostProc = void(ALCdevice::*)(const size_t SamplesToDo);
-    PostProc PostProcess{nullptr};
-
-    std::unique_ptr<FrontStablizer> Stablizer;
-
-    std::unique_ptr<Compressor> Limiter;
-
-    /* Delay buffers used to compensate for speaker distances. */
-    DistanceComp ChannelDelay;
-
-    /* Dithering control. */
-    ALfloat DitherDepth{0.0f};
-    ALuint DitherSeed{0u};
-
-    /* Running count of the mixer invocations, in 31.1 fixed point. This
-     * actually increments *twice* when mixing, first at the start and then at
-     * the end, so the bottom bit indicates if the device is currently mixing
-     * and the upper bits indicates how many mixes have been done.
-     */
-    RefCount MixCount{0u};
-
-    // Contexts created on this device
-    std::atomic<al::FlexArray<ALCcontext*>*> mContexts{nullptr};
-
-    /* This lock protects the device state (format, update size, etc) from
-     * being from being changed in multiple threads, or being accessed while
-     * being changed. It's also used to serialize calls to the backend.
-     */
-    std::mutex StateLock;
-    std::unique_ptr<BackendBase> Backend;
-
-
-    ALCdevice(DeviceType type);
-    ALCdevice(const ALCdevice&) = delete;
-    ALCdevice& operator=(const ALCdevice&) = delete;
-    ~ALCdevice();
-
-    ALuint bytesFromFmt() const noexcept { return BytesFromDevFmt(FmtType); }
-    ALuint channelsFromFmt() const noexcept { return ChannelsFromDevFmt(FmtChans, mAmbiOrder); }
-    ALuint frameSizeFromFmt() const noexcept { return bytesFromFmt() * channelsFromFmt(); }
-
-    void ProcessHrtf(const size_t SamplesToDo);
-    void ProcessAmbiDec(const size_t SamplesToDo);
-    void ProcessUhj(const size_t SamplesToDo);
-    void ProcessBs2b(const size_t SamplesToDo);
-
-    inline void postProcess(const size_t SamplesToDo)
-    { if LIKELY(PostProcess) (this->*PostProcess)(SamplesToDo); }
-
-    DEF_NEWDEL(ALCdevice)
-};
-
-/* Must be less than 15 characters (16 including terminating null) for
- * compatibility with pthread_setname_np limitations. */
-#define MIXER_THREAD_NAME "alsoft-mixer"
-
-#define RECORD_THREAD_NAME "alsoft-record"
-
-
-extern ALint RTPrioLevel;
-void SetRTPriority(void);
-
-void SetDefaultChannelOrder(ALCdevice *device);
-void SetDefaultWFXChannelOrder(ALCdevice *device);
-
-const ALCchar *DevFmtTypeString(DevFmtType type) noexcept;
-const ALCchar *DevFmtChannelsString(DevFmtChannels chans) noexcept;
-
-/**
- * GetChannelIdxByName
- *
- * Returns the index for the given channel name (e.g. FrontCenter), or
- * INVALID_CHANNEL_INDEX if it doesn't exist.
- */
-inline ALuint GetChannelIdxByName(const RealMixParams &real, Channel chan) noexcept
-{ return real.ChannelIndex[chan]; }
-#define INVALID_CHANNEL_INDEX ~0u
-
-
-al::vector<std::string> SearchDataFiles(const char *match, const char *subdir);
-
-#endif
diff --git a/alc/alconfig.cpp b/alc/alconfig.cpp
index ede39156..b0544b89 100644
--- a/alc/alconfig.cpp
+++ b/alc/alconfig.cpp
@@ -18,14 +18,6 @@
  * Or go to http://www.gnu.org/copyleft/lgpl.html
  */
 
-#ifdef _WIN32
-#ifdef __MINGW32__
-#define _WIN32_IE 0x501
-#else
-#define _WIN32_IE 0x400
-#endif
-#endif
-
 #include "config.h"
 
 #include "alconfig.h"
@@ -33,7 +25,7 @@
 #include <cstdlib>
 #include <cctype>
 #include <cstring>
-#ifdef _WIN32_IE
+#ifdef _WIN32
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ -48,8 +40,8 @@
 
 #include "alfstream.h"
 #include "alstring.h"
-#include "compat.h"
-#include "logging.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "strutils.h"
 #include "vector.h"
 
@@ -148,7 +140,7 @@ void LoadConfigFromFile(std::istream &f)
 
         if(buffer[0] == '[')
         {
-            char *line{&buffer[0]};
+            auto line = const_cast<char*>(buffer.data());
             char *section = line+1;
             char *endsection;
 
@@ -224,35 +216,28 @@ void LoadConfigFromFile(std::istream &f)
             continue;
         }
 
-        auto cmtpos = buffer.find('#');
-        if(cmtpos != std::string::npos)
-            buffer.resize(cmtpos);
-        while(!buffer.empty() && std::isspace(buffer.back()))
-            buffer.pop_back();
-        if(buffer.empty()) continue;
-
-        const char *line{&buffer[0]};
-        char key[256]{};
-        char value[256]{};
-        if(std::sscanf(line, "%255[^=] = \"%255[^\"]\"", key, value) == 2 ||
-           std::sscanf(line, "%255[^=] = '%255[^\']'", key, value) == 2 ||
-           std::sscanf(line, "%255[^=] = %255[^\n]", key, value) == 2)
-        {
-            /* sscanf doesn't handle '' or "" as empty values, so clip it
-             * manually. */
-            if(std::strcmp(value, "\"\"") == 0 || std::strcmp(value, "''") == 0)
-                value[0] = 0;
-        }
-        else if(std::sscanf(line, "%255[^=] %255[=]", key, value) == 2)
+        auto cmtpos = std::min(buffer.find('#'), buffer.size());
+        while(cmtpos > 0 && std::isspace(buffer[cmtpos-1]))
+            --cmtpos;
+        if(!cmtpos) continue;
+        buffer.erase(cmtpos);
+
+        auto sep = buffer.find('=');
+        if(sep == std::string::npos)
         {
-            /* Special case for 'key =' */
-            value[0] = 0;
+            ERR(" config parse error: malformed option line: \"%s\"\n", buffer.c_str());
+            continue;
         }
-        else
+        auto keyend = sep++;
+        while(keyend > 0 && std::isspace(buffer[keyend-1]))
+            --keyend;
+        if(!keyend)
         {
-            ERR(" config parse error: malformed option line: \"%s\"\n\n", line);
+            ERR(" config parse error: malformed option line: \"%s\"\n", buffer.c_str());
             continue;
         }
+        while(sep < buffer.size() && std::isspace(buffer[sep]))
+            sep++;
 
         std::string fullKey;
         if(!curSection.empty())
@@ -260,30 +245,84 @@ void LoadConfigFromFile(std::istream &f)
             fullKey += curSection;
             fullKey += '/';
         }
-        fullKey += key;
-        while(!fullKey.empty() && std::isspace(fullKey.back()))
-            fullKey.pop_back();
+        fullKey += buffer.substr(0u, keyend);
 
-        TRACE(" found '%s' = '%s'\n", fullKey.c_str(), value);
+        std::string value{(sep < buffer.size()) ? buffer.substr(sep) : std::string{}};
+        if(value.size() > 1)
+        {
+            if((value.front() == '"' && value.back() == '"')
+                || (value.front() == '\'' && value.back() == '\''))
+            {
+                value.pop_back();
+                value.erase(value.begin());
+            }
+        }
+
+        TRACE(" found '%s' = '%s'\n", fullKey.c_str(), value.c_str());
 
         /* Check if we already have this option set */
-        auto ent = std::find_if(ConfOpts.begin(), ConfOpts.end(),
-            [&fullKey](const ConfigEntry &entry) -> bool
-            { return entry.key == fullKey; }
-        );
+        auto find_key = [&fullKey](const ConfigEntry &entry) -> bool
+        { return entry.key == fullKey; };
+        auto ent = std::find_if(ConfOpts.begin(), ConfOpts.end(), find_key);
         if(ent != ConfOpts.end())
         {
-            if(value[0])
-                ent->value = expdup(value);
+            if(!value.empty())
+                ent->value = expdup(value.c_str());
             else
                 ConfOpts.erase(ent);
         }
-        else if(value[0])
-            ConfOpts.emplace_back(ConfigEntry{std::move(fullKey), expdup(value)});
+        else if(!value.empty())
+            ConfOpts.emplace_back(ConfigEntry{std::move(fullKey), expdup(value.c_str())});
     }
     ConfOpts.shrink_to_fit();
 }
 
+const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName)
+{
+    if(!keyName)
+        return nullptr;
+
+    std::string key;
+    if(blockName && al::strcasecmp(blockName, "general") != 0)
+    {
+        key = blockName;
+        if(devName)
+        {
+            key += '/';
+            key += devName;
+        }
+        key += '/';
+        key += keyName;
+    }
+    else
+    {
+        if(devName)
+        {
+            key = devName;
+            key += '/';
+        }
+        key += keyName;
+    }
+
+    auto iter = std::find_if(ConfOpts.cbegin(), ConfOpts.cend(),
+        [&key](const ConfigEntry &entry) -> bool
+        { return entry.key == key; });
+    if(iter != ConfOpts.cend())
+    {
+        TRACE("Found %s = \"%s\"\n", key.c_str(), iter->value.c_str());
+        if(!iter->value.empty())
+            return iter->value.c_str();
+        return nullptr;
+    }
+
+    if(!devName)
+    {
+        TRACE("Key %s not found\n", key.c_str());
+        return nullptr;
+    }
+    return GetConfigValue(nullptr, blockName, keyName);
+}
+
 } // namespace
 
 
@@ -444,106 +483,46 @@ void ReadALConfig()
 }
 #endif
 
-const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName, const char *def)
-{
-    if(!keyName)
-        return def;
-
-    std::string key;
-    if(blockName && al::strcasecmp(blockName, "general") != 0)
-    {
-        key = blockName;
-        if(devName)
-        {
-            key += '/';
-            key += devName;
-        }
-        key += '/';
-        key += keyName;
-    }
-    else
-    {
-        if(devName)
-        {
-            key = devName;
-            key += '/';
-        }
-        key += keyName;
-    }
-
-    auto iter = std::find_if(ConfOpts.cbegin(), ConfOpts.cend(),
-        [&key](const ConfigEntry &entry) -> bool
-        { return entry.key == key; }
-    );
-    if(iter != ConfOpts.cend())
-    {
-        TRACE("Found %s = \"%s\"\n", key.c_str(), iter->value.c_str());
-        if(!iter->value.empty())
-            return iter->value.c_str();
-        return def;
-    }
-
-    if(!devName)
-    {
-        TRACE("Key %s not found\n", key.c_str());
-        return def;
-    }
-    return GetConfigValue(nullptr, blockName, keyName, def);
-}
-
-int ConfigValueExists(const char *devName, const char *blockName, const char *keyName)
-{
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    return val[0] != 0;
-}
-
 al::optional<std::string> ConfigValueStr(const char *devName, const char *blockName, const char *keyName)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    if(!val[0]) return al::nullopt;
-
-    return al::make_optional<std::string>(val);
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return val;
+    return al::nullopt;
 }
 
 al::optional<int> ConfigValueInt(const char *devName, const char *blockName, const char *keyName)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    if(!val[0]) return al::nullopt;
-
-    return al::make_optional(static_cast<int>(std::strtol(val, nullptr, 0)));
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return static_cast<int>(std::strtol(val, nullptr, 0));
+    return al::nullopt;
 }
 
 al::optional<unsigned int> ConfigValueUInt(const char *devName, const char *blockName, const char *keyName)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    if(!val[0]) return al::nullopt;
-
-    return al::make_optional(static_cast<unsigned int>(std::strtoul(val, nullptr, 0)));
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return static_cast<unsigned int>(std::strtoul(val, nullptr, 0));
+    return al::nullopt;
 }
 
 al::optional<float> ConfigValueFloat(const char *devName, const char *blockName, const char *keyName)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    if(!val[0]) return al::nullopt;
-
-    return al::make_optional(std::strtof(val, nullptr));
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return std::strtof(val, nullptr);
+    return al::nullopt;
 }
 
 al::optional<bool> ConfigValueBool(const char *devName, const char *blockName, const char *keyName)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-    if(!val[0]) return al::nullopt;
-
-    return al::make_optional(
-        al::strcasecmp(val, "true") == 0 || al::strcasecmp(val, "yes") == 0 ||
-        al::strcasecmp(val, "on") == 0 || atoi(val) != 0);
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return al::strcasecmp(val, "on") == 0 || al::strcasecmp(val, "yes") == 0
+            || al::strcasecmp(val, "true")==0 || atoi(val) != 0;
+    return al::nullopt;
 }
 
-int GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, int def)
+bool GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, bool def)
 {
-    const char *val = GetConfigValue(devName, blockName, keyName, "");
-
-    if(!val[0]) return def != 0;
-    return (al::strcasecmp(val, "true") == 0 || al::strcasecmp(val, "yes") == 0 ||
-            al::strcasecmp(val, "on") == 0 || atoi(val) != 0);
+    if(const char *val{GetConfigValue(devName, blockName, keyName)})
+        return (al::strcasecmp(val, "on") == 0 || al::strcasecmp(val, "yes") == 0
+            || al::strcasecmp(val, "true") == 0 || atoi(val) != 0);
+    return def;
 }
diff --git a/alc/alconfig.h b/alc/alconfig.h
index ffc7adad..df2830cc 100644
--- a/alc/alconfig.h
+++ b/alc/alconfig.h
@@ -7,9 +7,7 @@
 
 void ReadALConfig();
 
-int ConfigValueExists(const char *devName, const char *blockName, const char *keyName);
-const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName, const char *def);
-int GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, int def);
+bool GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, bool def);
 
 al::optional<std::string> ConfigValueStr(const char *devName, const char *blockName, const char *keyName);
 al::optional<int> ConfigValueInt(const char *devName, const char *blockName, const char *keyName);
diff --git a/alc/alcontext.h b/alc/alcontext.h
deleted file mode 100644
index ba3942f5..00000000
--- a/alc/alcontext.h
+++ /dev/null
@@ -1,196 +0,0 @@
-#ifndef ALCONTEXT_H
-#define ALCONTEXT_H
-
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <thread>
-#include <utility>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-
-#include "al/listener.h"
-#include "almalloc.h"
-#include "alnumeric.h"
-#include "alu.h"
-#include "atomic.h"
-#include "inprogext.h"
-#include "intrusive_ptr.h"
-#include "logging.h"
-#include "threads.h"
-#include "vector.h"
-#include "voice.h"
-
-struct ALeffectslot;
-struct ALeffectslotProps;
-struct ALsource;
-struct RingBuffer;
-
-
-enum class DistanceModel {
-    InverseClamped  = AL_INVERSE_DISTANCE_CLAMPED,
-    LinearClamped   = AL_LINEAR_DISTANCE_CLAMPED,
-    ExponentClamped = AL_EXPONENT_DISTANCE_CLAMPED,
-    Inverse  = AL_INVERSE_DISTANCE,
-    Linear   = AL_LINEAR_DISTANCE,
-    Exponent = AL_EXPONENT_DISTANCE,
-    Disable  = AL_NONE,
-
-    Default = InverseClamped
-};
-
-
-struct ALcontextProps {
-    ALfloat DopplerFactor;
-    ALfloat DopplerVelocity;
-    ALfloat SpeedOfSound;
-    ALboolean SourceDistanceModel;
-    DistanceModel mDistanceModel;
-
-    std::atomic<ALcontextProps*> next;
-
-    DEF_NEWDEL(ALcontextProps)
-};
-
-
-struct SourceSubList {
-    uint64_t FreeMask{~0_u64};
-    ALsource *Sources{nullptr}; /* 64 */
-
-    SourceSubList() noexcept = default;
-    SourceSubList(const SourceSubList&) = delete;
-    SourceSubList(SourceSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Sources{rhs.Sources}
-    { rhs.FreeMask = ~0_u64; rhs.Sources = nullptr; }
-    ~SourceSubList();
-
-    SourceSubList& operator=(const SourceSubList&) = delete;
-    SourceSubList& operator=(SourceSubList&& rhs) noexcept
-    { std::swap(FreeMask, rhs.FreeMask); std::swap(Sources, rhs.Sources); return *this; }
-};
-
-struct EffectSlotSubList {
-    uint64_t FreeMask{~0_u64};
-    ALeffectslot *EffectSlots{nullptr}; /* 64 */
-
-    EffectSlotSubList() noexcept = default;
-    EffectSlotSubList(const EffectSlotSubList&) = delete;
-    EffectSlotSubList(EffectSlotSubList&& rhs) noexcept
-      : FreeMask{rhs.FreeMask}, EffectSlots{rhs.EffectSlots}
-    { rhs.FreeMask = ~0_u64; rhs.EffectSlots = nullptr; }
-    ~EffectSlotSubList();
-
-    EffectSlotSubList& operator=(const EffectSlotSubList&) = delete;
-    EffectSlotSubList& operator=(EffectSlotSubList&& rhs) noexcept
-    { std::swap(FreeMask, rhs.FreeMask); std::swap(EffectSlots, rhs.EffectSlots); return *this; }
-};
-
-struct ALCcontext : public al::intrusive_ref<ALCcontext> {
-    al::vector<SourceSubList> mSourceList;
-    ALuint mNumSources{0};
-    std::mutex mSourceLock;
-
-    al::vector<EffectSlotSubList> mEffectSlotList;
-    ALuint mNumEffectSlots{0u};
-    std::mutex mEffectSlotLock;
-
-    std::atomic<ALenum> mLastError{AL_NO_ERROR};
-
-    DistanceModel mDistanceModel{DistanceModel::Default};
-    ALboolean mSourceDistanceModel{AL_FALSE};
-
-    ALfloat mDopplerFactor{1.0f};
-    ALfloat mDopplerVelocity{1.0f};
-    ALfloat mSpeedOfSound{SPEEDOFSOUNDMETRESPERSEC};
-
-    std::atomic_flag mPropsClean;
-    std::atomic<bool> mDeferUpdates{false};
-
-    std::mutex mPropLock;
-
-    /* Counter for the pre-mixing updates, in 31.1 fixed point (lowest bit
-     * indicates if updates are currently happening).
-     */
-    RefCount mUpdateCount{0u};
-    std::atomic<bool> mHoldUpdates{false};
-
-    ALfloat mGainBoost{1.0f};
-
-    std::atomic<ALcontextProps*> mUpdate{nullptr};
-
-    /* Linked lists of unused property containers, free to use for future
-     * updates.
-     */
-    std::atomic<ALcontextProps*> mFreeContextProps{nullptr};
-    std::atomic<ALlistenerProps*> mFreeListenerProps{nullptr};
-    std::atomic<ALvoiceProps*> mFreeVoiceProps{nullptr};
-    std::atomic<ALeffectslotProps*> mFreeEffectslotProps{nullptr};
-
-    al::vector<ALvoice> mVoices;
-
-    using ALeffectslotArray = al::FlexArray<ALeffectslot*>;
-    std::atomic<ALeffectslotArray*> mActiveAuxSlots{nullptr};
-
-    std::thread mEventThread;
-    al::semaphore mEventSem;
-    std::unique_ptr<RingBuffer> mAsyncEvents;
-    std::atomic<ALbitfieldSOFT> mEnabledEvts{0u};
-    std::mutex mEventCbLock;
-    ALEVENTPROCSOFT mEventCb{};
-    void *mEventParam{nullptr};
-
-    /* Default effect slot */
-    std::unique_ptr<ALeffectslot> mDefaultSlot;
-
-    const al::intrusive_ptr<ALCdevice> mDevice;
-    const ALCchar *mExtensionList{nullptr};
-
-    ALlistener mListener{};
-
-
-    ALCcontext(al::intrusive_ptr<ALCdevice> device);
-    ALCcontext(const ALCcontext&) = delete;
-    ALCcontext& operator=(const ALCcontext&) = delete;
-    ~ALCcontext();
-
-    void init();
-    /**
-     * Removes the context from its device and removes it from being current on
-     * the running thread or globally. Returns true if other contexts still
-     * exist on the device.
-     */
-    bool deinit();
-
-    /**
-     * Defers/suspends updates for the given context's listener and sources.
-     * This does *NOT* stop mixing, but rather prevents certain property
-     * changes from taking effect.
-     */
-    void deferUpdates() noexcept { mDeferUpdates.store(true); }
-
-    /** Resumes update processing after being deferred. */
-    void processUpdates();
-
-    void setError(ALenum errorCode, const char *msg, ...) DECL_FORMAT(printf, 3, 4);
-
-    DEF_NEWDEL(ALCcontext)
-};
-
-#define SETERR_RETURN(ctx, err, retval, ...) do {                             \
-    (ctx)->setError((err), __VA_ARGS__);                                      \
-    return retval;                                                            \
-} while(0)
-
-
-using ContextRef = al::intrusive_ptr<ALCcontext>;
-
-ContextRef GetContextRef(void);
-
-void UpdateContextProps(ALCcontext *context);
-
-
-extern bool TrapALError;
-
-#endif /* ALCONTEXT_H */
diff --git a/alc/alu.cpp b/alc/alu.cpp
index 9bf052e1..e9ad68b1 100644
--- a/alc/alu.cpp
+++ b/alc/alu.cpp
@@ -25,9 +25,9 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <cassert>
 #include <chrono>
 #include <climits>
-#include <cmath>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
@@ -36,62 +36,83 @@
 #include <limits>
 #include <memory>
 #include <new>
-#include <numeric>
+#include <stdint.h>
 #include <utility>
 
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "AL/efx.h"
-
-#include "al/auxeffectslot.h"
-#include "al/buffer.h"
-#include "al/effect.h"
-#include "al/event.h"
-#include "al/listener.h"
-#include "alcmain.h"
-#include "alcontext.h"
 #include "almalloc.h"
+#include "alnumbers.h"
 #include "alnumeric.h"
 #include "alspan.h"
 #include "alstring.h"
-#include "ambidefs.h"
 #include "atomic.h"
-#include "bformatdec.h"
-#include "bs2b.h"
-#include "cpu_caps.h"
-#include "devformat.h"
-#include "effects/base.h"
-#include "filters/biquad.h"
-#include "filters/nfc.h"
-#include "filters/splitter.h"
-#include "fpu_modes.h"
-#include "hrtf.h"
-#include "inprogext.h"
-#include "mastering.h"
-#include "math_defs.h"
-#include "mixer/defs.h"
+#include "core/ambidefs.h"
+#include "core/async_event.h"
+#include "core/bformatdec.h"
+#include "core/bs2b.h"
+#include "core/bsinc_defs.h"
+#include "core/bsinc_tables.h"
+#include "core/bufferline.h"
+#include "core/buffer_storage.h"
+#include "core/context.h"
+#include "core/cpu_caps.h"
+#include "core/cubic_tables.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effects/base.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/filters/nfc.h"
+#include "core/fpu_ctrl.h"
+#include "core/hrtf.h"
+#include "core/mastering.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "core/mixer/hrtfdefs.h"
+#include "core/resampler_limits.h"
+#include "core/uhjfilter.h"
+#include "core/voice.h"
+#include "core/voice_change.h"
+#include "intrusive_ptr.h"
 #include "opthelpers.h"
 #include "ringbuffer.h"
 #include "strutils.h"
 #include "threads.h"
-#include "uhjfilter.h"
 #include "vecmat.h"
-#include "voice.h"
+#include "vector.h"
 
-#include "bsinc_inc.h"
+struct CTag;
+#ifdef HAVE_SSE
+struct SSETag;
+#endif
+#ifdef HAVE_SSE2
+struct SSE2Tag;
+#endif
+#ifdef HAVE_SSE4_1
+struct SSE4Tag;
+#endif
+#ifdef HAVE_NEON
+struct NEONTag;
+#endif
+struct PointTag;
+struct LerpTag;
+struct CubicTag;
+struct BSincTag;
+struct FastBSincTag;
 
 
-static_assert(!(MAX_RESAMPLER_PADDING&1) && MAX_RESAMPLER_PADDING >= bsinc24.m[0],
-    "MAX_RESAMPLER_PADDING is not a multiple of two, or is too small");
+static_assert(!(MaxResamplerPadding&1), "MaxResamplerPadding is not a multiple of two");
 
 
 namespace {
 
+using uint = unsigned int;
+using namespace std::chrono;
+
 using namespace std::placeholders;
 
-ALfloat InitConeScale()
+float InitConeScale()
 {
-    ALfloat ret{1.0f};
+    float ret{1.0f};
     if(auto optval = al::getenv("__ALSOFT_HALF_ANGLE_CONES"))
     {
         if(al::strcasecmp(optval->c_str(), "true") == 0
@@ -100,65 +121,31 @@ ALfloat InitConeScale()
     }
     return ret;
 }
-
-ALfloat InitZScale()
-{
-    ALfloat ret{1.0f};
-    if(auto optval = al::getenv("__ALSOFT_REVERSE_Z"))
-    {
-        if(al::strcasecmp(optval->c_str(), "true") == 0
-            || strtol(optval->c_str(), nullptr, 0) == 1)
-            ret *= -1.0f;
-    }
-    return ret;
-}
-
-} // namespace
-
 /* Cone scalar */
-const ALfloat ConeScale{InitConeScale()};
+const float ConeScale{InitConeScale()};
 
-/* Localized Z scalar for mono sources */
-const ALfloat ZScale{InitZScale()};
+/* Localized scalars for mono sources (initialized in aluInit, after
+ * configuration is loaded).
+ */
+float XScale{1.0f};
+float YScale{1.0f};
+float ZScale{1.0f};
 
-MixerFunc MixSamples{Mix_<CTag>};
-RowMixerFunc MixRowSamples{MixRow_<CTag>};
+/* Source distance scale for NFC filters. */
+float NfcScale{1.0f};
 
-namespace {
 
 struct ChanMap {
     Channel channel;
-    ALfloat angle;
-    ALfloat elevation;
+    float angle;
+    float elevation;
 };
 
-HrtfDirectMixerFunc MixDirectHrtf = MixDirectHrtf_<CTag>;
+using HrtfDirectMixerFunc = void(*)(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, float *TempBuf,
+    HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize);
 
-inline MixerFunc SelectMixer()
-{
-#ifdef HAVE_NEON
-    if((CPUCapFlags&CPU_CAP_NEON))
-        return Mix_<NEONTag>;
-#endif
-#ifdef HAVE_SSE
-    if((CPUCapFlags&CPU_CAP_SSE))
-        return Mix_<SSETag>;
-#endif
-    return Mix_<CTag>;
-}
-
-inline RowMixerFunc SelectRowMixer()
-{
-#ifdef HAVE_NEON
-    if((CPUCapFlags&CPU_CAP_NEON))
-        return MixRow_<NEONTag>;
-#endif
-#ifdef HAVE_SSE
-    if((CPUCapFlags&CPU_CAP_SSE))
-        return MixRow_<SSETag>;
-#endif
-    return MixRow_<CTag>;
-}
+HrtfDirectMixerFunc MixDirectHrtf{MixDirectHrtf_<CTag>};
 
 inline HrtfDirectMixerFunc SelectHrtfMixer(void)
 {
@@ -175,15 +162,15 @@ inline HrtfDirectMixerFunc SelectHrtfMixer(void)
 }
 
 
-inline void BsincPrepare(const ALuint increment, BsincState *state, const BSincTable *table)
+inline void BsincPrepare(const uint increment, BsincState *state, const BSincTable *table)
 {
-    size_t si{BSINC_SCALE_COUNT - 1};
+    size_t si{BSincScaleCount - 1};
     float sf{0.0f};
 
-    if(increment > FRACTIONONE)
+    if(increment > MixerFracOne)
     {
-        sf = FRACTIONONE / static_cast<float>(increment);
-        sf = maxf(0.0f, (BSINC_SCALE_COUNT-1) * (sf-table->scaleBase) * table->scaleRange);
+        sf = MixerFracOne/static_cast<float>(increment) - table->scaleBase;
+        sf = maxf(0.0f, BSincScaleCount*sf*table->scaleRange - 1.0f);
         si = float2uint(sf);
         /* The interpolation factor is fit to this diagonally-symmetric curve
          * to reduce the transition ripple caused by interpolating different
@@ -198,7 +185,7 @@ inline void BsincPrepare(const ALuint increment, BsincState *state, const BSincT
     state->filter = table->Tab + table->filterOffset[si];
 }
 
-inline ResamplerFunc SelectResampler(Resampler resampler, ALuint increment)
+inline ResamplerFunc SelectResampler(Resampler resampler, uint increment)
 {
     switch(resampler)
     {
@@ -219,33 +206,41 @@ inline ResamplerFunc SelectResampler(Resampler resampler, ALuint increment)
 #endif
         return Resample_<LerpTag,CTag>;
     case Resampler::Cubic:
+#ifdef HAVE_NEON
+        if((CPUCapFlags&CPU_CAP_NEON))
+            return Resample_<CubicTag,NEONTag>;
+#endif
+#ifdef HAVE_SSE
+        if((CPUCapFlags&CPU_CAP_SSE))
+            return Resample_<CubicTag,SSETag>;
+#endif
         return Resample_<CubicTag,CTag>;
     case Resampler::BSinc12:
     case Resampler::BSinc24:
-        if(increment <= FRACTIONONE)
+        if(increment > MixerFracOne)
         {
-            /* fall-through */
-        case Resampler::FastBSinc12:
-        case Resampler::FastBSinc24:
 #ifdef HAVE_NEON
             if((CPUCapFlags&CPU_CAP_NEON))
-                return Resample_<FastBSincTag,NEONTag>;
+                return Resample_<BSincTag,NEONTag>;
 #endif
 #ifdef HAVE_SSE
             if((CPUCapFlags&CPU_CAP_SSE))
-                return Resample_<FastBSincTag,SSETag>;
+                return Resample_<BSincTag,SSETag>;
 #endif
-            return Resample_<FastBSincTag,CTag>;
+            return Resample_<BSincTag,CTag>;
         }
+        /* fall-through */
+    case Resampler::FastBSinc12:
+    case Resampler::FastBSinc24:
 #ifdef HAVE_NEON
         if((CPUCapFlags&CPU_CAP_NEON))
-            return Resample_<BSincTag,NEONTag>;
+            return Resample_<FastBSincTag,NEONTag>;
 #endif
 #ifdef HAVE_SSE
         if((CPUCapFlags&CPU_CAP_SSE))
-            return Resample_<BSincTag,SSETag>;
+            return Resample_<FastBSincTag,SSETag>;
 #endif
-        return Resample_<BSincTag,CTag>;
+        return Resample_<FastBSincTag,CTag>;
     }
 
     return Resample_<PointTag,CTag>;
@@ -253,69 +248,85 @@ inline ResamplerFunc SelectResampler(Resampler resampler, ALuint increment)
 
 } // namespace
 
-void aluInit(void)
+void aluInit(CompatFlagBitset flags, const float nfcscale)
 {
-    MixSamples = SelectMixer();
-    MixRowSamples = SelectRowMixer();
     MixDirectHrtf = SelectHrtfMixer();
+    XScale = flags.test(CompatFlags::ReverseX) ? -1.0f : 1.0f;
+    YScale = flags.test(CompatFlags::ReverseY) ? -1.0f : 1.0f;
+    ZScale = flags.test(CompatFlags::ReverseZ) ? -1.0f : 1.0f;
+
+    NfcScale = clampf(nfcscale, 0.0001f, 10000.0f);
 }
 
 
-ResamplerFunc PrepareResampler(Resampler resampler, ALuint increment, InterpState *state)
+ResamplerFunc PrepareResampler(Resampler resampler, uint increment, InterpState *state)
 {
     switch(resampler)
     {
     case Resampler::Point:
     case Resampler::Linear:
+        break;
     case Resampler::Cubic:
+        state->cubic.filter = gCubicSpline.Tab.data();
         break;
     case Resampler::FastBSinc12:
     case Resampler::BSinc12:
-        BsincPrepare(increment, &state->bsinc, &bsinc12);
+        BsincPrepare(increment, &state->bsinc, &gBSinc12);
         break;
     case Resampler::FastBSinc24:
     case Resampler::BSinc24:
-        BsincPrepare(increment, &state->bsinc, &bsinc24);
+        BsincPrepare(increment, &state->bsinc, &gBSinc24);
         break;
     }
     return SelectResampler(resampler, increment);
 }
 
 
-void ALCdevice::ProcessHrtf(const size_t SamplesToDo)
+void DeviceBase::ProcessHrtf(const size_t SamplesToDo)
 {
     /* HRTF is stereo output only. */
-    const ALuint lidx{RealOut.ChannelIndex[FrontLeft]};
-    const ALuint ridx{RealOut.ChannelIndex[FrontRight]};
+    const uint lidx{RealOut.ChannelIndex[FrontLeft]};
+    const uint ridx{RealOut.ChannelIndex[FrontRight]};
 
     MixDirectHrtf(RealOut.Buffer[lidx], RealOut.Buffer[ridx], Dry.Buffer, HrtfAccumData,
-        mHrtfState.get(), SamplesToDo);
+        mHrtfState->mTemp.data(), mHrtfState->mChannels.data(), mHrtfState->mIrSize, SamplesToDo);
 }
 
-void ALCdevice::ProcessAmbiDec(const size_t SamplesToDo)
+void DeviceBase::ProcessAmbiDec(const size_t SamplesToDo)
 {
     AmbiDecoder->process(RealOut.Buffer, Dry.Buffer.data(), SamplesToDo);
 }
 
-void ALCdevice::ProcessUhj(const size_t SamplesToDo)
+void DeviceBase::ProcessAmbiDecStablized(const size_t SamplesToDo)
+{
+    /* Decode with front image stablization. */
+    const uint lidx{RealOut.ChannelIndex[FrontLeft]};
+    const uint ridx{RealOut.ChannelIndex[FrontRight]};
+    const uint cidx{RealOut.ChannelIndex[FrontCenter]};
+
+    AmbiDecoder->processStablize(RealOut.Buffer, Dry.Buffer.data(), lidx, ridx, cidx,
+        SamplesToDo);
+}
+
+void DeviceBase::ProcessUhj(const size_t SamplesToDo)
 {
     /* UHJ is stereo output only. */
-    const ALuint lidx{RealOut.ChannelIndex[FrontLeft]};
-    const ALuint ridx{RealOut.ChannelIndex[FrontRight]};
+    const uint lidx{RealOut.ChannelIndex[FrontLeft]};
+    const uint ridx{RealOut.ChannelIndex[FrontRight]};
 
     /* Encode to stereo-compatible 2-channel UHJ output. */
-    Uhj_Encoder->encode(RealOut.Buffer[lidx], RealOut.Buffer[ridx], Dry.Buffer.data(),
-        SamplesToDo);
+    mUhjEncoder->encode(RealOut.Buffer[lidx].data(), RealOut.Buffer[ridx].data(),
+        {{Dry.Buffer[0].data(), Dry.Buffer[1].data(), Dry.Buffer[2].data()}}, SamplesToDo);
 }
 
-void ALCdevice::ProcessBs2b(const size_t SamplesToDo)
+void DeviceBase::ProcessBs2b(const size_t SamplesToDo)
 {
     /* First, decode the ambisonic mix to the "real" output. */
     AmbiDecoder->process(RealOut.Buffer, Dry.Buffer.data(), SamplesToDo);
 
     /* BS2B is stereo output only. */
-    const ALuint lidx{RealOut.ChannelIndex[FrontLeft]};
-    const ALuint ridx{RealOut.ChannelIndex[FrontRight]};
+    const uint lidx{RealOut.ChannelIndex[FrontLeft]};
+    const uint ridx{RealOut.ChannelIndex[FrontRight]};
 
     /* Now apply the BS2B binaural/crossfeed filter. */
     bs2b_cross_feed(Bs2b.get(), RealOut.Buffer[lidx].data(), RealOut.Buffer[ridx].data(),
@@ -329,126 +340,145 @@ namespace {
  * and starting with a seed value of 22222, is suitable for generating
  * whitenoise.
  */
-inline ALuint dither_rng(ALuint *seed) noexcept
+inline uint dither_rng(uint *seed) noexcept
 {
     *seed = (*seed * 96314165) + 907633515;
     return *seed;
 }
 
 
-inline alu::Vector aluCrossproduct(const alu::Vector &in1, const alu::Vector &in2)
+/* Ambisonic upsampler function. It's effectively a matrix multiply. It takes
+ * an 'upsampler' and 'rotator' as the input matrices, and creates a matrix
+ * that behaves as if the B-Format input was first decoded to a speaker array
+ * at its input order, encoded back into the higher order mix, then finally
+ * rotated.
+ */
+void UpsampleBFormatTransform(
+    const al::span<std::array<float,MaxAmbiChannels>,MaxAmbiChannels> output,
+    const al::span<const std::array<float,MaxAmbiChannels>> upsampler,
+    const al::span<std::array<float,MaxAmbiChannels>,MaxAmbiChannels> rotator, size_t coeffs_order)
 {
-    return alu::Vector{
-        in1[1]*in2[2] - in1[2]*in2[1],
-        in1[2]*in2[0] - in1[0]*in2[2],
-        in1[0]*in2[1] - in1[1]*in2[0],
-        0.0f
-    };
+    const size_t num_chans{AmbiChannelsFromOrder(coeffs_order)};
+    for(size_t i{0};i < upsampler.size();++i)
+        output[i].fill(0.0f);
+    for(size_t i{0};i < upsampler.size();++i)
+    {
+        for(size_t k{0};k < num_chans;++k)
+        {
+            float *RESTRICT out{output[i].data()};
+            /* Write the full number of channels. The compiler will have an
+             * easier time optimizing if it has a fixed length.
+             */
+            for(size_t j{0};j < MaxAmbiChannels;++j)
+                out[j] += upsampler[i][k] * rotator[k][j];
+        }
+    }
 }
 
-inline ALfloat aluDotproduct(const alu::Vector &vec1, const alu::Vector &vec2)
+
+inline auto& GetAmbiScales(AmbiScaling scaletype) noexcept
 {
-    return vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2];
+    switch(scaletype)
+    {
+    case AmbiScaling::FuMa: return AmbiScale::FromFuMa();
+    case AmbiScaling::SN3D: return AmbiScale::FromSN3D();
+    case AmbiScaling::UHJ: return AmbiScale::FromUHJ();
+    case AmbiScaling::N3D: break;
+    }
+    return AmbiScale::FromN3D();
 }
 
-
-alu::Vector operator*(const alu::Matrix &mtx, const alu::Vector &vec) noexcept
+inline auto& GetAmbiLayout(AmbiLayout layouttype) noexcept
 {
-    return alu::Vector{
-        vec[0]*mtx[0][0] + vec[1]*mtx[1][0] + vec[2]*mtx[2][0] + vec[3]*mtx[3][0],
-        vec[0]*mtx[0][1] + vec[1]*mtx[1][1] + vec[2]*mtx[2][1] + vec[3]*mtx[3][1],
-        vec[0]*mtx[0][2] + vec[1]*mtx[1][2] + vec[2]*mtx[2][2] + vec[3]*mtx[3][2],
-        vec[0]*mtx[0][3] + vec[1]*mtx[1][3] + vec[2]*mtx[2][3] + vec[3]*mtx[3][3]
-    };
+    if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa();
+    return AmbiIndex::FromACN();
 }
 
-
-bool CalcContextParams(ALCcontext *Context)
+inline auto& GetAmbi2DLayout(AmbiLayout layouttype) noexcept
 {
-    ALcontextProps *props{Context->mUpdate.exchange(nullptr, std::memory_order_acq_rel)};
-    if(!props) return false;
-
-    ALlistener &Listener = Context->mListener;
-    Listener.Params.DopplerFactor = props->DopplerFactor;
-    Listener.Params.SpeedOfSound = props->SpeedOfSound * props->DopplerVelocity;
-
-    Listener.Params.SourceDistanceModel = props->SourceDistanceModel;
-    Listener.Params.mDistanceModel = props->mDistanceModel;
-
-    AtomicReplaceHead(Context->mFreeContextProps, props);
-    return true;
+    if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D();
+    return AmbiIndex::FromACN2D();
 }
 
-bool CalcListenerParams(ALCcontext *Context)
-{
-    ALlistener &Listener = Context->mListener;
 
-    ALlistenerProps *props{Listener.Params.Update.exchange(nullptr, std::memory_order_acq_rel)};
+bool CalcContextParams(ContextBase *ctx)
+{
+    ContextProps *props{ctx->mParams.ContextUpdate.exchange(nullptr, std::memory_order_acq_rel)};
     if(!props) return false;
 
+    const alu::Vector pos{props->Position[0], props->Position[1], props->Position[2], 1.0f};
+    ctx->mParams.Position = pos;
+
     /* AT then UP */
     alu::Vector N{props->OrientAt[0], props->OrientAt[1], props->OrientAt[2], 0.0f};
     N.normalize();
     alu::Vector V{props->OrientUp[0], props->OrientUp[1], props->OrientUp[2], 0.0f};
     V.normalize();
     /* Build and normalize right-vector */
-    alu::Vector U{aluCrossproduct(N, V)};
+    alu::Vector U{N.cross_product(V)};
     U.normalize();
 
-    Listener.Params.Matrix = alu::Matrix{
-        U[0], V[0], -N[0], 0.0f,
-        U[1], V[1], -N[1], 0.0f,
-        U[2], V[2], -N[2], 0.0f,
-        0.0f, 0.0f,  0.0f, 1.0f
-    };
+    const alu::Matrix rot{
+        U[0], V[0], -N[0], 0.0,
+        U[1], V[1], -N[1], 0.0,
+        U[2], V[2], -N[2], 0.0,
+         0.0,  0.0,   0.0, 1.0};
+    const alu::Vector vel{props->Velocity[0], props->Velocity[1], props->Velocity[2], 0.0};
+
+    ctx->mParams.Matrix = rot;
+    ctx->mParams.Velocity = rot * vel;
 
-    const alu::Vector P{Listener.Params.Matrix *
-        alu::Vector{props->Position[0], props->Position[1], props->Position[2], 1.0f}};
-    Listener.Params.Matrix.setRow(3, -P[0], -P[1], -P[2], 1.0f);
+    ctx->mParams.Gain = props->Gain * ctx->mGainBoost;
+    ctx->mParams.MetersPerUnit = props->MetersPerUnit;
+    ctx->mParams.AirAbsorptionGainHF = props->AirAbsorptionGainHF;
 
-    const alu::Vector vel{props->Velocity[0], props->Velocity[1], props->Velocity[2], 0.0f};
-    Listener.Params.Velocity = Listener.Params.Matrix * vel;
+    ctx->mParams.DopplerFactor = props->DopplerFactor;
+    ctx->mParams.SpeedOfSound = props->SpeedOfSound * props->DopplerVelocity;
 
-    Listener.Params.Gain = props->Gain * Context->mGainBoost;
-    Listener.Params.MetersPerUnit = props->MetersPerUnit;
+    ctx->mParams.SourceDistanceModel = props->SourceDistanceModel;
+    ctx->mParams.mDistanceModel = props->mDistanceModel;
 
-    AtomicReplaceHead(Context->mFreeListenerProps, props);
+    AtomicReplaceHead(ctx->mFreeContextProps, props);
     return true;
 }
 
-bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context)
+bool CalcEffectSlotParams(EffectSlot *slot, EffectSlot **sorted_slots, ContextBase *context)
 {
-    ALeffectslotProps *props{slot->Params.Update.exchange(nullptr, std::memory_order_acq_rel)};
+    EffectSlotProps *props{slot->Update.exchange(nullptr, std::memory_order_acq_rel)};
     if(!props) return false;
 
-    slot->Params.Gain = props->Gain;
-    slot->Params.AuxSendAuto = props->AuxSendAuto;
-    slot->Params.Target = props->Target;
-    slot->Params.EffectType = props->Type;
-    slot->Params.mEffectProps = props->Props;
-    if(IsReverbEffect(props->Type))
+    /* If the effect slot target changed, clear the first sorted entry to force
+     * a re-sort.
+     */
+    if(slot->Target != props->Target)
+        *sorted_slots = nullptr;
+    slot->Gain = props->Gain;
+    slot->AuxSendAuto = props->AuxSendAuto;
+    slot->Target = props->Target;
+    slot->EffectType = props->Type;
+    slot->mEffectProps = props->Props;
+    if(props->Type == EffectSlotType::Reverb || props->Type == EffectSlotType::EAXReverb)
     {
-        slot->Params.RoomRolloff = props->Props.Reverb.RoomRolloffFactor;
-        slot->Params.DecayTime = props->Props.Reverb.DecayTime;
-        slot->Params.DecayLFRatio = props->Props.Reverb.DecayLFRatio;
-        slot->Params.DecayHFRatio = props->Props.Reverb.DecayHFRatio;
-        slot->Params.DecayHFLimit = props->Props.Reverb.DecayHFLimit;
-        slot->Params.AirAbsorptionGainHF = props->Props.Reverb.AirAbsorptionGainHF;
+        slot->RoomRolloff = props->Props.Reverb.RoomRolloffFactor;
+        slot->DecayTime = props->Props.Reverb.DecayTime;
+        slot->DecayLFRatio = props->Props.Reverb.DecayLFRatio;
+        slot->DecayHFRatio = props->Props.Reverb.DecayHFRatio;
+        slot->DecayHFLimit = props->Props.Reverb.DecayHFLimit;
+        slot->AirAbsorptionGainHF = props->Props.Reverb.AirAbsorptionGainHF;
     }
     else
     {
-        slot->Params.RoomRolloff = 0.0f;
-        slot->Params.DecayTime = 0.0f;
-        slot->Params.DecayLFRatio = 0.0f;
-        slot->Params.DecayHFRatio = 0.0f;
-        slot->Params.DecayHFLimit = AL_FALSE;
-        slot->Params.AirAbsorptionGainHF = 1.0f;
+        slot->RoomRolloff = 0.0f;
+        slot->DecayTime = 0.0f;
+        slot->DecayLFRatio = 0.0f;
+        slot->DecayHFRatio = 0.0f;
+        slot->DecayHFLimit = false;
+        slot->AirAbsorptionGainHF = 1.0f;
     }
 
-    EffectState *state{props->State};
-    props->State = nullptr;
-    EffectState *oldstate{slot->Params.mEffectState};
-    slot->Params.mEffectState = state;
+    EffectState *state{props->State.release()};
+    EffectState *oldstate{slot->mEffectState.release()};
+    slot->mEffectState.reset(state);
 
     /* Only release the old state if it won't get deleted, since we can't be
      * deleting/freeing anything in the mixer.
@@ -458,12 +488,12 @@ bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context)
         /* Otherwise, if it would be deleted send it off with a release event. */
         RingBuffer *ring{context->mAsyncEvents.get()};
         auto evt_vec = ring->getWriteVector();
-        if LIKELY(evt_vec.first.len > 0)
+        if(evt_vec.first.len > 0) LIKELY
         {
-            AsyncEvent *evt{new (evt_vec.first.buf) AsyncEvent{EventType_ReleaseEffectState}};
+            AsyncEvent *evt{al::construct_at(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf),
+                AsyncEvent::ReleaseEffectState)};
             evt->u.mEffectState = oldstate;
             ring->writeAdvance(1);
-            context->mEventSem.post();
         }
         else
         {
@@ -472,21 +502,21 @@ bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context)
              * cleaned up sometime later (not ideal, but better than blocking
              * or leaking).
              */
-            props->State = oldstate;
+            props->State.reset(oldstate);
         }
     }
 
     AtomicReplaceHead(context->mFreeEffectslotProps, props);
 
     EffectTarget output;
-    if(ALeffectslot *target{slot->Params.Target})
+    if(EffectSlot *target{slot->Target})
         output = EffectTarget{&target->Wet, nullptr};
     else
     {
-        ALCdevice *device{context->mDevice.get()};
+        DeviceBase *device{context->mDevice};
         output = EffectTarget{&device->Dry, &device->RealOut};
     }
-    state->update(context, slot, &slot->Params.mEffectProps, output);
+    state->update(context, slot, &slot->mEffectProps, output);
     return true;
 }
 
@@ -496,20 +526,188 @@ bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context)
  */
 inline float ScaleAzimuthFront(float azimuth, float scale)
 {
-    const ALfloat abs_azi{std::fabs(azimuth)};
-    if(!(abs_azi >= al::MathDefs<float>::Pi()*0.5f))
-        return std::copysign(minf(abs_azi*scale, al::MathDefs<float>::Pi()*0.5f), azimuth);
+    const float abs_azi{std::fabs(azimuth)};
+    if(!(abs_azi >= al::numbers::pi_v<float>*0.5f))
+        return std::copysign(minf(abs_azi*scale, al::numbers::pi_v<float>*0.5f), azimuth);
     return azimuth;
 }
 
-void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypos,
-    const ALfloat zpos, const ALfloat Distance, const ALfloat Spread, const ALfloat DryGain,
-    const ALfloat DryGainHF, const ALfloat DryGainLF, const ALfloat (&WetGain)[MAX_SENDS],
-    const ALfloat (&WetGainLF)[MAX_SENDS], const ALfloat (&WetGainHF)[MAX_SENDS],
-    ALeffectslot *(&SendSlots)[MAX_SENDS], const ALvoicePropsBase *props,
-    const ALlistener &Listener, const ALCdevice *Device)
+/* Wraps the given value in radians to stay between [-pi,+pi] */
+inline float WrapRadians(float r)
 {
-    static const ChanMap MonoMap[1]{
+    static constexpr float Pi{al::numbers::pi_v<float>};
+    static constexpr float Pi2{Pi*2.0f};
+    if(r >  Pi) return std::fmod(Pi+r, Pi2) - Pi;
+    if(r < -Pi) return Pi - std::fmod(Pi-r, Pi2);
+    return r;
+}
+
+/* Begin ambisonic rotation helpers.
+ *
+ * Rotating first-order B-Format just needs a straight-forward X/Y/Z rotation
+ * matrix. Higher orders, however, are more complicated. The method implemented
+ * here is a recursive algorithm (the rotation for first-order is used to help
+ * generate the second-order rotation, which helps generate the third-order
+ * rotation, etc).
+ *
+ * Adapted from
+ * <https://github.com/polarch/Spherical-Harmonic-Transform/blob/master/getSHrotMtx.m>,
+ * provided under the BSD 3-Clause license.
+ *
+ * Copyright (c) 2015, Archontis Politis
+ * Copyright (c) 2019, Christopher Robinson
+ *
+ * The u, v, and w coefficients used for generating higher-order rotations are
+ * precomputed since they're constant. The second-order coefficients are
+ * followed by the third-order coefficients, etc.
+ */
+template<size_t L>
+constexpr size_t CalcRotatorSize()
+{ return (L*2 + 1)*(L*2 + 1) + CalcRotatorSize<L-1>(); }
+
+template<> constexpr size_t CalcRotatorSize<0>() = delete;
+template<> constexpr size_t CalcRotatorSize<1>() = delete;
+template<> constexpr size_t CalcRotatorSize<2>() { return 5*5; }
+
+struct RotatorCoeffs {
+    struct CoeffValues {
+        float u, v, w;
+    };
+    std::array<CoeffValues,CalcRotatorSize<MaxAmbiOrder>()> mCoeffs{};
+
+    RotatorCoeffs()
+    {
+        auto coeffs = mCoeffs.begin();
+
+        for(int l=2;l <= MaxAmbiOrder;++l)
+        {
+            for(int n{-l};n <= l;++n)
+            {
+                for(int m{-l};m <= l;++m)
+                {
+                    // compute u,v,w terms of Eq.8.1 (Table I)
+                    const bool d{m == 0}; // the delta function d_m0
+                    const float denom{static_cast<float>((std::abs(n) == l) ?
+                        (2*l) * (2*l - 1) : (l*l - n*n))};
+
+                    const int abs_m{std::abs(m)};
+                    coeffs->u = std::sqrt(static_cast<float>(l*l - m*m)/denom);
+                    coeffs->v = std::sqrt(static_cast<float>(l+abs_m-1) *
+                        static_cast<float>(l+abs_m) / denom) * (1.0f+d) * (1.0f - 2.0f*d) * 0.5f;
+                    coeffs->w = std::sqrt(static_cast<float>(l-abs_m-1) *
+                        static_cast<float>(l-abs_m) / denom) * (1.0f-d) * -0.5f;
+                    ++coeffs;
+                }
+            }
+        }
+    }
+};
+const RotatorCoeffs RotatorCoeffArray{};
+
+/**
+ * Given the matrix, pre-filled with the (zeroth- and) first-order rotation
+ * coefficients, this fills in the coefficients for the higher orders up to and
+ * including the given order. The matrix is in ACN layout.
+ */
+void AmbiRotator(AmbiRotateMatrix &matrix, const int order)
+{
+    /* Don't do anything for < 2nd order. */
+    if(order < 2) return;
+
+    auto P = [](const int i, const int l, const int a, const int n, const size_t last_band,
+        const AmbiRotateMatrix &R)
+    {
+        const float ri1{ R[ 1+2][static_cast<size_t>(i+2)]};
+        const float rim1{R[-1+2][static_cast<size_t>(i+2)]};
+        const float ri0{ R[ 0+2][static_cast<size_t>(i+2)]};
+
+        const size_t y{last_band + static_cast<size_t>(a+l-1)};
+        if(n == -l)
+            return ri1*R[last_band][y] + rim1*R[last_band + static_cast<size_t>(l-1)*2][y];
+        if(n == l)
+            return ri1*R[last_band + static_cast<size_t>(l-1)*2][y] - rim1*R[last_band][y];
+        return ri0*R[last_band + static_cast<size_t>(n+l-1)][y];
+    };
+
+    auto U = [P](const int l, const int m, const int n, const size_t last_band,
+        const AmbiRotateMatrix &R)
+    {
+        return P(0, l, m, n, last_band, R);
+    };
+    auto V = [P](const int l, const int m, const int n, const size_t last_band,
+        const AmbiRotateMatrix &R)
+    {
+        using namespace al::numbers;
+        if(m > 0)
+        {
+            const bool d{m == 1};
+            const float p0{P( 1, l,  m-1, n, last_band, R)};
+            const float p1{P(-1, l, -m+1, n, last_band, R)};
+            return d ? p0*sqrt2_v<float> : (p0 - p1);
+        }
+        const bool d{m == -1};
+        const float p0{P( 1, l,  m+1, n, last_band, R)};
+        const float p1{P(-1, l, -m-1, n, last_band, R)};
+        return d ? p1*sqrt2_v<float> : (p0 + p1);
+    };
+    auto W = [P](const int l, const int m, const int n, const size_t last_band,
+        const AmbiRotateMatrix &R)
+    {
+        assert(m != 0);
+        if(m > 0)
+        {
+            const float p0{P( 1, l,  m+1, n, last_band, R)};
+            const float p1{P(-1, l, -m-1, n, last_band, R)};
+            return p0 + p1;
+        }
+        const float p0{P( 1, l,  m-1, n, last_band, R)};
+        const float p1{P(-1, l, -m+1, n, last_band, R)};
+        return p0 - p1;
+    };
+
+    // compute rotation matrix of each subsequent band recursively
+    auto coeffs = RotatorCoeffArray.mCoeffs.cbegin();
+    size_t band_idx{4}, last_band{1};
+    for(int l{2};l <= order;++l)
+    {
+        size_t y{band_idx};
+        for(int n{-l};n <= l;++n,++y)
+        {
+            size_t x{band_idx};
+            for(int m{-l};m <= l;++m,++x)
+            {
+                float r{0.0f};
+
+                // computes Eq.8.1
+                const float u{coeffs->u};
+                if(u != 0.0f) r += u * U(l, m, n, last_band, matrix);
+                const float v{coeffs->v};
+                if(v != 0.0f) r += v * V(l, m, n, last_band, matrix);
+                const float w{coeffs->w};
+                if(w != 0.0f) r += w * W(l, m, n, last_band, matrix);
+
+                matrix[y][x] = r;
+                ++coeffs;
+            }
+        }
+        last_band = band_idx;
+        band_idx += static_cast<uint>(l)*size_t{2} + 1;
+    }
+}
+/* End ambisonic rotation helpers. */
+
+
+constexpr float Deg2Rad(float x) noexcept
+{ return static_cast<float>(al::numbers::pi / 180.0 * x); }
+
+struct GainTriplet { float Base, HF, LF; };
+
+void CalcPanningAndFilters(Voice *voice, const float xpos, const float ypos, const float zpos,
+    const float Distance, const float Spread, const GainTriplet &DryGain,
+    const al::span<const GainTriplet,MAX_SENDS> WetGain, EffectSlot *(&SendSlots)[MAX_SENDS],
+    const VoiceProps *props, const ContextParams &Context, DeviceBase *Device)
+{
+    static constexpr ChanMap MonoMap[1]{
         { FrontCenter, 0.0f, 0.0f }
     }, RearMap[2]{
         { BackLeft,  Deg2Rad(-150.0f), Deg2Rad(0.0f) },
@@ -550,158 +748,134 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
         { FrontRight, Deg2Rad( 30.0f), Deg2Rad(0.0f) }
     };
 
-    const auto Frequency = static_cast<ALfloat>(Device->Frequency);
-    const ALuint NumSends{Device->NumAuxSends};
+    const auto Frequency = static_cast<float>(Device->Frequency);
+    const uint NumSends{Device->NumAuxSends};
+
+    const size_t num_channels{voice->mChans.size()};
+    ASSUME(num_channels > 0);
+
+    for(auto &chandata : voice->mChans)
+    {
+        chandata.mDryParams.Hrtf.Target = HrtfFilter{};
+        chandata.mDryParams.Gains.Target.fill(0.0f);
+        std::for_each(chandata.mWetParams.begin(), chandata.mWetParams.begin()+NumSends,
+            [](SendParams &params) -> void { params.Gains.Target.fill(0.0f); });
+    }
 
-    bool DirectChannels{props->DirectChannels != AL_FALSE};
+    DirectMode DirectChannels{props->DirectChannels};
     const ChanMap *chans{nullptr};
-    ALuint num_channels{0};
-    bool isbformat{false};
-    ALfloat downmix_gain{1.0f};
     switch(voice->mFmtChannels)
     {
     case FmtMono:
         chans = MonoMap;
-        num_channels = 1;
         /* Mono buffers are never played direct. */
-        DirectChannels = false;
+        DirectChannels = DirectMode::Off;
         break;
 
     case FmtStereo:
-        /* Convert counter-clockwise to clockwise. */
-        StereoMap[0].angle = -props->StereoPan[0];
-        StereoMap[1].angle = -props->StereoPan[1];
-
+        if(DirectChannels == DirectMode::Off)
+        {
+            /* Convert counter-clockwise to clock-wise, and wrap between
+             * [-pi,+pi].
+             */
+            StereoMap[0].angle = WrapRadians(-props->StereoPan[0]);
+            StereoMap[1].angle = WrapRadians(-props->StereoPan[1]);
+        }
         chans = StereoMap;
-        num_channels = 2;
-        downmix_gain = 1.0f / 2.0f;
         break;
 
-    case FmtRear:
-        chans = RearMap;
-        num_channels = 2;
-        downmix_gain = 1.0f / 2.0f;
-        break;
-
-    case FmtQuad:
-        chans = QuadMap;
-        num_channels = 4;
-        downmix_gain = 1.0f / 4.0f;
-        break;
-
-    case FmtX51:
-        chans = X51Map;
-        num_channels = 6;
-        /* NOTE: Excludes LFE. */
-        downmix_gain = 1.0f / 5.0f;
-        break;
-
-    case FmtX61:
-        chans = X61Map;
-        num_channels = 7;
-        /* NOTE: Excludes LFE. */
-        downmix_gain = 1.0f / 6.0f;
-        break;
-
-    case FmtX71:
-        chans = X71Map;
-        num_channels = 8;
-        /* NOTE: Excludes LFE. */
-        downmix_gain = 1.0f / 7.0f;
-        break;
+    case FmtRear: chans = RearMap; break;
+    case FmtQuad: chans = QuadMap; break;
+    case FmtX51: chans = X51Map; break;
+    case FmtX61: chans = X61Map; break;
+    case FmtX71: chans = X71Map; break;
 
     case FmtBFormat2D:
-        num_channels = 3;
-        isbformat = true;
-        DirectChannels = false;
-        break;
-
     case FmtBFormat3D:
-        num_channels = 4;
-        isbformat = true;
-        DirectChannels = false;
+    case FmtUHJ2:
+    case FmtUHJ3:
+    case FmtUHJ4:
+    case FmtSuperStereo:
+        DirectChannels = DirectMode::Off;
         break;
     }
-    ASSUME(num_channels > 0);
 
-    std::for_each(voice->mChans.begin(), voice->mChans.begin()+num_channels,
-        [NumSends](ALvoice::ChannelData &chandata) -> void
-        {
-            chandata.mDryParams.Hrtf.Target = HrtfFilter{};
-            chandata.mDryParams.Gains.Target.fill(0.0f);
-            std::for_each(chandata.mWetParams.begin(), chandata.mWetParams.begin()+NumSends,
-                [](SendParams &params) -> void { params.Gains.Target.fill(0.0f); });
-        });
-
-    voice->mFlags &= ~(VOICE_HAS_HRTF | VOICE_HAS_NFC);
-    if(isbformat)
+    voice->mFlags.reset(VoiceHasHrtf).reset(VoiceHasNfc);
+    if(auto *decoder{voice->mDecoder.get()})
+        decoder->mWidthControl = minf(props->EnhWidth, 0.7f);
+
+    if(IsAmbisonic(voice->mFmtChannels))
     {
-        /* Special handling for B-Format sources. */
+        /* Special handling for B-Format and UHJ sources. */
 
-        if(Distance > std::numeric_limits<float>::epsilon())
+        if(Device->AvgSpeakerDist > 0.0f && voice->mFmtChannels != FmtUHJ2
+            && voice->mFmtChannels != FmtSuperStereo)
         {
-            /* Panning a B-Format sound toward some direction is easy. Just pan
-             * the first (W) channel as a normal mono sound and silence the
-             * others.
-             */
-
-            if(Device->AvgSpeakerDist > 0.0f)
+            if(!(Distance > std::numeric_limits<float>::epsilon()))
+            {
+                /* NOTE: The NFCtrlFilters were created with a w0 of 0, which
+                 * is what we want for FOA input. The first channel may have
+                 * been previously re-adjusted if panned, so reset it.
+                 */
+                voice->mChans[0].mDryParams.NFCtrlFilter.adjust(0.0f);
+            }
+            else
             {
                 /* Clamp the distance for really close sources, to prevent
                  * excessive bass.
                  */
-                const ALfloat mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
-                const ALfloat w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
+                const float mdist{maxf(Distance*NfcScale, Device->AvgSpeakerDist/4.0f)};
+                const float w0{SpeedOfSoundMetersPerSec / (mdist * Frequency)};
 
                 /* Only need to adjust the first channel of a B-Format source. */
                 voice->mChans[0].mDryParams.NFCtrlFilter.adjust(w0);
-
-                voice->mFlags |= VOICE_HAS_NFC;
             }
 
-            ALfloat coeffs[MAX_AMBI_CHANNELS];
-            if(Device->mRenderMode != StereoPair)
-                CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
-            else
-            {
-                /* Clamp Y, in case rounding errors caused it to end up outside
-                 * of -1...+1.
-                 */
-                const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
-                /* Negate Z for right-handed coords with -Z in front. */
-                const ALfloat az{std::atan2(xpos, -zpos)};
+            voice->mFlags.set(VoiceHasNfc);
+        }
 
-                /* A scalar of 1.5 for plain stereo results in +/-60 degrees
-                 * being moved to +/-90 degrees for direct right and left
-                 * speaker responses.
-                 */
-                CalcAngleCoeffs(ScaleAzimuthFront(az, 1.5f), ev, Spread, coeffs);
-            }
+        /* Panning a B-Format sound toward some direction is easy. Just pan the
+         * first (W) channel as a normal mono sound. The angular spread is used
+         * as a directional scalar to blend between full coverage and full
+         * panning.
+         */
+        const float coverage{!(Distance > std::numeric_limits<float>::epsilon()) ? 1.0f :
+            (al::numbers::inv_pi_v<float>/2.0f * Spread)};
 
-            /* NOTE: W needs to be scaled due to FuMa normalization. */
-            const ALfloat &scale0 = AmbiScale::FromFuMa[0];
-            ComputePanGains(&Device->Dry, coeffs, DryGain*scale0,
+        auto calc_coeffs = [xpos,ypos,zpos](RenderMode mode)
+        {
+            if(mode != RenderMode::Pairwise)
+                return CalcDirectionCoeffs({xpos, ypos, zpos});
+
+            /* Clamp Y, in case rounding errors caused it to end up outside
+             * of -1...+1.
+             */
+            const float ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
+            /* Negate Z for right-handed coords with -Z in front. */
+            const float az{std::atan2(xpos, -zpos)};
+
+            /* A scalar of 1.5 for plain stereo results in +/-60 degrees
+             * being moved to +/-90 degrees for direct right and left
+             * speaker responses.
+             */
+            return CalcAngleCoeffs(ScaleAzimuthFront(az, 1.5f), ev, 0.0f);
+        };
+        auto&& scales = GetAmbiScales(voice->mAmbiScaling);
+        auto coeffs = calc_coeffs(Device->mRenderMode);
+
+        if(!(coverage > 0.0f))
+        {
+            ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base*scales[0],
                 voice->mChans[0].mDryParams.Gains.Target);
-            for(ALuint i{0};i < NumSends;i++)
+            for(uint i{0};i < NumSends;i++)
             {
-                if(const ALeffectslot *Slot{SendSlots[i]})
-                    ComputePanGains(&Slot->Wet, coeffs, WetGain[i]*scale0,
+                if(const EffectSlot *Slot{SendSlots[i]})
+                    ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base*scales[0],
                         voice->mChans[0].mWetParams[i].Gains.Target);
             }
         }
         else
         {
-            if(Device->AvgSpeakerDist > 0.0f)
-            {
-                /* NOTE: The NFCtrlFilters were created with a w0 of 0, which
-                 * is what we want for FOA input. The first channel may have
-                 * been previously re-adjusted if panned, so reset it.
-                 */
-                voice->mChans[0].mDryParams.NFCtrlFilter.adjust(0.0f);
-
-                voice->mFlags |= VOICE_HAS_NFC;
-            }
-
             /* Local B-Format sources have their XYZ channels rotated according
              * to the orientation.
              */
@@ -712,74 +886,159 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
             V.normalize();
             if(!props->HeadRelative)
             {
-                N = Listener.Params.Matrix * N;
-                V = Listener.Params.Matrix * V;
+                N = Context.Matrix * N;
+                V = Context.Matrix * V;
             }
             /* Build and normalize right-vector */
-            alu::Vector U{aluCrossproduct(N, V)};
+            alu::Vector U{N.cross_product(V)};
             U.normalize();
 
-            /* Build a rotate + conversion matrix (FuMa -> ACN+N3D). NOTE: This
-             * matrix is transposed, for the inputs to align on the rows and
-             * outputs on the columns.
+            /* Build a rotation matrix. Manually fill the zeroth- and first-
+             * order elements, then construct the rotation for the higher
+             * orders.
              */
-            const ALfloat &wscale = AmbiScale::FromFuMa[0];
-            const ALfloat &yscale = AmbiScale::FromFuMa[1];
-            const ALfloat &zscale = AmbiScale::FromFuMa[2];
-            const ALfloat &xscale = AmbiScale::FromFuMa[3];
-            const ALfloat matrix[4][MAX_AMBI_CHANNELS]{
-            //      ACN0          ACN1          ACN2          ACN3
-                { wscale,         0.0f,         0.0f,         0.0f }, // FuMa W
-                {   0.0f, -N[0]*xscale,  N[1]*xscale, -N[2]*xscale }, // FuMa X
-                {   0.0f,  U[0]*yscale, -U[1]*yscale,  U[2]*yscale }, // FuMa Y
-                {   0.0f, -V[0]*zscale,  V[1]*zscale, -V[2]*zscale }  // FuMa Z
-            };
+            AmbiRotateMatrix &shrot = Device->mAmbiRotateMatrix;
+            shrot.fill(AmbiRotateMatrix::value_type{});
+
+            shrot[0][0] = 1.0f;
+            shrot[1][1] =  U[0]; shrot[1][2] = -U[1]; shrot[1][3] =  U[2];
+            shrot[2][1] = -V[0]; shrot[2][2] =  V[1]; shrot[2][3] = -V[2];
+            shrot[3][1] = -N[0]; shrot[3][2] =  N[1]; shrot[3][3] = -N[2];
+            AmbiRotator(shrot, static_cast<int>(Device->mAmbiOrder));
+
+            /* If the device is higher order than the voice, "upsample" the
+             * matrix.
+             *
+             * NOTE: Starting with second-order, a 2D upsample needs to be
+             * applied with a 2D source and 3D output, even when they're the
+             * same order. This is because higher orders have a height offset
+             * on various channels (i.e. when elevation=0, those height-related
+             * channels should be non-0).
+             */
+            AmbiRotateMatrix &mixmatrix = Device->mAmbiRotateMatrix2;
+            if(Device->mAmbiOrder > voice->mAmbiOrder
+                || (Device->mAmbiOrder >= 2 && !Device->m2DMixing
+                    && Is2DAmbisonic(voice->mFmtChannels)))
+            {
+                if(voice->mAmbiOrder == 1)
+                {
+                    auto&& upsampler = Is2DAmbisonic(voice->mFmtChannels) ?
+                        AmbiScale::FirstOrder2DUp : AmbiScale::FirstOrderUp;
+                    UpsampleBFormatTransform(mixmatrix, upsampler, shrot, Device->mAmbiOrder);
+                }
+                else if(voice->mAmbiOrder == 2)
+                {
+                    auto&& upsampler = Is2DAmbisonic(voice->mFmtChannels) ?
+                        AmbiScale::SecondOrder2DUp : AmbiScale::SecondOrderUp;
+                    UpsampleBFormatTransform(mixmatrix, upsampler, shrot, Device->mAmbiOrder);
+                }
+                else if(voice->mAmbiOrder == 3)
+                {
+                    auto&& upsampler = Is2DAmbisonic(voice->mFmtChannels) ?
+                        AmbiScale::ThirdOrder2DUp : AmbiScale::ThirdOrderUp;
+                    UpsampleBFormatTransform(mixmatrix, upsampler, shrot, Device->mAmbiOrder);
+                }
+                else if(voice->mAmbiOrder == 4)
+                {
+                    auto&& upsampler = AmbiScale::FourthOrder2DUp;
+                    UpsampleBFormatTransform(mixmatrix, upsampler, shrot, Device->mAmbiOrder);
+                }
+                else
+                    al::unreachable();
+            }
+            else
+                mixmatrix = shrot;
+
+            /* Convert the rotation matrix for input ordering and scaling, and
+             * whether input is 2D or 3D.
+             */
+            const uint8_t *index_map{Is2DAmbisonic(voice->mFmtChannels) ?
+                GetAmbi2DLayout(voice->mAmbiLayout).data() :
+                GetAmbiLayout(voice->mAmbiLayout).data()};
+
+            /* Scale the panned W signal inversely to coverage (full coverage
+             * means no panned signal), and according to the channel scaling.
+             */
+            std::for_each(coeffs.begin(), coeffs.end(),
+                [scale=(1.0f-coverage)*scales[0]](float &coeff) noexcept { coeff *= scale; });
 
-            for(ALuint c{0};c < num_channels;c++)
+            for(size_t c{0};c < num_channels;c++)
             {
-                ComputePanGains(&Device->Dry, matrix[c], DryGain,
+                const size_t acn{index_map[c]};
+                const float scale{scales[acn] * coverage};
+
+                /* For channel 0, combine the B-Format signal (scaled according
+                 * to the coverage amount) with the directional pan. For all
+                 * other channels, use just the (scaled) B-Format signal.
+                 */
+                for(size_t x{0};x < MaxAmbiChannels;++x)
+                    coeffs[x] += mixmatrix[acn][x] * scale;
+
+                ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base,
                     voice->mChans[c].mDryParams.Gains.Target);
 
-                for(ALuint i{0};i < NumSends;i++)
+                for(uint i{0};i < NumSends;i++)
                 {
-                    if(const ALeffectslot *Slot{SendSlots[i]})
-                        ComputePanGains(&Slot->Wet, matrix[c], WetGain[i],
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
                             voice->mChans[c].mWetParams[i].Gains.Target);
                 }
+
+                coeffs = std::array<float,MaxAmbiChannels>{};
             }
         }
     }
-    else if(DirectChannels)
+    else if(DirectChannels != DirectMode::Off && !Device->RealOut.RemixMap.empty())
     {
         /* Direct source channels always play local. Skip the virtual channels
          * and write inputs to the matching real outputs.
          */
         voice->mDirect.Buffer = Device->RealOut.Buffer;
 
-        for(ALuint c{0};c < num_channels;c++)
+        for(size_t c{0};c < num_channels;c++)
         {
-            const ALuint idx{GetChannelIdxByName(Device->RealOut, chans[c].channel)};
-            if(idx != INVALID_CHANNEL_INDEX)
-                voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain;
+            uint idx{Device->channelIdxByName(chans[c].channel)};
+            if(idx != InvalidChannelIndex)
+                voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain.Base;
+            else if(DirectChannels == DirectMode::RemixMismatch)
+            {
+                auto match_channel = [chans,c](const InputRemixMap &map) noexcept -> bool
+                { return chans[c].channel == map.channel; };
+                auto remap = std::find_if(Device->RealOut.RemixMap.cbegin(),
+                    Device->RealOut.RemixMap.cend(), match_channel);
+                if(remap != Device->RealOut.RemixMap.cend())
+                {
+                    for(const auto &target : remap->targets)
+                    {
+                        idx = Device->channelIdxByName(target.channel);
+                        if(idx != InvalidChannelIndex)
+                            voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain.Base *
+                                target.mix;
+                    }
+                }
+            }
         }
 
         /* Auxiliary sends still use normal channel panning since they mix to
          * B-Format, which can't channel-match.
          */
-        for(ALuint c{0};c < num_channels;c++)
+        for(size_t c{0};c < num_channels;c++)
         {
-            ALfloat coeffs[MAX_AMBI_CHANNELS];
-            CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
+            /* Skip LFE */
+            if(chans[c].channel == LFE)
+                continue;
+
+            const auto coeffs = CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f);
 
-            for(ALuint i{0};i < NumSends;i++)
+            for(uint i{0};i < NumSends;i++)
             {
-                if(const ALeffectslot *Slot{SendSlots[i]})
-                    ComputePanGains(&Slot->Wet, coeffs, WetGain[i],
+                if(const EffectSlot *Slot{SendSlots[i]})
+                    ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
                         voice->mChans[c].mWetParams[i].Gains.Target);
             }
         }
     }
-    else if(Device->mRenderMode == HrtfRender)
+    else if(Device->mRenderMode == RenderMode::Hrtf)
     {
         /* Full HRTF rendering. Skip the virtual channels and render to the
          * real outputs.
@@ -788,51 +1047,75 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
 
         if(Distance > std::numeric_limits<float>::epsilon())
         {
-            const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
-            const ALfloat az{std::atan2(xpos, -zpos)};
+            const float src_ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
+            const float src_az{std::atan2(xpos, -zpos)};
 
-            /* Get the HRIR coefficients and delays just once, for the given
-             * source direction.
-             */
-            GetHrtfCoeffs(Device->mHrtf, ev, az, Distance, Spread,
-                voice->mChans[0].mDryParams.Hrtf.Target.Coeffs,
-                voice->mChans[0].mDryParams.Hrtf.Target.Delay);
-            voice->mChans[0].mDryParams.Hrtf.Target.Gain = DryGain * downmix_gain;
+            if(voice->mFmtChannels == FmtMono)
+            {
+                Device->mHrtf->getCoeffs(src_ev, src_az, Distance*NfcScale, Spread,
+                    voice->mChans[0].mDryParams.Hrtf.Target.Coeffs,
+                    voice->mChans[0].mDryParams.Hrtf.Target.Delay);
+                voice->mChans[0].mDryParams.Hrtf.Target.Gain = DryGain.Base;
 
-            /* Remaining channels use the same results as the first. */
-            for(ALuint c{1};c < num_channels;c++)
+                const auto coeffs = CalcAngleCoeffs(src_az, src_ev, Spread);
+                for(uint i{0};i < NumSends;i++)
+                {
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
+                            voice->mChans[0].mWetParams[i].Gains.Target);
+                }
+            }
+            else for(size_t c{0};c < num_channels;c++)
             {
+                using namespace al::numbers;
+
                 /* Skip LFE */
                 if(chans[c].channel == LFE) continue;
-                voice->mChans[c].mDryParams.Hrtf.Target = voice->mChans[0].mDryParams.Hrtf.Target;
-            }
 
-            /* Calculate the directional coefficients once, which apply to all
-             * input channels of the source sends.
-             */
-            ALfloat coeffs[MAX_AMBI_CHANNELS];
-            CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
+                /* Warp the channel position toward the source position as the
+                 * source spread decreases. With no spread, all channels are at
+                 * the source position, at full spread (pi*2), each channel is
+                 * left unchanged.
+                 */
+                const float ev{lerpf(src_ev, chans[c].elevation, inv_pi_v<float>/2.0f * Spread)};
 
-            for(ALuint c{0};c < num_channels;c++)
-            {
-                /* Skip LFE */
-                if(chans[c].channel == LFE)
-                    continue;
-                for(ALuint i{0};i < NumSends;i++)
+                float az{chans[c].angle - src_az};
+                if(az < -pi_v<float>) az += pi_v<float>*2.0f;
+                else if(az > pi_v<float>) az -= pi_v<float>*2.0f;
+
+                az *= inv_pi_v<float>/2.0f * Spread;
+
+                az += src_az;
+                if(az < -pi_v<float>) az += pi_v<float>*2.0f;
+                else if(az > pi_v<float>) az -= pi_v<float>*2.0f;
+
+                Device->mHrtf->getCoeffs(ev, az, Distance*NfcScale, 0.0f,
+                    voice->mChans[c].mDryParams.Hrtf.Target.Coeffs,
+                    voice->mChans[c].mDryParams.Hrtf.Target.Delay);
+                voice->mChans[c].mDryParams.Hrtf.Target.Gain = DryGain.Base;
+
+                const auto coeffs = CalcAngleCoeffs(az, ev, 0.0f);
+                for(uint i{0};i < NumSends;i++)
                 {
-                    if(const ALeffectslot *Slot{SendSlots[i]})
-                        ComputePanGains(&Slot->Wet, coeffs, WetGain[i] * downmix_gain,
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
                             voice->mChans[c].mWetParams[i].Gains.Target);
                 }
             }
         }
         else
         {
+            /* With no distance, spread is only meaningful for mono sources
+             * where it can be 0 or full (non-mono sources are always full
+             * spread here).
+             */
+            const float spread{Spread * (voice->mFmtChannels == FmtMono)};
+
             /* Local sources on HRTF play with each channel panned to its
              * relative location around the listener, providing "virtual
              * speaker" responses.
              */
-            for(ALuint c{0};c < num_channels;c++)
+            for(size_t c{0};c < num_channels;c++)
             {
                 /* Skip LFE */
                 if(chans[c].channel == LFE)
@@ -841,26 +1124,25 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
                 /* Get the HRIR coefficients and delays for this channel
                  * position.
                  */
-                GetHrtfCoeffs(Device->mHrtf, chans[c].elevation, chans[c].angle,
-                    std::numeric_limits<float>::infinity(), Spread,
+                Device->mHrtf->getCoeffs(chans[c].elevation, chans[c].angle,
+                    std::numeric_limits<float>::infinity(), spread,
                     voice->mChans[c].mDryParams.Hrtf.Target.Coeffs,
                     voice->mChans[c].mDryParams.Hrtf.Target.Delay);
-                voice->mChans[c].mDryParams.Hrtf.Target.Gain = DryGain;
+                voice->mChans[c].mDryParams.Hrtf.Target.Gain = DryGain.Base;
 
                 /* Normal panning for auxiliary sends. */
-                ALfloat coeffs[MAX_AMBI_CHANNELS];
-                CalcAngleCoeffs(chans[c].angle, chans[c].elevation, Spread, coeffs);
+                const auto coeffs = CalcAngleCoeffs(chans[c].angle, chans[c].elevation, spread);
 
-                for(ALuint i{0};i < NumSends;i++)
+                for(uint i{0};i < NumSends;i++)
                 {
-                    if(const ALeffectslot *Slot{SendSlots[i]})
-                        ComputePanGains(&Slot->Wet, coeffs, WetGain[i],
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
                             voice->mChans[c].mWetParams[i].Gains.Target);
                 }
             }
         }
 
-        voice->mFlags |= VOICE_HAS_HRTF;
+        voice->mFlags.set(VoiceHasHrtf);
     }
     else
     {
@@ -874,50 +1156,88 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
                 /* Clamp the distance for really close sources, to prevent
                  * excessive bass.
                  */
-                const ALfloat mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
-                const ALfloat w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
+                const float mdist{maxf(Distance*NfcScale, Device->AvgSpeakerDist/4.0f)};
+                const float w0{SpeedOfSoundMetersPerSec / (mdist * Frequency)};
 
                 /* Adjust NFC filters. */
-                for(ALuint c{0};c < num_channels;c++)
+                for(size_t c{0};c < num_channels;c++)
                     voice->mChans[c].mDryParams.NFCtrlFilter.adjust(w0);
 
-                voice->mFlags |= VOICE_HAS_NFC;
+                voice->mFlags.set(VoiceHasNfc);
             }
 
-            /* Calculate the directional coefficients once, which apply to all
-             * input channels.
-             */
-            ALfloat coeffs[MAX_AMBI_CHANNELS];
-            if(Device->mRenderMode != StereoPair)
-                CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
-            else
+            if(voice->mFmtChannels == FmtMono)
             {
-                const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
-                const ALfloat az{std::atan2(xpos, -zpos)};
-                CalcAngleCoeffs(ScaleAzimuthFront(az, 1.5f), ev, Spread, coeffs);
+                auto calc_coeffs = [xpos,ypos,zpos,Spread](RenderMode mode)
+                {
+                    if(mode != RenderMode::Pairwise)
+                        return CalcDirectionCoeffs({xpos, ypos, zpos}, Spread);
+                    const float ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
+                    const float az{std::atan2(xpos, -zpos)};
+                    return CalcAngleCoeffs(ScaleAzimuthFront(az, 1.5f), ev, Spread);
+                };
+                const auto coeffs = calc_coeffs(Device->mRenderMode);
+
+                ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base,
+                    voice->mChans[0].mDryParams.Gains.Target);
+                for(uint i{0};i < NumSends;i++)
+                {
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
+                            voice->mChans[0].mWetParams[i].Gains.Target);
+                }
             }
-
-            for(ALuint c{0};c < num_channels;c++)
+            else
             {
-                /* Special-case LFE */
-                if(chans[c].channel == LFE)
+                using namespace al::numbers;
+
+                const float src_ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
+                const float src_az{std::atan2(xpos, -zpos)};
+
+                for(size_t c{0};c < num_channels;c++)
                 {
-                    if(Device->Dry.Buffer.data() == Device->RealOut.Buffer.data())
+                    /* Special-case LFE */
+                    if(chans[c].channel == LFE)
                     {
-                        const ALuint idx{GetChannelIdxByName(Device->RealOut, chans[c].channel)};
-                        if(idx != INVALID_CHANNEL_INDEX)
-                            voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain;
+                        if(Device->Dry.Buffer.data() == Device->RealOut.Buffer.data())
+                        {
+                            const uint idx{Device->channelIdxByName(chans[c].channel)};
+                            if(idx != InvalidChannelIndex)
+                                voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain.Base;
+                        }
+                        continue;
                     }
-                    continue;
-                }
 
-                ComputePanGains(&Device->Dry, coeffs, DryGain * downmix_gain,
-                    voice->mChans[c].mDryParams.Gains.Target);
-                for(ALuint i{0};i < NumSends;i++)
-                {
-                    if(const ALeffectslot *Slot{SendSlots[i]})
-                        ComputePanGains(&Slot->Wet, coeffs, WetGain[i] * downmix_gain,
-                            voice->mChans[c].mWetParams[i].Gains.Target);
+                    /* Warp the channel position toward the source position as
+                     * the spread decreases. With no spread, all channels are
+                     * at the source position, at full spread (pi*2), each
+                     * channel position is left unchanged.
+                     */
+                    const float ev{lerpf(src_ev, chans[c].elevation,
+                        inv_pi_v<float>/2.0f * Spread)};
+
+                    float az{chans[c].angle - src_az};
+                    if(az < -pi_v<float>) az += pi_v<float>*2.0f;
+                    else if(az > pi_v<float>) az -= pi_v<float>*2.0f;
+
+                    az *= inv_pi_v<float>/2.0f * Spread;
+
+                    az += src_az;
+                    if(az < -pi_v<float>) az += pi_v<float>*2.0f;
+                    else if(az > pi_v<float>) az -= pi_v<float>*2.0f;
+
+                    if(Device->mRenderMode == RenderMode::Pairwise)
+                        az = ScaleAzimuthFront(az, 3.0f);
+                    const auto coeffs = CalcAngleCoeffs(az, ev, 0.0f);
+
+                    ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base,
+                        voice->mChans[c].mDryParams.Gains.Target);
+                    for(uint i{0};i < NumSends;i++)
+                    {
+                        if(const EffectSlot *Slot{SendSlots[i]})
+                            ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
+                                voice->mChans[c].mWetParams[i].Gains.Target);
+                    }
                 }
             }
         }
@@ -925,46 +1245,45 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
         {
             if(Device->AvgSpeakerDist > 0.0f)
             {
-                /* If the source distance is 0, set w0 to w1 to act as a pass-
-                 * through. We still want to pass the signal through the
-                 * filters so they keep an appropriate history, in case the
-                 * source moves away from the listener.
+                /* If the source distance is 0, simulate a plane-wave by using
+                 * infinite distance, which results in a w0 of 0.
                  */
-                const ALfloat w0{SPEEDOFSOUNDMETRESPERSEC / (Device->AvgSpeakerDist * Frequency)};
-
-                for(ALuint c{0};c < num_channels;c++)
+                static constexpr float w0{0.0f};
+                for(size_t c{0};c < num_channels;c++)
                     voice->mChans[c].mDryParams.NFCtrlFilter.adjust(w0);
 
-                voice->mFlags |= VOICE_HAS_NFC;
+                voice->mFlags.set(VoiceHasNfc);
             }
 
-            for(ALuint c{0};c < num_channels;c++)
+            /* With no distance, spread is only meaningful for mono sources
+             * where it can be 0 or full (non-mono sources are always full
+             * spread here).
+             */
+            const float spread{Spread * (voice->mFmtChannels == FmtMono)};
+            for(size_t c{0};c < num_channels;c++)
             {
                 /* Special-case LFE */
                 if(chans[c].channel == LFE)
                 {
                     if(Device->Dry.Buffer.data() == Device->RealOut.Buffer.data())
                     {
-                        const ALuint idx{GetChannelIdxByName(Device->RealOut, chans[c].channel)};
-                        if(idx != INVALID_CHANNEL_INDEX)
-                            voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain;
+                        const uint idx{Device->channelIdxByName(chans[c].channel)};
+                        if(idx != InvalidChannelIndex)
+                            voice->mChans[c].mDryParams.Gains.Target[idx] = DryGain.Base;
                     }
                     continue;
                 }
 
-                ALfloat coeffs[MAX_AMBI_CHANNELS];
-                CalcAngleCoeffs(
-                    (Device->mRenderMode==StereoPair) ? ScaleAzimuthFront(chans[c].angle, 3.0f)
-                                                      : chans[c].angle,
-                    chans[c].elevation, Spread, coeffs
-                );
+                const auto coeffs = CalcAngleCoeffs((Device->mRenderMode == RenderMode::Pairwise)
+                    ? ScaleAzimuthFront(chans[c].angle, 3.0f) : chans[c].angle,
+                    chans[c].elevation, spread);
 
-                ComputePanGains(&Device->Dry, coeffs, DryGain,
+                ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base,
                     voice->mChans[c].mDryParams.Gains.Target);
-                for(ALuint i{0};i < NumSends;i++)
+                for(uint i{0};i < NumSends;i++)
                 {
-                    if(const ALeffectslot *Slot{SendSlots[i]})
-                        ComputePanGains(&Slot->Wet, coeffs, WetGain[i],
+                    if(const EffectSlot *Slot{SendSlots[i]})
+                        ComputePanGains(&Slot->Wet, coeffs.data(), WetGain[i].Base,
                             voice->mChans[c].mWetParams[i].Gains.Target);
                 }
             }
@@ -972,44 +1291,37 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
     }
 
     {
-        const ALfloat hfScale{props->Direct.HFReference / Frequency};
-        const ALfloat lfScale{props->Direct.LFReference / Frequency};
-        const ALfloat gainHF{maxf(DryGainHF, 0.001f)}; /* Limit -60dB */
-        const ALfloat gainLF{maxf(DryGainLF, 0.001f)};
+        const float hfNorm{props->Direct.HFReference / Frequency};
+        const float lfNorm{props->Direct.LFReference / Frequency};
 
         voice->mDirect.FilterType = AF_None;
-        if(gainHF != 1.0f) voice->mDirect.FilterType |= AF_LowPass;
-        if(gainLF != 1.0f) voice->mDirect.FilterType |= AF_HighPass;
+        if(DryGain.HF != 1.0f) voice->mDirect.FilterType |= AF_LowPass;
+        if(DryGain.LF != 1.0f) voice->mDirect.FilterType |= AF_HighPass;
+
         auto &lowpass = voice->mChans[0].mDryParams.LowPass;
         auto &highpass = voice->mChans[0].mDryParams.HighPass;
-        lowpass.setParams(BiquadType::HighShelf, gainHF, hfScale,
-            lowpass.rcpQFromSlope(gainHF, 1.0f));
-        highpass.setParams(BiquadType::LowShelf, gainLF, lfScale,
-            highpass.rcpQFromSlope(gainLF, 1.0f));
-        for(ALuint c{1};c < num_channels;c++)
+        lowpass.setParamsFromSlope(BiquadType::HighShelf, hfNorm, DryGain.HF, 1.0f);
+        highpass.setParamsFromSlope(BiquadType::LowShelf, lfNorm, DryGain.LF, 1.0f);
+        for(size_t c{1};c < num_channels;c++)
         {
             voice->mChans[c].mDryParams.LowPass.copyParamsFrom(lowpass);
             voice->mChans[c].mDryParams.HighPass.copyParamsFrom(highpass);
         }
     }
-    for(ALuint i{0};i < NumSends;i++)
+    for(uint i{0};i < NumSends;i++)
     {
-        const ALfloat hfScale{props->Send[i].HFReference / Frequency};
-        const ALfloat lfScale{props->Send[i].LFReference / Frequency};
-        const ALfloat gainHF{maxf(WetGainHF[i], 0.001f)};
-        const ALfloat gainLF{maxf(WetGainLF[i], 0.001f)};
+        const float hfNorm{props->Send[i].HFReference / Frequency};
+        const float lfNorm{props->Send[i].LFReference / Frequency};
 
         voice->mSend[i].FilterType = AF_None;
-        if(gainHF != 1.0f) voice->mSend[i].FilterType |= AF_LowPass;
-        if(gainLF != 1.0f) voice->mSend[i].FilterType |= AF_HighPass;
+        if(WetGain[i].HF != 1.0f) voice->mSend[i].FilterType |= AF_LowPass;
+        if(WetGain[i].LF != 1.0f) voice->mSend[i].FilterType |= AF_HighPass;
 
         auto &lowpass = voice->mChans[0].mWetParams[i].LowPass;
         auto &highpass = voice->mChans[0].mWetParams[i].HighPass;
-        lowpass.setParams(BiquadType::HighShelf, gainHF, hfScale,
-            lowpass.rcpQFromSlope(gainHF, 1.0f));
-        highpass.setParams(BiquadType::LowShelf, gainLF, lfScale,
-            highpass.rcpQFromSlope(gainLF, 1.0f));
-        for(ALuint c{1};c < num_channels;c++)
+        lowpass.setParamsFromSlope(BiquadType::HighShelf, hfNorm, WetGain[i].HF, 1.0f);
+        highpass.setParamsFromSlope(BiquadType::LowShelf, lfNorm, WetGain[i].LF, 1.0f);
+        for(size_t c{1};c < num_channels;c++)
         {
             voice->mChans[c].mWetParams[i].LowPass.copyParamsFrom(lowpass);
             voice->mChans[c].mWetParams[i].HighPass.copyParamsFrom(highpass);
@@ -1017,18 +1329,16 @@ void CalcPanningAndFilters(ALvoice *voice, const ALfloat xpos, const ALfloat ypo
     }
 }
 
-void CalcNonAttnSourceParams(ALvoice *voice, const ALvoicePropsBase *props, const ALCcontext *ALContext)
+void CalcNonAttnSourceParams(Voice *voice, const VoiceProps *props, const ContextBase *context)
 {
-    const ALCdevice *Device{ALContext->mDevice.get()};
-    ALeffectslot *SendSlots[MAX_SENDS];
+    DeviceBase *Device{context->mDevice};
+    EffectSlot *SendSlots[MAX_SENDS];
 
     voice->mDirect.Buffer = Device->Dry.Buffer;
-    for(ALuint i{0};i < Device->NumAuxSends;i++)
+    for(uint i{0};i < Device->NumAuxSends;i++)
     {
         SendSlots[i] = props->Send[i].Slot;
-        if(!SendSlots[i] && i == 0)
-            SendSlots[i] = ALContext->mDefaultSlot.get();
-        if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
+        if(!SendSlots[i] || SendSlots[i]->EffectType == EffectSlotType::None)
         {
             SendSlots[i] = nullptr;
             voice->mSend[i].Buffer = {};
@@ -1038,93 +1348,53 @@ void CalcNonAttnSourceParams(ALvoice *voice, const ALvoicePropsBase *props, cons
     }
 
     /* Calculate the stepping value */
-    const auto Pitch = static_cast<ALfloat>(voice->mFrequency) /
-        static_cast<ALfloat>(Device->Frequency) * props->Pitch;
-    if(Pitch > float{MAX_PITCH})
-        voice->mStep = MAX_PITCH<<FRACTIONBITS;
+    const auto Pitch = static_cast<float>(voice->mFrequency) /
+        static_cast<float>(Device->Frequency) * props->Pitch;
+    if(Pitch > float{MaxPitch})
+        voice->mStep = MaxPitch<<MixerFracBits;
     else
-        voice->mStep = maxu(fastf2u(Pitch * FRACTIONONE), 1);
+        voice->mStep = maxu(fastf2u(Pitch * MixerFracOne), 1);
     voice->mResampler = PrepareResampler(props->mResampler, voice->mStep, &voice->mResampleState);
 
     /* Calculate gains */
-    const ALlistener &Listener = ALContext->mListener;
-    ALfloat DryGain{clampf(props->Gain, props->MinGain, props->MaxGain)};
-    DryGain *= props->Direct.Gain * Listener.Params.Gain;
-    DryGain  = minf(DryGain, GAIN_MIX_MAX);
-    ALfloat DryGainHF{props->Direct.GainHF};
-    ALfloat DryGainLF{props->Direct.GainLF};
-    ALfloat WetGain[MAX_SENDS], WetGainHF[MAX_SENDS], WetGainLF[MAX_SENDS];
-    for(ALuint i{0};i < Device->NumAuxSends;i++)
+    GainTriplet DryGain;
+    DryGain.Base  = minf(clampf(props->Gain, props->MinGain, props->MaxGain) * props->Direct.Gain *
+        context->mParams.Gain, GainMixMax);
+    DryGain.HF = props->Direct.GainHF;
+    DryGain.LF = props->Direct.GainLF;
+    GainTriplet WetGain[MAX_SENDS];
+    for(uint i{0};i < Device->NumAuxSends;i++)
     {
-        WetGain[i]  = clampf(props->Gain, props->MinGain, props->MaxGain);
-        WetGain[i] *= props->Send[i].Gain * Listener.Params.Gain;
-        WetGain[i]  = minf(WetGain[i], GAIN_MIX_MAX);
-        WetGainHF[i] = props->Send[i].GainHF;
-        WetGainLF[i] = props->Send[i].GainLF;
+        WetGain[i].Base = minf(clampf(props->Gain, props->MinGain, props->MaxGain) *
+            props->Send[i].Gain * context->mParams.Gain, GainMixMax);
+        WetGain[i].HF = props->Send[i].GainHF;
+        WetGain[i].LF = props->Send[i].GainLF;
     }
 
-    CalcPanningAndFilters(voice, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, DryGain, DryGainHF, DryGainLF,
-        WetGain, WetGainLF, WetGainHF, SendSlots, props, Listener, Device);
+    CalcPanningAndFilters(voice, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, DryGain, WetGain, SendSlots, props,
+        context->mParams, Device);
 }
 
-void CalcAttnSourceParams(ALvoice *voice, const ALvoicePropsBase *props, const ALCcontext *ALContext)
+void CalcAttnSourceParams(Voice *voice, const VoiceProps *props, const ContextBase *context)
 {
-    const ALCdevice *Device{ALContext->mDevice.get()};
-    const ALuint NumSends{Device->NumAuxSends};
-    const ALlistener &Listener = ALContext->mListener;
+    DeviceBase *Device{context->mDevice};
+    const uint NumSends{Device->NumAuxSends};
 
     /* Set mixing buffers and get send parameters. */
     voice->mDirect.Buffer = Device->Dry.Buffer;
-    ALeffectslot *SendSlots[MAX_SENDS];
-    ALfloat RoomRolloff[MAX_SENDS];
-    ALfloat DecayDistance[MAX_SENDS];
-    ALfloat DecayLFDistance[MAX_SENDS];
-    ALfloat DecayHFDistance[MAX_SENDS];
-    for(ALuint i{0};i < NumSends;i++)
+    EffectSlot *SendSlots[MAX_SENDS];
+    uint UseDryAttnForRoom{0};
+    for(uint i{0};i < NumSends;i++)
     {
         SendSlots[i] = props->Send[i].Slot;
-        if(!SendSlots[i] && i == 0)
-            SendSlots[i] = ALContext->mDefaultSlot.get();
-        if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
-        {
+        if(!SendSlots[i] || SendSlots[i]->EffectType == EffectSlotType::None)
             SendSlots[i] = nullptr;
-            RoomRolloff[i] = 0.0f;
-            DecayDistance[i] = 0.0f;
-            DecayLFDistance[i] = 0.0f;
-            DecayHFDistance[i] = 0.0f;
-        }
-        else if(SendSlots[i]->Params.AuxSendAuto)
-        {
-            RoomRolloff[i] = SendSlots[i]->Params.RoomRolloff + props->RoomRolloffFactor;
-            /* Calculate the distances to where this effect's decay reaches
-             * -60dB.
-             */
-            DecayDistance[i] = SendSlots[i]->Params.DecayTime * SPEEDOFSOUNDMETRESPERSEC;
-            DecayLFDistance[i] = DecayDistance[i] * SendSlots[i]->Params.DecayLFRatio;
-            DecayHFDistance[i] = DecayDistance[i] * SendSlots[i]->Params.DecayHFRatio;
-            if(SendSlots[i]->Params.DecayHFLimit)
-            {
-                ALfloat airAbsorption{SendSlots[i]->Params.AirAbsorptionGainHF};
-                if(airAbsorption < 1.0f)
-                {
-                    /* Calculate the distance to where this effect's air
-                     * absorption reaches -60dB, and limit the effect's HF
-                     * decay distance (so it doesn't take any longer to decay
-                     * than the air would allow).
-                     */
-                    ALfloat absorb_dist{std::log10(REVERB_DECAY_GAIN) / std::log10(airAbsorption)};
-                    DecayHFDistance[i] = minf(absorb_dist, DecayHFDistance[i]);
-                }
-            }
-        }
-        else
+        else if(!SendSlots[i]->AuxSendAuto)
         {
             /* If the slot's auxiliary send auto is off, the data sent to the
-             * effect slot is the same as the dry path, sans filter effects */
-            RoomRolloff[i] = props->RolloffFactor;
-            DecayDistance[i] = 0.0f;
-            DecayLFDistance[i] = 0.0f;
-            DecayHFDistance[i] = 0.0f;
+             * effect slot is the same as the dry path, sans filter effects.
+             */
+            UseDryAttnForRoom |= 1u<<i;
         }
 
         if(!SendSlots[i])
@@ -1137,208 +1407,228 @@ void CalcAttnSourceParams(ALvoice *voice, const ALvoicePropsBase *props, const A
     alu::Vector Position{props->Position[0], props->Position[1], props->Position[2], 1.0f};
     alu::Vector Velocity{props->Velocity[0], props->Velocity[1], props->Velocity[2], 0.0f};
     alu::Vector Direction{props->Direction[0], props->Direction[1], props->Direction[2], 0.0f};
-    if(props->HeadRelative == AL_FALSE)
+    if(!props->HeadRelative)
     {
         /* Transform source vectors */
-        Position = Listener.Params.Matrix * Position;
-        Velocity = Listener.Params.Matrix * Velocity;
-        Direction = Listener.Params.Matrix * Direction;
+        Position = context->mParams.Matrix * (Position - context->mParams.Position);
+        Velocity = context->mParams.Matrix * Velocity;
+        Direction = context->mParams.Matrix * Direction;
     }
     else
     {
         /* Offset the source velocity to be relative of the listener velocity */
-        Velocity += Listener.Params.Velocity;
+        Velocity += context->mParams.Velocity;
     }
 
     const bool directional{Direction.normalize() > 0.0f};
     alu::Vector ToSource{Position[0], Position[1], Position[2], 0.0f};
-    const ALfloat Distance{ToSource.normalize()};
-
-    /* Initial source gain */
-    ALfloat DryGain{props->Gain};
-    ALfloat DryGainHF{1.0f};
-    ALfloat DryGainLF{1.0f};
-    ALfloat WetGain[MAX_SENDS], WetGainHF[MAX_SENDS], WetGainLF[MAX_SENDS];
-    for(ALuint i{0};i < NumSends;i++)
-    {
-        WetGain[i] = props->Gain;
-        WetGainHF[i] = 1.0f;
-        WetGainLF[i] = 1.0f;
-    }
+    const float Distance{ToSource.normalize()};
 
     /* Calculate distance attenuation */
-    ALfloat ClampedDist{Distance};
+    float ClampedDist{Distance};
+    float DryGainBase{props->Gain};
+    float WetGainBase{props->Gain};
 
-    switch(Listener.Params.SourceDistanceModel ?
-           props->mDistanceModel : Listener.Params.mDistanceModel)
+    switch(context->mParams.SourceDistanceModel ? props->mDistanceModel
+        : context->mParams.mDistanceModel)
     {
         case DistanceModel::InverseClamped:
-            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             if(props->MaxDistance < props->RefDistance) break;
+            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             /*fall-through*/
         case DistanceModel::Inverse:
-            if(!(props->RefDistance > 0.0f))
-                ClampedDist = props->RefDistance;
-            else
+            if(props->RefDistance > 0.0f)
             {
-                ALfloat dist = lerp(props->RefDistance, ClampedDist, props->RolloffFactor);
-                if(dist > 0.0f) DryGain *= props->RefDistance / dist;
-                for(ALuint i{0};i < NumSends;i++)
-                {
-                    dist = lerp(props->RefDistance, ClampedDist, RoomRolloff[i]);
-                    if(dist > 0.0f) WetGain[i] *= props->RefDistance / dist;
-                }
+                float dist{lerpf(props->RefDistance, ClampedDist, props->RolloffFactor)};
+                if(dist > 0.0f) DryGainBase *= props->RefDistance / dist;
+
+                dist = lerpf(props->RefDistance, ClampedDist, props->RoomRolloffFactor);
+                if(dist > 0.0f) WetGainBase *= props->RefDistance / dist;
             }
             break;
 
         case DistanceModel::LinearClamped:
-            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             if(props->MaxDistance < props->RefDistance) break;
+            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             /*fall-through*/
         case DistanceModel::Linear:
-            if(!(props->MaxDistance != props->RefDistance))
-                ClampedDist = props->RefDistance;
-            else
+            if(props->MaxDistance != props->RefDistance)
             {
-                ALfloat attn = props->RolloffFactor * (ClampedDist-props->RefDistance) /
-                               (props->MaxDistance-props->RefDistance);
-                DryGain *= maxf(1.0f - attn, 0.0f);
-                for(ALuint i{0};i < NumSends;i++)
-                {
-                    attn = RoomRolloff[i] * (ClampedDist-props->RefDistance) /
-                           (props->MaxDistance-props->RefDistance);
-                    WetGain[i] *= maxf(1.0f - attn, 0.0f);
-                }
+                float attn{(ClampedDist-props->RefDistance) /
+                    (props->MaxDistance-props->RefDistance) * props->RolloffFactor};
+                DryGainBase *= maxf(1.0f - attn, 0.0f);
+
+                attn = (ClampedDist-props->RefDistance) /
+                    (props->MaxDistance-props->RefDistance) * props->RoomRolloffFactor;
+                WetGainBase *= maxf(1.0f - attn, 0.0f);
             }
             break;
 
         case DistanceModel::ExponentClamped:
-            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             if(props->MaxDistance < props->RefDistance) break;
+            ClampedDist = clampf(ClampedDist, props->RefDistance, props->MaxDistance);
             /*fall-through*/
         case DistanceModel::Exponent:
-            if(!(ClampedDist > 0.0f && props->RefDistance > 0.0f))
-                ClampedDist = props->RefDistance;
-            else
+            if(ClampedDist > 0.0f && props->RefDistance > 0.0f)
             {
-                DryGain *= std::pow(ClampedDist/props->RefDistance, -props->RolloffFactor);
-                for(ALuint i{0};i < NumSends;i++)
-                    WetGain[i] *= std::pow(ClampedDist/props->RefDistance, -RoomRolloff[i]);
+                const float dist_ratio{ClampedDist/props->RefDistance};
+                DryGainBase *= std::pow(dist_ratio, -props->RolloffFactor);
+                WetGainBase *= std::pow(dist_ratio, -props->RoomRolloffFactor);
             }
             break;
 
         case DistanceModel::Disable:
-            ClampedDist = props->RefDistance;
             break;
     }
 
     /* Calculate directional soundcones */
+    float ConeHF{1.0f}, WetConeHF{1.0f};
     if(directional && props->InnerAngle < 360.0f)
     {
-        const ALfloat Angle{Rad2Deg(std::acos(-aluDotproduct(Direction, ToSource)) *
-            ConeScale * 2.0f)};
+        static constexpr float Rad2Deg{static_cast<float>(180.0 / al::numbers::pi)};
+        const float Angle{Rad2Deg*2.0f * std::acos(-Direction.dot_product(ToSource)) * ConeScale};
 
-        ALfloat ConeVolume, ConeHF;
-        if(!(Angle > props->InnerAngle))
+        float ConeGain{1.0f};
+        if(Angle >= props->OuterAngle)
         {
-            ConeVolume = 1.0f;
-            ConeHF = 1.0f;
+            ConeGain = props->OuterGain;
+            ConeHF = lerpf(1.0f, props->OuterGainHF, props->DryGainHFAuto);
         }
-        else if(Angle < props->OuterAngle)
+        else if(Angle >= props->InnerAngle)
         {
-            ALfloat scale = (            Angle-props->InnerAngle) /
-                            (props->OuterAngle-props->InnerAngle);
-            ConeVolume = lerp(1.0f, props->OuterGain, scale);
-            ConeHF = lerp(1.0f, props->OuterGainHF, scale);
-        }
-        else
-        {
-            ConeVolume = props->OuterGain;
-            ConeHF = props->OuterGainHF;
+            const float scale{(Angle-props->InnerAngle) / (props->OuterAngle-props->InnerAngle)};
+            ConeGain = lerpf(1.0f, props->OuterGain, scale);
+            ConeHF = lerpf(1.0f, props->OuterGainHF, scale * props->DryGainHFAuto);
         }
 
-        DryGain *= ConeVolume;
-        if(props->DryGainHFAuto)
-            DryGainHF *= ConeHF;
-        if(props->WetGainAuto)
-            std::transform(std::begin(WetGain), std::begin(WetGain)+NumSends, std::begin(WetGain),
-                [ConeVolume](ALfloat gain) noexcept -> ALfloat { return gain * ConeVolume; }
-            );
-        if(props->WetGainHFAuto)
-            std::transform(std::begin(WetGainHF), std::begin(WetGainHF)+NumSends,
-                std::begin(WetGainHF),
-                [ConeHF](ALfloat gain) noexcept -> ALfloat { return gain * ConeHF; }
-            );
+        DryGainBase *= ConeGain;
+        WetGainBase *= lerpf(1.0f, ConeGain, props->WetGainAuto);
+
+        WetConeHF = lerpf(1.0f, ConeHF, props->WetGainHFAuto);
     }
 
     /* Apply gain and frequency filters */
-    DryGain = clampf(DryGain, props->MinGain, props->MaxGain);
-    DryGain = minf(DryGain*props->Direct.Gain*Listener.Params.Gain, GAIN_MIX_MAX);
-    DryGainHF *= props->Direct.GainHF;
-    DryGainLF *= props->Direct.GainLF;
-    for(ALuint i{0};i < NumSends;i++)
+    DryGainBase = clampf(DryGainBase, props->MinGain, props->MaxGain) * context->mParams.Gain;
+    WetGainBase = clampf(WetGainBase, props->MinGain, props->MaxGain) * context->mParams.Gain;
+
+    GainTriplet DryGain{};
+    DryGain.Base = minf(DryGainBase * props->Direct.Gain, GainMixMax);
+    DryGain.HF = ConeHF * props->Direct.GainHF;
+    DryGain.LF = props->Direct.GainLF;
+    GainTriplet WetGain[MAX_SENDS]{};
+    for(uint i{0};i < NumSends;i++)
     {
-        WetGain[i] = clampf(WetGain[i], props->MinGain, props->MaxGain);
-        WetGain[i] = minf(WetGain[i]*props->Send[i].Gain*Listener.Params.Gain, GAIN_MIX_MAX);
-        WetGainHF[i] *= props->Send[i].GainHF;
-        WetGainLF[i] *= props->Send[i].GainLF;
+        /* If this effect slot's Auxiliary Send Auto is off, then use the dry
+         * path distance and cone attenuation, otherwise use the wet (room)
+         * path distance and cone attenuation. The send filter is used instead
+         * of the direct filter, regardless.
+         */
+        const bool use_room{!(UseDryAttnForRoom&(1u<<i))};
+        const float gain{use_room ? WetGainBase : DryGainBase};
+        WetGain[i].Base = minf(gain * props->Send[i].Gain, GainMixMax);
+        WetGain[i].HF = (use_room ? WetConeHF : ConeHF) * props->Send[i].GainHF;
+        WetGain[i].LF = props->Send[i].GainLF;
     }
 
     /* Distance-based air absorption and initial send decay. */
-    if(ClampedDist > props->RefDistance && props->RolloffFactor > 0.0f)
+    if(Distance > props->RefDistance) LIKELY
     {
-        ALfloat meters_base{(ClampedDist-props->RefDistance) * props->RolloffFactor *
-                            Listener.Params.MetersPerUnit};
-        if(props->AirAbsorptionFactor > 0.0f)
+        const float distance_base{(Distance-props->RefDistance) * props->RolloffFactor};
+        const float distance_meters{distance_base * context->mParams.MetersPerUnit};
+        const float dryabsorb{distance_meters * props->AirAbsorptionFactor};
+        if(dryabsorb > std::numeric_limits<float>::epsilon())
+            DryGain.HF *= std::pow(context->mParams.AirAbsorptionGainHF, dryabsorb);
+
+        /* If the source's Auxiliary Send Filter Gain Auto is off, no extra
+         * adjustment is applied to the send gains.
+         */
+        for(uint i{props->WetGainAuto ? 0u : NumSends};i < NumSends;++i)
         {
-            ALfloat hfattn{std::pow(AIRABSORBGAINHF, meters_base * props->AirAbsorptionFactor)};
-            DryGainHF *= hfattn;
-            std::transform(std::begin(WetGainHF), std::begin(WetGainHF)+NumSends,
-                std::begin(WetGainHF),
-                [hfattn](ALfloat gain) noexcept -> ALfloat { return gain * hfattn; }
-            );
-        }
+            if(!SendSlots[i] || !(SendSlots[i]->DecayTime > 0.0f))
+                continue;
 
-        if(props->WetGainAuto)
-        {
-            /* Apply a decay-time transformation to the wet path, based on the
-             * source distance in meters. The initial decay of the reverb
-             * effect is calculated and applied to the wet path.
-             */
-            for(ALuint i{0};i < NumSends;i++)
+            auto calc_attenuation = [](float distance, float refdist, float rolloff) noexcept
             {
-                if(!(DecayDistance[i] > 0.0f))
-                    continue;
+                const float dist{lerpf(refdist, distance, rolloff)};
+                if(dist > refdist) return refdist / dist;
+                return 1.0f;
+            };
 
-                const ALfloat gain{std::pow(REVERB_DECAY_GAIN, meters_base/DecayDistance[i])};
-                WetGain[i] *= gain;
-                /* Yes, the wet path's air absorption is applied with
-                 * WetGainAuto on, rather than WetGainHFAuto.
-                 */
-                if(gain > 0.0f)
+            /* The reverb effect's room rolloff factor always applies to an
+             * inverse distance rolloff model.
+             */
+            WetGain[i].Base *= calc_attenuation(Distance, props->RefDistance,
+                SendSlots[i]->RoomRolloff);
+
+            if(distance_meters > std::numeric_limits<float>::epsilon())
+                WetGain[i].HF *= std::pow(SendSlots[i]->AirAbsorptionGainHF, distance_meters);
+
+            /* If this effect slot's Auxiliary Send Auto is off, don't apply
+             * the automatic initial reverb decay (should the reverb's room
+             * rolloff still apply?).
+             */
+            if(!SendSlots[i]->AuxSendAuto)
+                continue;
+
+            GainTriplet DecayDistance;
+            /* Calculate the distances to where this effect's decay reaches
+             * -60dB.
+             */
+            DecayDistance.Base = SendSlots[i]->DecayTime * SpeedOfSoundMetersPerSec;
+            DecayDistance.LF = DecayDistance.Base * SendSlots[i]->DecayLFRatio;
+            DecayDistance.HF = DecayDistance.Base * SendSlots[i]->DecayHFRatio;
+            if(SendSlots[i]->DecayHFLimit)
+            {
+                const float airAbsorption{SendSlots[i]->AirAbsorptionGainHF};
+                if(airAbsorption < 1.0f)
                 {
-                    ALfloat gainhf{std::pow(REVERB_DECAY_GAIN, meters_base/DecayHFDistance[i])};
-                    WetGainHF[i] *= minf(gainhf / gain, 1.0f);
-                    ALfloat gainlf{std::pow(REVERB_DECAY_GAIN, meters_base/DecayLFDistance[i])};
-                    WetGainLF[i] *= minf(gainlf / gain, 1.0f);
+                    /* Calculate the distance to where this effect's air
+                     * absorption reaches -60dB, and limit the effect's HF
+                     * decay distance (so it doesn't take any longer to decay
+                     * than the air would allow).
+                     */
+                    static constexpr float log10_decaygain{-3.0f/*std::log10(ReverbDecayGain)*/};
+                    const float absorb_dist{log10_decaygain / std::log10(airAbsorption)};
+                    DecayDistance.HF = minf(absorb_dist, DecayDistance.HF);
                 }
             }
+
+            const float baseAttn = calc_attenuation(Distance, props->RefDistance,
+                props->RolloffFactor);
+
+            /* Apply a decay-time transformation to the wet path, based on the
+             * source distance. The initial decay of the reverb effect is
+             * calculated and applied to the wet path.
+             */
+            const float fact{distance_base / DecayDistance.Base};
+            const float gain{std::pow(ReverbDecayGain, fact)*(1.0f-baseAttn) + baseAttn};
+            WetGain[i].Base *= gain;
+
+            if(gain > 0.0f)
+            {
+                const float hffact{distance_base / DecayDistance.HF};
+                const float gainhf{std::pow(ReverbDecayGain, hffact)*(1.0f-baseAttn) + baseAttn};
+                WetGain[i].HF *= minf(gainhf/gain, 1.0f);
+                const float lffact{distance_base / DecayDistance.LF};
+                const float gainlf{std::pow(ReverbDecayGain, lffact)*(1.0f-baseAttn) + baseAttn};
+                WetGain[i].LF *= minf(gainlf/gain, 1.0f);
+            }
         }
     }
 
 
     /* Initial source pitch */
-    ALfloat Pitch{props->Pitch};
+    float Pitch{props->Pitch};
 
     /* Calculate velocity-based doppler effect */
-    ALfloat DopplerFactor{props->DopplerFactor * Listener.Params.DopplerFactor};
+    float DopplerFactor{props->DopplerFactor * context->mParams.DopplerFactor};
     if(DopplerFactor > 0.0f)
     {
-        const alu::Vector &lvelocity = Listener.Params.Velocity;
-        ALfloat vss{aluDotproduct(Velocity, ToSource) * -DopplerFactor};
-        ALfloat vls{aluDotproduct(lvelocity, ToSource) * -DopplerFactor};
+        const alu::Vector &lvelocity = context->mParams.Velocity;
+        float vss{Velocity.dot_product(ToSource) * -DopplerFactor};
+        float vls{lvelocity.dot_product(ToSource) * -DopplerFactor};
 
-        const ALfloat SpeedOfSound{Listener.Params.SpeedOfSound};
+        const float SpeedOfSound{context->mParams.SpeedOfSound};
         if(!(vls < SpeedOfSound))
         {
             /* Listener moving away from the source at the speed of sound.
@@ -1365,27 +1655,26 @@ void CalcAttnSourceParams(ALvoice *voice, const ALvoicePropsBase *props, const A
     /* Adjust pitch based on the buffer and output frequencies, and calculate
      * fixed-point stepping value.
      */
-    Pitch *= static_cast<ALfloat>(voice->mFrequency)/static_cast<ALfloat>(Device->Frequency);
-    if(Pitch > float{MAX_PITCH})
-        voice->mStep = MAX_PITCH<<FRACTIONBITS;
+    Pitch *= static_cast<float>(voice->mFrequency) / static_cast<float>(Device->Frequency);
+    if(Pitch > float{MaxPitch})
+        voice->mStep = MaxPitch<<MixerFracBits;
     else
-        voice->mStep = maxu(fastf2u(Pitch * FRACTIONONE), 1);
+        voice->mStep = maxu(fastf2u(Pitch * MixerFracOne), 1);
     voice->mResampler = PrepareResampler(props->mResampler, voice->mStep, &voice->mResampleState);
 
-    ALfloat spread{0.0f};
+    float spread{0.0f};
     if(props->Radius > Distance)
-        spread = al::MathDefs<float>::Tau() - Distance/props->Radius*al::MathDefs<float>::Pi();
+        spread = al::numbers::pi_v<float>*2.0f - Distance/props->Radius*al::numbers::pi_v<float>;
     else if(Distance > 0.0f)
         spread = std::asin(props->Radius/Distance) * 2.0f;
 
-    CalcPanningAndFilters(voice, ToSource[0], ToSource[1], ToSource[2]*ZScale,
-        Distance*Listener.Params.MetersPerUnit, spread, DryGain, DryGainHF, DryGainLF, WetGain,
-        WetGainLF, WetGainHF, SendSlots, props, Listener, Device);
+    CalcPanningAndFilters(voice, ToSource[0]*XScale, ToSource[1]*YScale, ToSource[2]*ZScale,
+        Distance, spread, DryGain, WetGain, SendSlots, props, context->mParams, Device);
 }
 
-void CalcSourceParams(ALvoice *voice, ALCcontext *context, bool force)
+void CalcSourceParams(Voice *voice, ContextBase *context, bool force)
 {
-    ALvoiceProps *props{voice->mUpdate.exchange(nullptr, std::memory_order_acq_rel)};
+    VoicePropsItem *props{voice->mUpdate.exchange(nullptr, std::memory_order_acq_rel)};
     if(!props && !force) return;
 
     if(props)
@@ -1395,221 +1684,284 @@ void CalcSourceParams(ALvoice *voice, ALCcontext *context, bool force)
         AtomicReplaceHead(context->mFreeVoiceProps, props);
     }
 
-    if((voice->mProps.mSpatializeMode == SpatializeAuto && voice->mFmtChannels == FmtMono) ||
-       voice->mProps.mSpatializeMode == SpatializeOn)
-        CalcAttnSourceParams(voice, &voice->mProps, context);
-    else
+    if((voice->mProps.DirectChannels != DirectMode::Off && voice->mFmtChannels != FmtMono
+            && !IsAmbisonic(voice->mFmtChannels))
+        || voice->mProps.mSpatializeMode == SpatializeMode::Off
+        || (voice->mProps.mSpatializeMode==SpatializeMode::Auto && voice->mFmtChannels != FmtMono))
         CalcNonAttnSourceParams(voice, &voice->mProps, context);
+    else
+        CalcAttnSourceParams(voice, &voice->mProps, context);
 }
 
 
-void ProcessParamUpdates(ALCcontext *ctx, const ALeffectslotArray &slots,
-    const al::span<ALvoice> voices)
+void SendSourceStateEvent(ContextBase *context, uint id, VChangeState state)
 {
-    IncrementRef(ctx->mUpdateCount);
-    if LIKELY(!ctx->mHoldUpdates.load(std::memory_order_acquire))
+    RingBuffer *ring{context->mAsyncEvents.get()};
+    auto evt_vec = ring->getWriteVector();
+    if(evt_vec.first.len < 1) return;
+
+    AsyncEvent *evt{al::construct_at(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf),
+        AsyncEvent::SourceStateChange)};
+    evt->u.srcstate.id = id;
+    switch(state)
     {
-        bool force{CalcContextParams(ctx)};
-        force |= CalcListenerParams(ctx);
-        force = std::accumulate(slots.begin(), slots.end(), force,
-            [ctx](const bool f, ALeffectslot *slot) -> bool
-            { return CalcEffectSlotParams(slot, ctx) | f; }
-        );
-
-        auto calc_params = [ctx,force](ALvoice &voice) -> void
-        {
-            if(voice.mSourceID.load(std::memory_order_acquire) != 0)
-                CalcSourceParams(&voice, ctx, force);
-        };
-        std::for_each(voices.begin(), voices.end(), calc_params);
+    case VChangeState::Reset:
+        evt->u.srcstate.state = AsyncEvent::SrcState::Reset;
+        break;
+    case VChangeState::Stop:
+        evt->u.srcstate.state = AsyncEvent::SrcState::Stop;
+        break;
+    case VChangeState::Play:
+        evt->u.srcstate.state = AsyncEvent::SrcState::Play;
+        break;
+    case VChangeState::Pause:
+        evt->u.srcstate.state = AsyncEvent::SrcState::Pause;
+        break;
+    /* Shouldn't happen. */
+    case VChangeState::Restart:
+        al::unreachable();
     }
-    IncrementRef(ctx->mUpdateCount);
+
+    ring->writeAdvance(1);
 }
 
-void ProcessContext(ALCcontext *ctx, const ALuint SamplesToDo)
+void ProcessVoiceChanges(ContextBase *ctx)
 {
-    ASSUME(SamplesToDo > 0);
+    VoiceChange *cur{ctx->mCurrentVoiceChange.load(std::memory_order_acquire)};
+    VoiceChange *next{cur->mNext.load(std::memory_order_acquire)};
+    if(!next) return;
 
-    const ALeffectslotArray &auxslots = *ctx->mActiveAuxSlots.load(std::memory_order_acquire);
-    const al::span<ALvoice> voices{ctx->mVoices.data(), ctx->mVoices.size()};
+    const auto enabledevt = ctx->mEnabledEvts.load(std::memory_order_acquire);
+    do {
+        cur = next;
 
-    /* Process pending propery updates for objects on the context. */
-    ProcessParamUpdates(ctx, auxslots, voices);
-
-    /* Clear auxiliary effect slot mixing buffers. */
-    std::for_each(auxslots.begin(), auxslots.end(),
-        [SamplesToDo](ALeffectslot *slot) -> void
+        bool sendevt{false};
+        if(cur->mState == VChangeState::Reset || cur->mState == VChangeState::Stop)
         {
-            for(auto &buffer : slot->MixBuffer)
-                std::fill_n(buffer.begin(), SamplesToDo, 0.0f);
+            if(Voice *voice{cur->mVoice})
+            {
+                voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
+                voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+                /* A source ID indicates the voice was playing or paused, which
+                 * gets a reset/stop event.
+                 */
+                sendevt = voice->mSourceID.exchange(0u, std::memory_order_relaxed) != 0u;
+                Voice::State oldvstate{Voice::Playing};
+                voice->mPlayState.compare_exchange_strong(oldvstate, Voice::Stopping,
+                    std::memory_order_relaxed, std::memory_order_acquire);
+                voice->mPendingChange.store(false, std::memory_order_release);
+            }
+            /* Reset state change events are always sent, even if the voice is
+             * already stopped or even if there is no voice.
+             */
+            sendevt |= (cur->mState == VChangeState::Reset);
         }
-    );
-
-    /* Process voices that have a playing source. */
-    std::for_each(voices.begin(), voices.end(),
-        [SamplesToDo,ctx](ALvoice &voice) -> void
+        else if(cur->mState == VChangeState::Pause)
         {
-            const ALvoice::State vstate{voice.mPlayState.load(std::memory_order_acquire)};
-            if(vstate != ALvoice::Stopped) voice.mix(vstate, ctx, SamplesToDo);
+            Voice *voice{cur->mVoice};
+            Voice::State oldvstate{Voice::Playing};
+            sendevt = voice->mPlayState.compare_exchange_strong(oldvstate, Voice::Stopping,
+                std::memory_order_release, std::memory_order_acquire);
         }
-    );
+        else if(cur->mState == VChangeState::Play)
+        {
+            /* NOTE: When playing a voice, sending a source state change event
+             * depends if there's an old voice to stop and if that stop is
+             * successful. If there is no old voice, a playing event is always
+             * sent. If there is an old voice, an event is sent only if the
+             * voice is already stopped.
+             */
+            if(Voice *oldvoice{cur->mOldVoice})
+            {
+                oldvoice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
+                oldvoice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+                oldvoice->mSourceID.store(0u, std::memory_order_relaxed);
+                Voice::State oldvstate{Voice::Playing};
+                sendevt = !oldvoice->mPlayState.compare_exchange_strong(oldvstate, Voice::Stopping,
+                    std::memory_order_relaxed, std::memory_order_acquire);
+                oldvoice->mPendingChange.store(false, std::memory_order_release);
+            }
+            else
+                sendevt = true;
 
-    /* Process effects. */
-    if(auxslots.empty()) return;
-    auto slots = auxslots.data();
-    auto slots_end = slots + auxslots.size();
+            Voice *voice{cur->mVoice};
+            voice->mPlayState.store(Voice::Playing, std::memory_order_release);
+        }
+        else if(cur->mState == VChangeState::Restart)
+        {
+            /* Restarting a voice never sends a source change event. */
+            Voice *oldvoice{cur->mOldVoice};
+            oldvoice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
+            oldvoice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+            /* If there's no sourceID, the old voice finished so don't start
+             * the new one at its new offset.
+             */
+            if(oldvoice->mSourceID.exchange(0u, std::memory_order_relaxed) != 0u)
+            {
+                /* Otherwise, set the voice to stopping if it's not already (it
+                 * might already be, if paused), and play the new voice as
+                 * appropriate.
+                 */
+                Voice::State oldvstate{Voice::Playing};
+                oldvoice->mPlayState.compare_exchange_strong(oldvstate, Voice::Stopping,
+                    std::memory_order_relaxed, std::memory_order_acquire);
 
-    /* First sort the slots into scratch storage, so that effects come before
-     * their effect target (or their targets' target).
-     */
-    auto sorted_slots = const_cast<ALeffectslot**>(slots_end);
-    auto sorted_slots_end = sorted_slots;
-    auto in_chain = [](const ALeffectslot *slot1, const ALeffectslot *slot2) noexcept -> bool
-    {
-        while((slot1=slot1->Params.Target) != nullptr) {
-            if(slot1 == slot2) return true;
+                Voice *voice{cur->mVoice};
+                voice->mPlayState.store((oldvstate == Voice::Playing) ? Voice::Playing
+                    : Voice::Stopped, std::memory_order_release);
+            }
+            oldvoice->mPendingChange.store(false, std::memory_order_release);
         }
-        return false;
-    };
+        if(sendevt && enabledevt.test(AsyncEvent::SourceStateChange))
+            SendSourceStateEvent(ctx, cur->mSourceID, cur->mState);
+
+        next = cur->mNext.load(std::memory_order_acquire);
+    } while(next);
+    ctx->mCurrentVoiceChange.store(cur, std::memory_order_release);
+}
 
-    *sorted_slots_end = *slots;
-    ++sorted_slots_end;
-    while(++slots != slots_end)
+void ProcessParamUpdates(ContextBase *ctx, const EffectSlotArray &slots,
+    const al::span<Voice*> voices)
+{
+    ProcessVoiceChanges(ctx);
+
+    IncrementRef(ctx->mUpdateCount);
+    if(!ctx->mHoldUpdates.load(std::memory_order_acquire)) LIKELY
     {
-        /* If this effect slot targets an effect slot already in the list (i.e.
-         * slots outputs to something in sorted_slots), directly or indirectly,
-         * insert it prior to that element.
-         */
-        auto checker = sorted_slots;
-        do {
-            if(in_chain(*slots, *checker)) break;
-        } while(++checker != sorted_slots_end);
-
-        checker = std::move_backward(checker, sorted_slots_end, sorted_slots_end+1);
-        *--checker = *slots;
-        ++sorted_slots_end;
-    }
+        bool force{CalcContextParams(ctx)};
+        auto sorted_slots = const_cast<EffectSlot**>(slots.data() + slots.size());
+        for(EffectSlot *slot : slots)
+            force |= CalcEffectSlotParams(slot, sorted_slots, ctx);
 
-    std::for_each(sorted_slots, sorted_slots_end,
-        [SamplesToDo](const ALeffectslot *slot) -> void
+        for(Voice *voice : voices)
         {
-            EffectState *state{slot->Params.mEffectState};
-            state->process(SamplesToDo, slot->Wet.Buffer, state->mOutTarget);
+            /* Only update voices that have a source. */
+            if(voice->mSourceID.load(std::memory_order_relaxed) != 0)
+                CalcSourceParams(voice, ctx, force);
         }
-    );
+    }
+    IncrementRef(ctx->mUpdateCount);
 }
 
-
-void ApplyStablizer(FrontStablizer *Stablizer, const al::span<FloatBufferLine> Buffer,
-    const ALuint lidx, const ALuint ridx, const ALuint cidx, const ALuint SamplesToDo)
+void ProcessContexts(DeviceBase *device, const uint SamplesToDo)
 {
     ASSUME(SamplesToDo > 0);
 
-    /* Apply a delay to all channels, except the front-left and front-right, so
-     * they maintain correct timing.
-     */
-    const size_t NumChannels{Buffer.size()};
-    for(size_t i{0u};i < NumChannels;i++)
+    const nanoseconds curtime{device->ClockBase +
+        nanoseconds{seconds{device->SamplesDone}}/device->Frequency};
+
+    for(ContextBase *ctx : *device->mContexts.load(std::memory_order_acquire))
     {
-        if(i == lidx || i == ridx)
-            continue;
+        const EffectSlotArray &auxslots = *ctx->mActiveAuxSlots.load(std::memory_order_acquire);
+        const al::span<Voice*> voices{ctx->getVoicesSpanAcquired()};
 
-        auto &DelayBuf = Stablizer->DelayBuf[i];
-        auto buffer_end = Buffer[i].begin() + SamplesToDo;
-        if LIKELY(SamplesToDo >= ALuint{FrontStablizer::DelayLength})
+        /* Process pending propery updates for objects on the context. */
+        ProcessParamUpdates(ctx, auxslots, voices);
+
+        /* Clear auxiliary effect slot mixing buffers. */
+        for(EffectSlot *slot : auxslots)
         {
-            auto delay_end = std::rotate(Buffer[i].begin(),
-                buffer_end - FrontStablizer::DelayLength, buffer_end);
-            std::swap_ranges(Buffer[i].begin(), delay_end, std::begin(DelayBuf));
+            for(auto &buffer : slot->Wet.Buffer)
+                buffer.fill(0.0f);
         }
-        else
+
+        /* Process voices that have a playing source. */
+        for(Voice *voice : voices)
         {
-            auto delay_start = std::swap_ranges(Buffer[i].begin(), buffer_end,
-                std::begin(DelayBuf));
-            std::rotate(std::begin(DelayBuf), delay_start, std::end(DelayBuf));
+            const Voice::State vstate{voice->mPlayState.load(std::memory_order_acquire)};
+            if(vstate != Voice::Stopped && vstate != Voice::Pending)
+                voice->mix(vstate, ctx, curtime, SamplesToDo);
         }
-    }
 
-    ALfloat (&lsplit)[2][BUFFERSIZE] = Stablizer->LSplit;
-    ALfloat (&rsplit)[2][BUFFERSIZE] = Stablizer->RSplit;
-    auto &tmpbuf = Stablizer->TempBuf;
-
-    /* This applies the band-splitter, preserving phase at the cost of some
-     * delay. The shorter the delay, the more error seeps into the result.
-     */
-    auto apply_splitter = [&tmpbuf,SamplesToDo](const FloatBufferLine &InBuf,
-        ALfloat (&DelayBuf)[FrontStablizer::DelayLength], BandSplitter &Filter,
-        ALfloat (&splitbuf)[2][BUFFERSIZE]) -> void
-    {
-        /* Combine the delayed samples and the input samples into the temp
-         * buffer, in reverse. Then copy the final samples back into the delay
-         * buffer for next time. Note that the delay buffer's samples are
-         * stored backwards here.
-         */
-        auto tmpbuf_end = std::begin(tmpbuf) + SamplesToDo;
-        std::copy_n(std::begin(DelayBuf), FrontStablizer::DelayLength, tmpbuf_end);
-        std::reverse_copy(InBuf.begin(), InBuf.begin()+SamplesToDo, std::begin(tmpbuf));
-        std::copy_n(std::begin(tmpbuf), FrontStablizer::DelayLength, std::begin(DelayBuf));
-
-        /* Apply an all-pass on the reversed signal, then reverse the samples
-         * to get the forward signal with a reversed phase shift.
-         */
-        Filter.applyAllpass(tmpbuf, SamplesToDo+FrontStablizer::DelayLength);
-        std::reverse(std::begin(tmpbuf), tmpbuf_end+FrontStablizer::DelayLength);
+        /* Process effects. */
+        if(const size_t num_slots{auxslots.size()})
+        {
+            auto slots = auxslots.data();
+            auto slots_end = slots + num_slots;
 
-        /* Now apply the band-splitter, combining its phase shift with the
-         * reversed phase shift, restoring the original phase on the split
-         * signal.
-         */
-        Filter.process(splitbuf[1], splitbuf[0], tmpbuf, SamplesToDo);
-    };
-    apply_splitter(Buffer[lidx], Stablizer->DelayBuf[lidx], Stablizer->LFilter, lsplit);
-    apply_splitter(Buffer[ridx], Stablizer->DelayBuf[ridx], Stablizer->RFilter, rsplit);
+            /* Sort the slots into extra storage, so that effect slots come
+             * before their effect slot target (or their targets' target).
+             */
+            const al::span<EffectSlot*> sorted_slots{const_cast<EffectSlot**>(slots_end),
+                num_slots};
+            /* Skip sorting if it has already been done. */
+            if(!sorted_slots[0])
+            {
+                /* First, copy the slots to the sorted list, then partition the
+                 * sorted list so that all slots without a target slot go to
+                 * the end.
+                 */
+                std::copy(slots, slots_end, sorted_slots.begin());
+                auto split_point = std::partition(sorted_slots.begin(), sorted_slots.end(),
+                    [](const EffectSlot *slot) noexcept -> bool
+                    { return slot->Target != nullptr; });
+                /* There must be at least one slot without a slot target. */
+                assert(split_point != sorted_slots.end());
+
+                /* Simple case: no more than 1 slot has a target slot. Either
+                 * all slots go right to the output, or the remaining one must
+                 * target an already-partitioned slot.
+                 */
+                if(split_point - sorted_slots.begin() > 1)
+                {
+                    /* At least two slots target other slots. Starting from the
+                     * back of the sorted list, continue partitioning the front
+                     * of the list given each target until all targets are
+                     * accounted for. This ensures all slots without a target
+                     * go last, all slots directly targeting those last slots
+                     * go second-to-last, all slots directly targeting those
+                     * second-last slots go third-to-last, etc.
+                     */
+                    auto next_target = sorted_slots.end();
+                    do {
+                        /* This shouldn't happen, but if there's unsorted slots
+                         * left that don't target any sorted slots, they can't
+                         * contribute to the output, so leave them.
+                         */
+                        if(next_target == split_point) UNLIKELY
+                            break;
+
+                        --next_target;
+                        split_point = std::partition(sorted_slots.begin(), split_point,
+                            [next_target](const EffectSlot *slot) noexcept -> bool
+                            { return slot->Target != *next_target; });
+                    } while(split_point - sorted_slots.begin() > 1);
+                }
+            }
 
-    for(ALuint i{0};i < SamplesToDo;i++)
-    {
-        ALfloat lfsum{lsplit[0][i] + rsplit[0][i]};
-        ALfloat hfsum{lsplit[1][i] + rsplit[1][i]};
-        ALfloat s{lsplit[0][i] + lsplit[1][i] - rsplit[0][i] - rsplit[1][i]};
-
-        /* This pans the separate low- and high-frequency sums between being on
-         * the center channel and the left/right channels. The low-frequency
-         * sum is 1/3rd toward center (2/3rds on left/right) and the high-
-         * frequency sum is 1/4th toward center (3/4ths on left/right). These
-         * values can be tweaked.
-         */
-        ALfloat m{lfsum*std::cos(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
-            hfsum*std::cos(1.0f/4.0f * (al::MathDefs<float>::Pi()*0.5f))};
-        ALfloat c{lfsum*std::sin(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
-            hfsum*std::sin(1.0f/4.0f * (al::MathDefs<float>::Pi()*0.5f))};
+            for(const EffectSlot *slot : sorted_slots)
+            {
+                EffectState *state{slot->mEffectState.get()};
+                state->process(SamplesToDo, slot->Wet.Buffer, state->mOutTarget);
+            }
+        }
 
-        /* The generated center channel signal adds to the existing signal,
-         * while the modified left and right channels replace.
-         */
-        Buffer[lidx][i] = (m + s) * 0.5f;
-        Buffer[ridx][i] = (m - s) * 0.5f;
-        Buffer[cidx][i] += c * 0.5f;
+        /* Signal the event handler if there are any events to read. */
+        RingBuffer *ring{ctx->mAsyncEvents.get()};
+        if(ring->readSpace() > 0)
+            ctx->mEventSem.post();
     }
 }
 
-void ApplyDistanceComp(const al::span<FloatBufferLine> Samples, const ALuint SamplesToDo,
-    const DistanceComp::DistData *distcomp)
+
+void ApplyDistanceComp(const al::span<FloatBufferLine> Samples, const size_t SamplesToDo,
+    const DistanceComp::ChanData *distcomp)
 {
     ASSUME(SamplesToDo > 0);
 
     for(auto &chanbuffer : Samples)
     {
-        const ALfloat gain{distcomp->Gain};
-        const ALuint base{distcomp->Length};
-        ALfloat *distbuf{al::assume_aligned<16>(distcomp->Buffer)};
+        const float gain{distcomp->Gain};
+        const size_t base{distcomp->Length};
+        float *distbuf{al::assume_aligned<16>(distcomp->Buffer)};
         ++distcomp;
 
         if(base < 1)
             continue;
 
-        ALfloat *inout{al::assume_aligned<16>(chanbuffer.data())};
+        float *inout{al::assume_aligned<16>(chanbuffer.data())};
         auto inout_end = inout + SamplesToDo;
-        if LIKELY(SamplesToDo >= base)
+        if(SamplesToDo >= base) LIKELY
         {
             auto delay_end = std::rotate(inout, inout_end - base, inout_end);
             std::swap_ranges(inout, delay_end, distbuf);
@@ -1619,33 +1971,31 @@ void ApplyDistanceComp(const al::span<FloatBufferLine> Samples, const ALuint Sam
             auto delay_start = std::swap_ranges(inout, inout_end, distbuf);
             std::rotate(distbuf, delay_start, distbuf + base);
         }
-        std::transform(inout, inout_end, inout, std::bind(std::multiplies<float>{}, _1, gain));
+        std::transform(inout, inout_end, inout, [gain](float s) { return s * gain; });
     }
 }
 
-void ApplyDither(const al::span<FloatBufferLine> Samples, ALuint *dither_seed,
-    const ALfloat quant_scale, const ALuint SamplesToDo)
+void ApplyDither(const al::span<FloatBufferLine> Samples, uint *dither_seed,
+    const float quant_scale, const size_t SamplesToDo)
 {
+    ASSUME(SamplesToDo > 0);
+
     /* Dithering. Generate whitenoise (uniform distribution of random values
      * between -1 and +1) and add it to the sample values, after scaling up to
      * the desired quantization depth amd before rounding.
      */
-    const ALfloat invscale{1.0f / quant_scale};
-    ALuint seed{*dither_seed};
-    auto dither_channel = [&seed,invscale,quant_scale,SamplesToDo](FloatBufferLine &input) -> void
+    const float invscale{1.0f / quant_scale};
+    uint seed{*dither_seed};
+    auto dither_sample = [&seed,invscale,quant_scale](const float sample) noexcept -> float
     {
-        ASSUME(SamplesToDo > 0);
-        auto dither_sample = [&seed,invscale,quant_scale](const ALfloat sample) noexcept -> ALfloat
-        {
-            ALfloat val{sample * quant_scale};
-            ALuint rng0{dither_rng(&seed)};
-            ALuint rng1{dither_rng(&seed)};
-            val += static_cast<ALfloat>(rng0*(1.0/UINT_MAX) - rng1*(1.0/UINT_MAX));
-            return fast_roundf(val) * invscale;
-        };
-        std::transform(input.begin(), input.begin()+SamplesToDo, input.begin(), dither_sample);
+        float val{sample * quant_scale};
+        uint rng0{dither_rng(&seed)};
+        uint rng1{dither_rng(&seed)};
+        val += static_cast<float>(rng0*(1.0/UINT_MAX) - rng1*(1.0/UINT_MAX));
+        return fast_roundf(val) * invscale;
     };
-    std::for_each(Samples.begin(), Samples.end(), dither_channel);
+    for(FloatBufferLine &inout : Samples)
+        std::transform(inout.begin(), inout.begin()+SamplesToDo, inout.begin(), dither_sample);
     *dither_seed = seed;
 }
 
@@ -1682,161 +2032,179 @@ template<> inline uint8_t SampleConv(float val) noexcept
 
 template<DevFmtType T>
 void Write(const al::span<const FloatBufferLine> InBuffer, void *OutBuffer, const size_t Offset,
-    const ALuint SamplesToDo)
+    const size_t SamplesToDo, const size_t FrameStep)
 {
-    using SampleType = typename DevFmtTypeTraits<T>::Type;
-
-    const size_t numchans{InBuffer.size()};
-    ASSUME(numchans > 0);
+    ASSUME(FrameStep > 0);
+    ASSUME(SamplesToDo > 0);
 
-    SampleType *outbase = static_cast<SampleType*>(OutBuffer) + Offset*numchans;
-    auto conv_channel = [&outbase,SamplesToDo,numchans](const FloatBufferLine &inbuf) -> void
+    DevFmtType_t<T> *outbase{static_cast<DevFmtType_t<T>*>(OutBuffer) + Offset*FrameStep};
+    size_t c{0};
+    for(const FloatBufferLine &inbuf : InBuffer)
     {
-        ASSUME(SamplesToDo > 0);
-        SampleType *out{outbase++};
-        auto conv_sample = [numchans,&out](const float s) noexcept -> void
+        DevFmtType_t<T> *out{outbase++};
+        auto conv_sample = [FrameStep,&out](const float s) noexcept -> void
         {
-            *out = SampleConv<SampleType>(s);
-            out += numchans;
+            *out = SampleConv<DevFmtType_t<T>>(s);
+            out += FrameStep;
         };
         std::for_each(inbuf.begin(), inbuf.begin()+SamplesToDo, conv_sample);
-    };
-    std::for_each(InBuffer.cbegin(), InBuffer.cend(), conv_channel);
+        ++c;
+    }
+    if(const size_t extra{FrameStep - c})
+    {
+        const auto silence = SampleConv<DevFmtType_t<T>>(0.0f);
+        for(size_t i{0};i < SamplesToDo;++i)
+        {
+            std::fill_n(outbase, extra, silence);
+            outbase += FrameStep;
+        }
+    }
 }
 
 } // namespace
 
-void aluMixData(ALCdevice *device, ALvoid *OutBuffer, const ALuint NumSamples)
+uint DeviceBase::renderSamples(const uint numSamples)
 {
-    FPUCtl mixer_mode{};
-    for(ALuint SamplesDone{0u};SamplesDone < NumSamples;)
-    {
-        const ALuint SamplesToDo{minu(NumSamples-SamplesDone, BUFFERSIZE)};
+    const uint samplesToDo{minu(numSamples, BufferLineSize)};
 
-        /* Clear main mixing buffers. */
-        std::for_each(device->MixBuffer.begin(), device->MixBuffer.end(),
-            [SamplesToDo](std::array<ALfloat,BUFFERSIZE> &buffer) -> void
-            { std::fill_n(buffer.begin(), SamplesToDo, 0.0f); }
-        );
+    /* Clear main mixing buffers. */
+    for(FloatBufferLine &buffer : MixBuffer)
+        buffer.fill(0.0f);
 
-        /* Increment the mix count at the start (lsb should now be 1). */
-        IncrementRef(device->MixCount);
+    /* Increment the mix count at the start (lsb should now be 1). */
+    IncrementRef(MixCount);
 
-        /* For each context on this device, process and mix its sources and
-         * effects.
-         */
-        for(ALCcontext *ctx : *device->mContexts.load(std::memory_order_acquire))
-            ProcessContext(ctx, SamplesToDo);
+    /* Process and mix each context's sources and effects. */
+    ProcessContexts(this, samplesToDo);
 
-        /* Increment the clock time. Every second's worth of samples is
-         * converted and added to clock base so that large sample counts don't
-         * overflow during conversion. This also guarantees a stable
-         * conversion.
-         */
-        device->SamplesDone += SamplesToDo;
-        device->ClockBase += std::chrono::seconds{device->SamplesDone / device->Frequency};
-        device->SamplesDone %= device->Frequency;
+    /* Increment the clock time. Every second's worth of samples is converted
+     * and added to clock base so that large sample counts don't overflow
+     * during conversion. This also guarantees a stable conversion.
+     */
+    SamplesDone += samplesToDo;
+    ClockBase += std::chrono::seconds{SamplesDone / Frequency};
+    SamplesDone %= Frequency;
 
-        /* Increment the mix count at the end (lsb should now be 0). */
-        IncrementRef(device->MixCount);
+    /* Increment the mix count at the end (lsb should now be 0). */
+    IncrementRef(MixCount);
 
-        /* Apply any needed post-process for finalizing the Dry mix to the
-         * RealOut (Ambisonic decode, UHJ encode, etc).
-         */
-        device->postProcess(SamplesToDo);
+    /* Apply any needed post-process for finalizing the Dry mix to the RealOut
+     * (Ambisonic decode, UHJ encode, etc).
+     */
+    postProcess(samplesToDo);
 
-        const al::span<FloatBufferLine> RealOut{device->RealOut.Buffer};
+    /* Apply compression, limiting sample amplitude if needed or desired. */
+    if(Limiter) Limiter->process(samplesToDo, RealOut.Buffer.data());
 
-        /* Apply front image stablization for surround sound, if applicable. */
-        if(device->Stablizer)
-        {
-            const ALuint lidx{GetChannelIdxByName(device->RealOut, FrontLeft)};
-            const ALuint ridx{GetChannelIdxByName(device->RealOut, FrontRight)};
-            const ALuint cidx{GetChannelIdxByName(device->RealOut, FrontCenter)};
+    /* Apply delays and attenuation for mismatched speaker distances. */
+    if(ChannelDelays)
+        ApplyDistanceComp(RealOut.Buffer, samplesToDo, ChannelDelays->mChannels.data());
 
-            ApplyStablizer(device->Stablizer.get(), RealOut, lidx, ridx, cidx, SamplesToDo);
-        }
+    /* Apply dithering. The compressor should have left enough headroom for the
+     * dither noise to not saturate.
+     */
+    if(DitherDepth > 0.0f)
+        ApplyDither(RealOut.Buffer, &DitherSeed, DitherDepth, samplesToDo);
 
-        /* Apply compression, limiting sample amplitude if needed or desired. */
-        if(Compressor *comp{device->Limiter.get()})
-            comp->process(SamplesToDo, RealOut.data());
+    return samplesToDo;
+}
 
-        /* Apply delays and attenuation for mismatched speaker distances. */
-        ApplyDistanceComp(RealOut, SamplesToDo, device->ChannelDelay.as_span().cbegin());
+void DeviceBase::renderSamples(const al::span<float*> outBuffers, const uint numSamples)
+{
+    FPUCtl mixer_mode{};
+    uint total{0};
+    while(const uint todo{numSamples - total})
+    {
+        const uint samplesToDo{renderSamples(todo)};
 
-        /* Apply dithering. The compressor should have left enough headroom for
-         * the dither noise to not saturate.
-         */
-        if(device->DitherDepth > 0.0f)
-            ApplyDither(RealOut, &device->DitherSeed, device->DitherDepth, SamplesToDo);
+        auto *srcbuf = RealOut.Buffer.data();
+        for(auto *dstbuf : outBuffers)
+        {
+            std::copy_n(srcbuf->data(), samplesToDo, dstbuf + total);
+            ++srcbuf;
+        }
 
-        if LIKELY(OutBuffer)
+        total += samplesToDo;
+    }
+}
+
+void DeviceBase::renderSamples(void *outBuffer, const uint numSamples, const size_t frameStep)
+{
+    FPUCtl mixer_mode{};
+    uint total{0};
+    while(const uint todo{numSamples - total})
+    {
+        const uint samplesToDo{renderSamples(todo)};
+
+        if(outBuffer) LIKELY
         {
             /* Finally, interleave and convert samples, writing to the device's
              * output buffer.
              */
-            switch(device->FmtType)
+            switch(FmtType)
             {
-#define HANDLE_WRITE(T) case T:                                            \
-    Write<T>(RealOut, OutBuffer, SamplesDone, SamplesToDo); break;
-                HANDLE_WRITE(DevFmtByte)
-                HANDLE_WRITE(DevFmtUByte)
-                HANDLE_WRITE(DevFmtShort)
-                HANDLE_WRITE(DevFmtUShort)
-                HANDLE_WRITE(DevFmtInt)
-                HANDLE_WRITE(DevFmtUInt)
-                HANDLE_WRITE(DevFmtFloat)
+#define HANDLE_WRITE(T) case T:                                               \
+    Write<T>(RealOut.Buffer, outBuffer, total, samplesToDo, frameStep); break;
+            HANDLE_WRITE(DevFmtByte)
+            HANDLE_WRITE(DevFmtUByte)
+            HANDLE_WRITE(DevFmtShort)
+            HANDLE_WRITE(DevFmtUShort)
+            HANDLE_WRITE(DevFmtInt)
+            HANDLE_WRITE(DevFmtUInt)
+            HANDLE_WRITE(DevFmtFloat)
 #undef HANDLE_WRITE
             }
         }
 
-        SamplesDone += SamplesToDo;
+        total += samplesToDo;
     }
 }
 
-
-void aluHandleDisconnect(ALCdevice *device, const char *msg, ...)
+void DeviceBase::handleDisconnect(const char *msg, ...)
 {
-    if(!device->Connected.exchange(false, std::memory_order_acq_rel))
-        return;
-
-    AsyncEvent evt{EventType_Disconnected};
-    evt.u.user.type = AL_EVENT_TYPE_DISCONNECTED_SOFT;
-    evt.u.user.id = 0;
-    evt.u.user.param = 0;
+    IncrementRef(MixCount);
+    if(Connected.exchange(false, std::memory_order_acq_rel))
+    {
+        AsyncEvent evt{AsyncEvent::Disconnected};
 
-    va_list args;
-    va_start(args, msg);
-    int msglen{vsnprintf(evt.u.user.msg, sizeof(evt.u.user.msg), msg, args)};
-    va_end(args);
+        va_list args;
+        va_start(args, msg);
+        int msglen{vsnprintf(evt.u.disconnect.msg, sizeof(evt.u.disconnect.msg), msg, args)};
+        va_end(args);
 
-    if(msglen < 0 || static_cast<size_t>(msglen) >= sizeof(evt.u.user.msg))
-        evt.u.user.msg[sizeof(evt.u.user.msg)-1] = 0;
+        if(msglen < 0 || static_cast<size_t>(msglen) >= sizeof(evt.u.disconnect.msg))
+            evt.u.disconnect.msg[sizeof(evt.u.disconnect.msg)-1] = 0;
 
-    IncrementRef(device->MixCount);
-    for(ALCcontext *ctx : *device->mContexts.load())
-    {
-        const ALbitfieldSOFT enabledevt{ctx->mEnabledEvts.load(std::memory_order_acquire)};
-        if((enabledevt&EventType_Disconnected))
+        for(ContextBase *ctx : *mContexts.load())
         {
-            RingBuffer *ring{ctx->mAsyncEvents.get()};
-            auto evt_data = ring->getWriteVector().first;
-            if(evt_data.len > 0)
+            if(ctx->mEnabledEvts.load(std::memory_order_acquire).test(AsyncEvent::Disconnected))
             {
-                ::new (evt_data.buf) AsyncEvent{evt};
-                ring->writeAdvance(1);
-                ctx->mEventSem.post();
+                RingBuffer *ring{ctx->mAsyncEvents.get()};
+                auto evt_data = ring->getWriteVector().first;
+                if(evt_data.len > 0)
+                {
+                    al::construct_at(reinterpret_cast<AsyncEvent*>(evt_data.buf), evt);
+                    ring->writeAdvance(1);
+                    ctx->mEventSem.post();
+                }
             }
-        }
 
-        auto stop_voice = [](ALvoice &voice) -> void
-        {
-            voice.mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
-            voice.mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-            voice.mSourceID.store(0u, std::memory_order_relaxed);
-            voice.mPlayState.store(ALvoice::Stopped, std::memory_order_release);
-        };
-        std::for_each(ctx->mVoices.begin(), ctx->mVoices.end(), stop_voice);
+            if(!ctx->mStopVoicesOnDisconnect)
+            {
+                ProcessVoiceChanges(ctx);
+                continue;
+            }
+
+            auto voicelist = ctx->getVoicesSpanAcquired();
+            auto stop_voice = [](Voice *voice) -> void
+            {
+                voice->mCurrentBuffer.store(nullptr, std::memory_order_relaxed);
+                voice->mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+                voice->mSourceID.store(0u, std::memory_order_relaxed);
+                voice->mPlayState.store(Voice::Stopped, std::memory_order_release);
+            };
+            std::for_each(voicelist.begin(), voicelist.end(), stop_voice);
+        }
     }
-    IncrementRef(device->MixCount);
+    IncrementRef(MixCount);
 }
diff --git a/alc/alu.h b/alc/alu.h
index b3cfd840..67fd09e5 100644
--- a/alc/alu.h
+++ b/alc/alu.h
@@ -1,158 +1,38 @@
 #ifndef ALU_H
 #define ALU_H
 
-#include <array>
-#include <cmath>
-#include <cstddef>
+#include <bitset>
 
-#include "AL/al.h"
+#include "aloptional.h"
 
-#include "alcmain.h"
-#include "alspan.h"
-#include "logging.h"
+struct ALCcontext;
+struct ALCdevice;
+struct EffectSlot;
 
-struct ALbufferlistitem;
-struct ALeffectslot;
+enum class StereoEncoding : unsigned char;
 
 
-#define MAX_PITCH  255
-#define MAX_SENDS  16
+constexpr float GainMixMax{1000.0f}; /* +60dB */
 
 
-using MixerFunc = void(*)(const al::span<const float> InSamples,
-    const al::span<FloatBufferLine> OutBuffer, float *CurrentGains, const float *TargetGains,
-    const size_t Counter, const size_t OutPos);
-using RowMixerFunc = void(*)(const al::span<float> OutBuffer, const al::span<const float> Gains,
-    const float *InSamples, const size_t InStride);
-using HrtfDirectMixerFunc = void(*)(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
-    const size_t BufferSize);
+enum CompatFlags : uint8_t {
+    ReverseX,
+    ReverseY,
+    ReverseZ,
 
-extern MixerFunc MixSamples;
-extern RowMixerFunc MixRowSamples;
-
-
-#define GAIN_MIX_MAX  (1000.0f) /* +60dB */
-
-#define GAIN_SILENCE_THRESHOLD  (0.00001f) /* -100dB */
-
-#define SPEEDOFSOUNDMETRESPERSEC  (343.3f)
-#define AIRABSORBGAINHF           (0.99426f) /* -0.05dB */
-
-/* Target gain for the reverb decay feedback reaching the decay time. */
-#define REVERB_DECAY_GAIN  (0.001f) /* -60 dB */
-
-#define FRACTIONBITS (12)
-#define FRACTIONONE  (1<<FRACTIONBITS)
-#define FRACTIONMASK (FRACTIONONE-1)
-
-
-inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu) noexcept
-{ return val1 + (val2-val1)*mu; }
-inline ALfloat cubic(ALfloat val1, ALfloat val2, ALfloat val3, ALfloat val4, ALfloat mu) noexcept
-{
-    ALfloat mu2 = mu*mu, mu3 = mu2*mu;
-    ALfloat a0 = -0.5f*mu3 +       mu2 + -0.5f*mu;
-    ALfloat a1 =  1.5f*mu3 + -2.5f*mu2            + 1.0f;
-    ALfloat a2 = -1.5f*mu3 +  2.0f*mu2 +  0.5f*mu;
-    ALfloat a3 =  0.5f*mu3 + -0.5f*mu2;
-    return val1*a0 + val2*a1 + val3*a2 + val4*a3;
-}
-
-
-enum HrtfRequestMode {
-    Hrtf_Default = 0,
-    Hrtf_Enable = 1,
-    Hrtf_Disable = 2,
+    Count
 };
+using CompatFlagBitset = std::bitset<CompatFlags::Count>;
 
-void aluInit(void);
-
-void aluInitMixer(void);
+void aluInit(CompatFlagBitset flags, const float nfcscale);
 
 /* aluInitRenderer
  *
  * Set up the appropriate panning method and mixing method given the device
  * properties.
  */
-void aluInitRenderer(ALCdevice *device, ALint hrtf_id, HrtfRequestMode hrtf_appreq, HrtfRequestMode hrtf_userreq);
-
-void aluInitEffectPanning(ALeffectslot *slot, ALCdevice *device);
-
-/**
- * Calculates ambisonic encoder coefficients using the X, Y, and Z direction
- * components, which must represent a normalized (unit length) vector, and the
- * spread is the angular width of the sound (0...tau).
- *
- * NOTE: The components use ambisonic coordinates. As a result:
- *
- * Ambisonic Y = OpenAL -X
- * Ambisonic Z = OpenAL Y
- * Ambisonic X = OpenAL -Z
- *
- * The components are ordered such that OpenAL's X, Y, and Z are the first,
- * second, and third parameters respectively -- simply negate X and Z.
- */
-void CalcAmbiCoeffs(const float y, const float z, const float x, const float spread,
-    const al::span<float,MAX_AMBI_CHANNELS> coeffs);
-
-/**
- * CalcDirectionCoeffs
- *
- * Calculates ambisonic coefficients based on an OpenAL direction vector. The
- * vector must be normalized (unit length), and the spread is the angular width
- * of the sound (0...tau).
- */
-inline void CalcDirectionCoeffs(const float (&dir)[3], const float spread,
-    const al::span<float,MAX_AMBI_CHANNELS> coeffs)
-{
-    /* Convert from OpenAL coords to Ambisonics. */
-    CalcAmbiCoeffs(-dir[0], dir[1], -dir[2], spread, coeffs);
-}
-
-/**
- * CalcAngleCoeffs
- *
- * Calculates ambisonic coefficients based on azimuth and elevation. The
- * azimuth and elevation parameters are in radians, going right and up
- * respectively.
- */
-inline void CalcAngleCoeffs(const float azimuth, const float elevation, const float spread,
-    const al::span<float,MAX_AMBI_CHANNELS> coeffs)
-{
-    const float x{-std::sin(azimuth) * std::cos(elevation)};
-    const float y{ std::sin(elevation)};
-    const float z{ std::cos(azimuth) * std::cos(elevation)};
-
-    CalcAmbiCoeffs(x, y, z, spread, coeffs);
-}
-
-
-/**
- * ComputePanGains
- *
- * Computes panning gains using the given channel decoder coefficients and the
- * pre-calculated direction or angle coefficients. For B-Format sources, the
- * coeffs are a 'slice' of a transform matrix for the input channel, used to
- * scale and orient the sound samples.
- */
-void ComputePanGains(const MixParams *mix, const float*RESTRICT coeffs, const float ingain,
-    const al::span<float,MAX_OUTPUT_CHANNELS> gains);
-
-
-inline std::array<ALfloat,MAX_AMBI_CHANNELS> GetAmbiIdentityRow(size_t i) noexcept
-{
-    std::array<ALfloat,MAX_AMBI_CHANNELS> ret{};
-    ret[i] = 1.0f;
-    return ret;
-}
-
-
-void aluMixData(ALCdevice *device, ALvoid *OutBuffer, const ALuint NumSamples);
-/* Caller must lock the device state, and the mixer must not be running. */
-void aluHandleDisconnect(ALCdevice *device, const char *msg, ...) DECL_FORMAT(printf, 2, 3);
+void aluInitRenderer(ALCdevice *device, int hrtf_id, al::optional<StereoEncoding> stereomode);
 
-extern const ALfloat ConeScale;
-extern const ALfloat ZScale;
+void aluInitEffectPanning(EffectSlot *slot, ALCcontext *context);
 
 #endif
diff --git a/alc/ambdec.cpp b/alc/ambdec.cpp
deleted file mode 100644
index adf116fe..00000000
--- a/alc/ambdec.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-
-#include "config.h"
-
-#include "ambdec.h"
-
-#include <algorithm>
-#include <cctype>
-#include <cstddef>
-#include <iterator>
-#include <sstream>
-#include <string>
-
-#include "alfstream.h"
-#include "logging.h"
-
-
-namespace {
-
-template<typename T, std::size_t N>
-constexpr inline std::size_t size(const T(&)[N]) noexcept
-{ return N; }
-
-int readline(std::istream &f, std::string &output)
-{
-    while(f.good() && f.peek() == '\n')
-        f.ignore();
-
-    return std::getline(f, output) && !output.empty();
-}
-
-bool read_clipped_line(std::istream &f, std::string &buffer)
-{
-    while(readline(f, buffer))
-    {
-        std::size_t pos{0};
-        while(pos < buffer.length() && std::isspace(buffer[pos]))
-            pos++;
-        buffer.erase(0, pos);
-
-        std::size_t cmtpos{buffer.find_first_of('#')};
-        if(cmtpos < buffer.length())
-            buffer.resize(cmtpos);
-        while(!buffer.empty() && std::isspace(buffer.back()))
-            buffer.pop_back();
-
-        if(!buffer.empty())
-            return true;
-    }
-    return false;
-}
-
-
-std::string read_word(std::istream &f)
-{
-    std::string ret;
-    f >> ret;
-    return ret;
-}
-
-bool is_at_end(const std::string &buffer, std::size_t endpos)
-{
-    while(endpos < buffer.length() && std::isspace(buffer[endpos]))
-        ++endpos;
-    return !(endpos < buffer.length());
-}
-
-
-bool load_ambdec_speakers(al::vector<AmbDecConf::SpeakerConf> &spkrs, const std::size_t num_speakers, std::istream &f, std::string &buffer)
-{
-    while(spkrs.size() < num_speakers)
-    {
-        std::istringstream istr{buffer};
-
-        std::string cmd{read_word(istr)};
-        if(cmd.empty())
-        {
-            if(!read_clipped_line(f, buffer))
-            {
-                ERR("Unexpected end of file\n");
-                return false;
-            }
-            continue;
-        }
-
-        if(cmd == "add_spkr")
-        {
-            spkrs.emplace_back();
-            AmbDecConf::SpeakerConf &spkr = spkrs.back();
-            const size_t spkr_num{spkrs.size()};
-
-            istr >> spkr.Name;
-            if(istr.fail()) WARN("Name not specified for speaker %zu\n", spkr_num);
-            istr >> spkr.Distance;
-            if(istr.fail()) WARN("Distance not specified for speaker %zu\n", spkr_num);
-            istr >> spkr.Azimuth;
-            if(istr.fail()) WARN("Azimuth not specified for speaker %zu\n", spkr_num);
-            istr >> spkr.Elevation;
-            if(istr.fail()) WARN("Elevation not specified for speaker %zu\n", spkr_num);
-            istr >> spkr.Connection;
-            if(istr.fail()) TRACE("Connection not specified for speaker %zu\n", spkr_num);
-        }
-        else
-        {
-            ERR("Unexpected speakers command: %s\n", cmd.c_str());
-            return false;
-        }
-
-        istr.clear();
-        const auto endpos = static_cast<std::size_t>(istr.tellg());
-        if(!is_at_end(buffer, endpos))
-        {
-            ERR("Unexpected junk on line: %s\n", buffer.c_str()+endpos);
-            return false;
-        }
-        buffer.clear();
-    }
-
-    return true;
-}
-
-bool load_ambdec_matrix(float (&gains)[MAX_AMBI_ORDER+1], al::vector<AmbDecConf::CoeffArray> &matrix, const std::size_t maxrow, std::istream &f, std::string &buffer)
-{
-    bool gotgains{false};
-    std::size_t cur{0u};
-    while(cur < maxrow)
-    {
-        std::istringstream istr{buffer};
-
-        std::string cmd{read_word(istr)};
-        if(cmd.empty())
-        {
-            if(!read_clipped_line(f, buffer))
-            {
-                ERR("Unexpected end of file\n");
-                return false;
-            }
-            continue;
-        }
-
-        if(cmd == "order_gain")
-        {
-            std::size_t curgain{0u};
-            float value;
-            while(istr.good())
-            {
-                istr >> value;
-                if(istr.fail()) break;
-                if(!istr.eof() && !std::isspace(istr.peek()))
-                {
-                    ERR("Extra junk on gain %zu: %s\n", curgain+1,
-                        buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                    return false;
-                }
-                if(curgain < size(gains))
-                    gains[curgain++] = value;
-            }
-            std::fill(std::begin(gains)+curgain, std::end(gains), 0.0f);
-            gotgains = true;
-        }
-        else if(cmd == "add_row")
-        {
-            matrix.emplace_back();
-            AmbDecConf::CoeffArray &mtxrow = matrix.back();
-            std::size_t curidx{0u};
-            float value{};
-            while(istr.good())
-            {
-                istr >> value;
-                if(istr.fail()) break;
-                if(!istr.eof() && !std::isspace(istr.peek()))
-                {
-                    ERR("Extra junk on matrix element %zux%zu: %s\n", curidx,
-                        matrix.size(), buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                    matrix.pop_back();
-                    return false;
-                }
-                if(curidx < mtxrow.size())
-                    mtxrow[curidx++] = value;
-            }
-            std::fill(mtxrow.begin()+curidx, mtxrow.end(), 0.0f);
-            cur++;
-        }
-        else
-        {
-            ERR("Unexpected matrix command: %s\n", cmd.c_str());
-            return false;
-        }
-
-        istr.clear();
-        const auto endpos = static_cast<std::size_t>(istr.tellg());
-        if(!is_at_end(buffer, endpos))
-        {
-            ERR("Unexpected junk on line: %s\n", buffer.c_str()+endpos);
-            return false;
-        }
-        buffer.clear();
-    }
-
-    if(!gotgains)
-    {
-        ERR("Matrix order_gain not specified\n");
-        return false;
-    }
-
-    return true;
-}
-
-} // namespace
-
-int AmbDecConf::load(const char *fname) noexcept
-{
-    al::ifstream f{fname};
-    if(!f.is_open())
-    {
-        ERR("Failed to open: %s\n", fname);
-        return 0;
-    }
-
-    std::size_t num_speakers{0u};
-    std::string buffer;
-    while(read_clipped_line(f, buffer))
-    {
-        std::istringstream istr{buffer};
-
-        std::string command{read_word(istr)};
-        if(command.empty())
-        {
-            ERR("Malformed line: %s\n", buffer.c_str());
-            return 0;
-        }
-
-        if(command == "/description")
-            istr >> Description;
-        else if(command == "/version")
-        {
-            istr >> Version;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after version: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-            if(Version != 3)
-            {
-                ERR("Unsupported version: %u\n", Version);
-                return 0;
-            }
-        }
-        else if(command == "/dec/chan_mask")
-        {
-            istr >> std::hex >> ChanMask >> std::dec;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after mask: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-        }
-        else if(command == "/dec/freq_bands")
-        {
-            istr >> FreqBands;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after freq_bands: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-            if(FreqBands != 1 && FreqBands != 2)
-            {
-                ERR("Invalid freq_bands value: %u\n", FreqBands);
-                return 0;
-            }
-        }
-        else if(command == "/dec/speakers")
-        {
-            istr >> num_speakers;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after speakers: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-            Speakers.reserve(num_speakers);
-            LFMatrix.reserve(num_speakers);
-            HFMatrix.reserve(num_speakers);
-        }
-        else if(command == "/dec/coeff_scale")
-        {
-            std::string scale = read_word(istr);
-            if(scale == "n3d") CoeffScale = AmbDecScale::N3D;
-            else if(scale == "sn3d") CoeffScale = AmbDecScale::SN3D;
-            else if(scale == "fuma") CoeffScale = AmbDecScale::FuMa;
-            else
-            {
-                ERR("Unsupported coeff scale: %s\n", scale.c_str());
-                return 0;
-            }
-        }
-        else if(command == "/opt/xover_freq")
-        {
-            istr >> XOverFreq;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after xover_freq: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-        }
-        else if(command == "/opt/xover_ratio")
-        {
-            istr >> XOverRatio;
-            if(!istr.eof() && !std::isspace(istr.peek()))
-            {
-                ERR("Extra junk after xover_ratio: %s\n",
-                    buffer.c_str()+static_cast<std::size_t>(istr.tellg()));
-                return 0;
-            }
-        }
-        else if(command == "/opt/input_scale" || command == "/opt/nfeff_comp" ||
-                command == "/opt/delay_comp" || command == "/opt/level_comp")
-        {
-            /* Unused */
-            read_word(istr);
-        }
-        else if(command == "/speakers/{")
-        {
-            const auto endpos = static_cast<std::size_t>(istr.tellg());
-            if(!is_at_end(buffer, endpos))
-            {
-                ERR("Unexpected junk on line: %s\n", buffer.c_str()+endpos);
-                return 0;
-            }
-            buffer.clear();
-
-            if(!load_ambdec_speakers(Speakers, num_speakers, f, buffer))
-                return 0;
-
-            if(!read_clipped_line(f, buffer))
-            {
-                ERR("Unexpected end of file\n");
-                return 0;
-            }
-            std::istringstream istr2{buffer};
-            std::string endmark{read_word(istr2)};
-            if(endmark != "/}")
-            {
-                ERR("Expected /} after speaker definitions, got %s\n", endmark.c_str());
-                return 0;
-            }
-            istr.swap(istr2);
-        }
-        else if(command == "/lfmatrix/{" || command == "/hfmatrix/{" || command == "/matrix/{")
-        {
-            const auto endpos = static_cast<std::size_t>(istr.tellg());
-            if(!is_at_end(buffer, endpos))
-            {
-                ERR("Unexpected junk on line: %s\n", buffer.c_str()+endpos);
-                return 0;
-            }
-            buffer.clear();
-
-            if(FreqBands == 1)
-            {
-                if(command != "/matrix/{")
-                {
-                    ERR("Unexpected \"%s\" type for a single-band decoder\n", command.c_str());
-                    return 0;
-                }
-                if(!load_ambdec_matrix(HFOrderGain, HFMatrix, num_speakers, f, buffer))
-                    return 0;
-            }
-            else
-            {
-                if(command == "/lfmatrix/{")
-                {
-                    if(!load_ambdec_matrix(LFOrderGain, LFMatrix, num_speakers, f, buffer))
-                        return 0;
-                }
-                else if(command == "/hfmatrix/{")
-                {
-                    if(!load_ambdec_matrix(HFOrderGain, HFMatrix, num_speakers, f, buffer))
-                        return 0;
-                }
-                else
-                {
-                    ERR("Unexpected \"%s\" type for a dual-band decoder\n", command.c_str());
-                    return 0;
-                }
-            }
-
-            if(!read_clipped_line(f, buffer))
-            {
-                ERR("Unexpected end of file\n");
-                return 0;
-            }
-            std::istringstream istr2{buffer};
-            std::string endmark{read_word(istr2)};
-            if(endmark != "/}")
-            {
-                ERR("Expected /} after matrix definitions, got %s\n", endmark.c_str());
-                return 0;
-            }
-            istr.swap(istr2);
-        }
-        else if(command == "/end")
-        {
-            const auto endpos = static_cast<std::size_t>(istr.tellg());
-            if(!is_at_end(buffer, endpos))
-            {
-                ERR("Unexpected junk on end: %s\n", buffer.c_str()+endpos);
-                return 0;
-            }
-
-            return 1;
-        }
-        else
-        {
-            ERR("Unexpected command: %s\n", command.c_str());
-            return 0;
-        }
-
-        istr.clear();
-        const auto endpos = static_cast<std::size_t>(istr.tellg());
-        if(!is_at_end(buffer, endpos))
-        {
-            ERR("Unexpected junk on line: %s\n", buffer.c_str()+endpos);
-            return 0;
-        }
-        buffer.clear();
-    }
-    ERR("Unexpected end of file\n");
-
-    return 0;
-}
diff --git a/alc/ambidefs.h b/alc/ambidefs.h
deleted file mode 100644
index 9bc3e969..00000000
--- a/alc/ambidefs.h
+++ /dev/null
@@ -1,120 +0,0 @@
-#ifndef AMBIDEFS_H
-#define AMBIDEFS_H
-
-#include <array>
-#include <cstdint>
-
-/* The maximum number of Ambisonics channels. For a given order (o), the size
- * needed will be (o+1)**2, thus zero-order has 1, first-order has 4, second-
- * order has 9, third-order has 16, and fourth-order has 25.
- */
-#define MAX_AMBI_ORDER 3
-constexpr inline size_t AmbiChannelsFromOrder(size_t order) noexcept
-{ return (order+1) * (order+1); }
-#define MAX_AMBI_CHANNELS AmbiChannelsFromOrder(MAX_AMBI_ORDER)
-
-/* A bitmask of ambisonic channels for 0 to 4th order. This only specifies up
- * to 4th order, which is the highest order a 32-bit mask value can specify (a
- * 64-bit mask could handle up to 7th order).
- */
-#define AMBI_0ORDER_MASK 0x00000001
-#define AMBI_1ORDER_MASK 0x0000000f
-#define AMBI_2ORDER_MASK 0x000001ff
-#define AMBI_3ORDER_MASK 0x0000ffff
-#define AMBI_4ORDER_MASK 0x01ffffff
-
-/* A bitmask of ambisonic channels with height information. If none of these
- * channels are used/needed, there's no height (e.g. with most surround sound
- * speaker setups). This is ACN ordering, with bit 0 being ACN 0, etc.
- */
-#define AMBI_PERIPHONIC_MASK (0xfe7ce4)
-
-/* The maximum number of ambisonic channels for 2D (non-periphonic)
- * representation. This is 2 per each order above zero-order, plus 1 for zero-
- * order. Or simply, o*2 + 1.
- */
-constexpr inline size_t Ambi2DChannelsFromOrder(size_t order) noexcept
-{ return order*2 + 1; }
-#define MAX_AMBI2D_CHANNELS Ambi2DChannelsFromOrder(MAX_AMBI_ORDER)
-
-
-/* NOTE: These are scale factors as applied to Ambisonics content. Decoder
- * coefficients should be divided by these values to get proper scalings.
- */
-struct AmbiScale {
-    static constexpr std::array<float,MAX_AMBI_CHANNELS> FromN3D{{
-        1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-        1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
-    }};
-    static constexpr std::array<float,MAX_AMBI_CHANNELS> FromSN3D{{
-        1.000000000f, /* ACN  0, sqrt(1) */
-        1.732050808f, /* ACN  1, sqrt(3) */
-        1.732050808f, /* ACN  2, sqrt(3) */
-        1.732050808f, /* ACN  3, sqrt(3) */
-        2.236067978f, /* ACN  4, sqrt(5) */
-        2.236067978f, /* ACN  5, sqrt(5) */
-        2.236067978f, /* ACN  6, sqrt(5) */
-        2.236067978f, /* ACN  7, sqrt(5) */
-        2.236067978f, /* ACN  8, sqrt(5) */
-        2.645751311f, /* ACN  9, sqrt(7) */
-        2.645751311f, /* ACN 10, sqrt(7) */
-        2.645751311f, /* ACN 11, sqrt(7) */
-        2.645751311f, /* ACN 12, sqrt(7) */
-        2.645751311f, /* ACN 13, sqrt(7) */
-        2.645751311f, /* ACN 14, sqrt(7) */
-        2.645751311f, /* ACN 15, sqrt(7) */
-    }};
-    static constexpr std::array<float,MAX_AMBI_CHANNELS> FromFuMa{{
-        1.414213562f, /* ACN  0 (W), sqrt(2) */
-        1.732050808f, /* ACN  1 (Y), sqrt(3) */
-        1.732050808f, /* ACN  2 (Z), sqrt(3) */
-        1.732050808f, /* ACN  3 (X), sqrt(3) */
-        1.936491673f, /* ACN  4 (V), sqrt(15)/2 */
-        1.936491673f, /* ACN  5 (T), sqrt(15)/2 */
-        2.236067978f, /* ACN  6 (R), sqrt(5) */
-        1.936491673f, /* ACN  7 (S), sqrt(15)/2 */
-        1.936491673f, /* ACN  8 (U), sqrt(15)/2 */
-        2.091650066f, /* ACN  9 (Q), sqrt(35/8) */
-        1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
-        2.231093404f, /* ACN 11 (M), sqrt(224/45) */
-        2.645751311f, /* ACN 12 (K), sqrt(7) */
-        2.231093404f, /* ACN 13 (L), sqrt(224/45) */
-        1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
-        2.091650066f, /* ACN 15 (P), sqrt(35/8) */
-    }};
-};
-
-struct AmbiIndex {
-    static constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> FromFuMa{{
-        0,  /* W */
-        3,  /* X */
-        1,  /* Y */
-        2,  /* Z */
-        6,  /* R */
-        7,  /* S */
-        5,  /* T */
-        8,  /* U */
-        4,  /* V */
-        12, /* K */
-        13, /* L */
-        11, /* M */
-        14, /* N */
-        10, /* O */
-        15, /* P */
-        9,  /* Q */
-    }};
-    static constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> FromACN{{
-        0,  1,  2,  3,  4,  5,  6,  7,
-        8,  9, 10, 11, 12, 13, 14, 15
-    }};
-
-    static constexpr std::array<uint8_t,MAX_AMBI2D_CHANNELS> From2D{{
-        0, 1,3, 4,8, 9,15
-    }};
-    static constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> From3D{{
-        0,  1,  2,  3,  4,  5,  6,  7,
-        8,  9, 10, 11, 12, 13, 14, 15
-    }};
-};
-
-#endif /* AMBIDEFS_H */
diff --git a/alc/backends/alsa.cpp b/alc/backends/alsa.cpp
index 7dc3c3c4..d620a83c 100644
--- a/alc/backends/alsa.cpp
+++ b/alc/backends/alsa.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/alsa.h"
+#include "alsa.h"
 
 #include <algorithm>
 #include <atomic>
@@ -35,18 +35,15 @@
 #include <thread>
 #include <utility>
 
-#include "AL/al.h"
-
 #include "albyte.h"
-#include "alcmain.h"
-#include "alconfig.h"
-#include "alexcpt.h"
+#include "alc/alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "aloptional.h"
-#include "alu.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "dynload.h"
-#include "logging.h"
 #include "ringbuffer.h"
 #include "threads.h"
 #include "vector.h"
@@ -56,7 +53,7 @@
 
 namespace {
 
-constexpr ALCchar alsaDevice[] = "ALSA Default";
+constexpr char alsaDevice[] = "ALSA Default";
 
 
 #ifdef HAVE_DYNLOAD
@@ -71,35 +68,37 @@ constexpr ALCchar alsaDevice[] = "ALSA Default";
     MAGIC(snd_pcm_hw_params_free);                                            \
     MAGIC(snd_pcm_hw_params_any);                                             \
     MAGIC(snd_pcm_hw_params_current);                                         \
+    MAGIC(snd_pcm_hw_params_get_access);                                      \
+    MAGIC(snd_pcm_hw_params_get_buffer_size);                                 \
+    MAGIC(snd_pcm_hw_params_get_buffer_time_min);                             \
+    MAGIC(snd_pcm_hw_params_get_buffer_time_max);                             \
+    MAGIC(snd_pcm_hw_params_get_channels);                                    \
+    MAGIC(snd_pcm_hw_params_get_period_size);                                 \
+    MAGIC(snd_pcm_hw_params_get_period_time_max);                             \
+    MAGIC(snd_pcm_hw_params_get_period_time_min);                             \
+    MAGIC(snd_pcm_hw_params_get_periods);                                     \
     MAGIC(snd_pcm_hw_params_set_access);                                      \
-    MAGIC(snd_pcm_hw_params_set_format);                                      \
+    MAGIC(snd_pcm_hw_params_set_buffer_size_min);                             \
+    MAGIC(snd_pcm_hw_params_set_buffer_size_near);                            \
+    MAGIC(snd_pcm_hw_params_set_buffer_time_near);                            \
     MAGIC(snd_pcm_hw_params_set_channels);                                    \
+    MAGIC(snd_pcm_hw_params_set_channels_near);                               \
+    MAGIC(snd_pcm_hw_params_set_format);                                      \
+    MAGIC(snd_pcm_hw_params_set_period_time_near);                            \
+    MAGIC(snd_pcm_hw_params_set_period_size_near);                            \
     MAGIC(snd_pcm_hw_params_set_periods_near);                                \
     MAGIC(snd_pcm_hw_params_set_rate_near);                                   \
     MAGIC(snd_pcm_hw_params_set_rate);                                        \
     MAGIC(snd_pcm_hw_params_set_rate_resample);                               \
-    MAGIC(snd_pcm_hw_params_set_buffer_time_near);                            \
-    MAGIC(snd_pcm_hw_params_set_period_time_near);                            \
-    MAGIC(snd_pcm_hw_params_set_buffer_size_near);                            \
-    MAGIC(snd_pcm_hw_params_set_period_size_near);                            \
-    MAGIC(snd_pcm_hw_params_set_buffer_size_min);                             \
-    MAGIC(snd_pcm_hw_params_get_buffer_time_min);                             \
-    MAGIC(snd_pcm_hw_params_get_buffer_time_max);                             \
-    MAGIC(snd_pcm_hw_params_get_period_time_min);                             \
-    MAGIC(snd_pcm_hw_params_get_period_time_max);                             \
-    MAGIC(snd_pcm_hw_params_get_buffer_size);                                 \
-    MAGIC(snd_pcm_hw_params_get_period_size);                                 \
-    MAGIC(snd_pcm_hw_params_get_access);                                      \
-    MAGIC(snd_pcm_hw_params_get_periods);                                     \
     MAGIC(snd_pcm_hw_params_test_format);                                     \
     MAGIC(snd_pcm_hw_params_test_channels);                                   \
     MAGIC(snd_pcm_hw_params);                                                 \
-    MAGIC(snd_pcm_sw_params_malloc);                                          \
+    MAGIC(snd_pcm_sw_params);                                                 \
     MAGIC(snd_pcm_sw_params_current);                                         \
+    MAGIC(snd_pcm_sw_params_free);                                            \
+    MAGIC(snd_pcm_sw_params_malloc);                                          \
     MAGIC(snd_pcm_sw_params_set_avail_min);                                   \
     MAGIC(snd_pcm_sw_params_set_stop_threshold);                              \
-    MAGIC(snd_pcm_sw_params);                                                 \
-    MAGIC(snd_pcm_sw_params_free);                                            \
     MAGIC(snd_pcm_prepare);                                                   \
     MAGIC(snd_pcm_start);                                                     \
     MAGIC(snd_pcm_resume);                                                    \
@@ -108,7 +107,6 @@ constexpr ALCchar alsaDevice[] = "ALSA Default";
     MAGIC(snd_pcm_delay);                                                     \
     MAGIC(snd_pcm_state);                                                     \
     MAGIC(snd_pcm_avail_update);                                              \
-    MAGIC(snd_pcm_areas_silence);                                             \
     MAGIC(snd_pcm_mmap_begin);                                                \
     MAGIC(snd_pcm_mmap_commit);                                               \
     MAGIC(snd_pcm_readi);                                                     \
@@ -134,7 +132,7 @@ constexpr ALCchar alsaDevice[] = "ALSA Default";
     MAGIC(snd_card_next);                                                     \
     MAGIC(snd_config_update_free_global)
 
-static void *alsa_handle;
+void *alsa_handle;
 #define MAKE_FUNC(f) decltype(f) * p##f
 ALSA_FUNCS(MAKE_FUNC);
 #undef MAKE_FUNC
@@ -153,6 +151,7 @@ ALSA_FUNCS(MAKE_FUNC);
 #define snd_pcm_hw_params_set_access psnd_pcm_hw_params_set_access
 #define snd_pcm_hw_params_set_format psnd_pcm_hw_params_set_format
 #define snd_pcm_hw_params_set_channels psnd_pcm_hw_params_set_channels
+#define snd_pcm_hw_params_set_channels_near psnd_pcm_hw_params_set_channels_near
 #define snd_pcm_hw_params_set_periods_near psnd_pcm_hw_params_set_periods_near
 #define snd_pcm_hw_params_set_rate_near psnd_pcm_hw_params_set_rate_near
 #define snd_pcm_hw_params_set_rate psnd_pcm_hw_params_set_rate
@@ -170,6 +169,7 @@ ALSA_FUNCS(MAKE_FUNC);
 #define snd_pcm_hw_params_get_period_size psnd_pcm_hw_params_get_period_size
 #define snd_pcm_hw_params_get_access psnd_pcm_hw_params_get_access
 #define snd_pcm_hw_params_get_periods psnd_pcm_hw_params_get_periods
+#define snd_pcm_hw_params_get_channels psnd_pcm_hw_params_get_channels
 #define snd_pcm_hw_params_test_format psnd_pcm_hw_params_test_format
 #define snd_pcm_hw_params_test_channels psnd_pcm_hw_params_test_channels
 #define snd_pcm_hw_params psnd_pcm_hw_params
@@ -187,7 +187,6 @@ ALSA_FUNCS(MAKE_FUNC);
 #define snd_pcm_delay psnd_pcm_delay
 #define snd_pcm_state psnd_pcm_state
 #define snd_pcm_avail_update psnd_pcm_avail_update
-#define snd_pcm_areas_silence psnd_pcm_areas_silence
 #define snd_pcm_mmap_begin psnd_pcm_mmap_begin
 #define snd_pcm_mmap_commit psnd_pcm_mmap_commit
 #define snd_pcm_readi psnd_pcm_readi
@@ -242,6 +241,11 @@ SwParamsPtr CreateSwParams()
 struct DevMap {
     std::string name;
     std::string device_name;
+
+    template<typename T, typename U>
+    DevMap(T&& name_, U&& devname)
+        : name{std::forward<T>(name_)}, device_name{std::forward<U>(devname)}
+    { }
 };
 
 al::vector<DevMap> PlaybackDevices;
@@ -263,29 +267,36 @@ al::vector<DevMap> probe_devices(snd_pcm_stream_t stream)
     snd_pcm_info_t *pcminfo;
     snd_pcm_info_malloc(&pcminfo);
 
-    devlist.emplace_back(DevMap{alsaDevice,
-        GetConfigValue(nullptr, "alsa", (stream==SND_PCM_STREAM_PLAYBACK) ? "device" : "capture",
-            "default")});
+    auto defname = ConfigValueStr(nullptr, "alsa",
+        (stream == SND_PCM_STREAM_PLAYBACK) ? "device" : "capture");
+    devlist.emplace_back(alsaDevice, defname ? defname->c_str() : "default");
 
-    const char *customdevs{GetConfigValue(nullptr, "alsa",
-        (stream == SND_PCM_STREAM_PLAYBACK) ? "custom-devices" : "custom-captures", "")};
-    while(const char *curdev{customdevs})
+    if(auto customdevs = ConfigValueStr(nullptr, "alsa",
+        (stream == SND_PCM_STREAM_PLAYBACK) ? "custom-devices" : "custom-captures"))
     {
-        if(!curdev[0]) break;
-        customdevs = strchr(curdev, ';');
-        const char *sep{strchr(curdev, '=')};
-        if(!sep)
+        size_t nextpos{customdevs->find_first_not_of(';')};
+        size_t curpos;
+        while((curpos=nextpos) < customdevs->length())
         {
-            std::string spec{customdevs ? std::string(curdev, customdevs++) : std::string(curdev)};
-            ERR("Invalid ALSA device specification \"%s\"\n", spec.c_str());
-            continue;
-        }
+            nextpos = customdevs->find_first_of(';', curpos+1);
 
-        const char *oldsep{sep++};
-        devlist.emplace_back(DevMap{std::string(curdev, oldsep),
-            customdevs ? std::string(sep, customdevs++) : std::string(sep)});
-        const auto &entry = devlist.back();
-        TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
+            size_t seppos{customdevs->find_first_of('=', curpos)};
+            if(seppos == curpos || seppos >= nextpos)
+            {
+                std::string spec{customdevs->substr(curpos, nextpos-curpos)};
+                ERR("Invalid ALSA device specification \"%s\"\n", spec.c_str());
+            }
+            else
+            {
+                devlist.emplace_back(customdevs->substr(curpos, seppos-curpos),
+                    customdevs->substr(seppos+1, nextpos-seppos-1));
+                const auto &entry = devlist.back();
+                TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
+            }
+
+            if(nextpos < customdevs->length())
+                nextpos = customdevs->find_first_not_of(';', nextpos+1);
+        }
     }
 
     const std::string main_prefix{
@@ -319,13 +330,13 @@ al::vector<DevMap> probe_devices(snd_pcm_stream_t stream)
             ConfigValueStr(nullptr, "alsa", name.c_str()).value_or(main_prefix)};
 
         int dev{-1};
-        while(1)
+        while(true)
         {
             if(snd_ctl_pcm_next_device(handle, &dev) < 0)
                 ERR("snd_ctl_pcm_next_device failed\n");
             if(dev < 0) break;
 
-            snd_pcm_info_set_device(pcminfo, static_cast<ALuint>(dev));
+            snd_pcm_info_set_device(pcminfo, static_cast<uint>(dev));
             snd_pcm_info_set_subdevice(pcminfo, 0);
             snd_pcm_info_set_stream(pcminfo, stream);
             if((err=snd_ctl_pcm_info(handle, pcminfo)) < 0)
@@ -361,7 +372,7 @@ al::vector<DevMap> probe_devices(snd_pcm_stream_t stream)
             device += ",DEV=";
             device += std::to_string(dev);
             
-            devlist.emplace_back(DevMap{std::move(name), std::move(device)});
+            devlist.emplace_back(std::move(name), std::move(device));
             const auto &entry = devlist.back();
             TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
         }
@@ -410,21 +421,24 @@ int verify_state(snd_pcm_t *handle)
 
 
 struct AlsaPlayback final : public BackendBase {
-    AlsaPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    AlsaPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~AlsaPlayback() override;
 
     int mixerProc();
     int mixerNoMMapProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     ClockLatency getClockLatency() override;
 
     snd_pcm_t *mPcmHandle{nullptr};
 
+    std::mutex mMutex;
+
+    uint mFrameStep{};
     al::vector<al::byte> mBuffer;
 
     std::atomic<bool> mKillNow{true};
@@ -454,7 +468,7 @@ int AlsaPlayback::mixerProc()
         if(state < 0)
         {
             ERR("Invalid state detected: %s\n", snd_strerror(state));
-            aluHandleDisconnect(mDevice, "Bad state: %s", snd_strerror(state));
+            mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
             break;
         }
 
@@ -492,7 +506,7 @@ int AlsaPlayback::mixerProc()
         avail -= avail%update_size;
 
         // it is possible that contiguous areas are smaller, thus we use a loop
-        std::lock_guard<AlsaPlayback> _{*this};
+        std::lock_guard<std::mutex> _{mMutex};
         while(avail > 0)
         {
             snd_pcm_uframes_t frames{avail};
@@ -507,10 +521,10 @@ int AlsaPlayback::mixerProc()
             }
 
             char *WritePtr{static_cast<char*>(areas->addr) + (offset * areas->step / 8)};
-            aluMixData(mDevice, WritePtr, static_cast<ALuint>(frames));
+            mDevice->renderSamples(WritePtr, static_cast<uint>(frames), mFrameStep);
 
             snd_pcm_sframes_t commitres{snd_pcm_mmap_commit(mPcmHandle, offset, frames)};
-            if(commitres < 0 || (static_cast<snd_pcm_uframes_t>(commitres)-frames) != 0)
+            if(commitres < 0 || static_cast<snd_pcm_uframes_t>(commitres) != frames)
             {
                 ERR("mmap commit error: %s\n",
                     snd_strerror(commitres >= 0 ? -EPIPE : static_cast<int>(commitres)));
@@ -537,7 +551,7 @@ int AlsaPlayback::mixerNoMMapProc()
         if(state < 0)
         {
             ERR("Invalid state detected: %s\n", snd_strerror(state));
-            aluHandleDisconnect(mDevice, "Bad state: %s", snd_strerror(state));
+            mDevice->handleDisconnect("Bad state: %s", snd_strerror(state));
             break;
         }
 
@@ -571,10 +585,10 @@ int AlsaPlayback::mixerNoMMapProc()
             continue;
         }
 
-        std::lock_guard<AlsaPlayback> _{*this};
         al::byte *WritePtr{mBuffer.data()};
         avail = snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
-        aluMixData(mDevice, WritePtr, static_cast<ALuint>(avail));
+        std::lock_guard<std::mutex> _{mMutex};
+        mDevice->renderSamples(WritePtr, static_cast<uint>(avail), mFrameStep);
         while(avail > 0)
         {
             snd_pcm_sframes_t ret{snd_pcm_writei(mPcmHandle, WritePtr,
@@ -612,33 +626,37 @@ int AlsaPlayback::mixerNoMMapProc()
 }
 
 
-void AlsaPlayback::open(const ALCchar *name)
+void AlsaPlayback::open(const char *name)
 {
-    const char *driver{};
+    std::string driver{"default"};
     if(name)
     {
         if(PlaybackDevices.empty())
             PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
 
         auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == PlaybackDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
-        driver = iter->device_name.c_str();
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
+        driver = iter->device_name;
     }
     else
     {
         name = alsaDevice;
-        driver = GetConfigValue(nullptr, "alsa", "device", "default");
+        if(auto driveropt = ConfigValueStr(nullptr, "alsa", "device"))
+            driver = std::move(driveropt).value();
     }
+    TRACE("Opening device \"%s\"\n", driver.c_str());
 
-    TRACE("Opening device \"%s\"\n", driver);
-    int err{snd_pcm_open(&mPcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)};
+    snd_pcm_t *pcmHandle{};
+    int err{snd_pcm_open(&pcmHandle, driver.c_str(), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)};
     if(err < 0)
-        throw al::backend_exception{ALC_OUT_OF_MEMORY, "Could not open ALSA device \"%s\"",
-            driver};
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Could not open ALSA device \"%s\"", driver.c_str()};
+    if(mPcmHandle)
+        snd_pcm_close(mPcmHandle);
+    mPcmHandle = pcmHandle;
 
     /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
     snd_config_update_free_global();
@@ -674,16 +692,17 @@ bool AlsaPlayback::reset()
         break;
     }
 
-    bool allowmmap{!!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "mmap", 1)};
-    ALuint periodLen{static_cast<ALuint>(mDevice->UpdateSize * 1000000_u64 / mDevice->Frequency)};
-    ALuint bufferLen{static_cast<ALuint>(mDevice->BufferSize * 1000000_u64 / mDevice->Frequency)};
-    ALuint rate{mDevice->Frequency};
+    bool allowmmap{!!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "mmap", true)};
+    uint periodLen{static_cast<uint>(mDevice->UpdateSize * 1000000_u64 / mDevice->Frequency)};
+    uint bufferLen{static_cast<uint>(mDevice->BufferSize * 1000000_u64 / mDevice->Frequency)};
+    uint rate{mDevice->Frequency};
 
     int err{};
     HwParamsPtr hp{CreateHwParams()};
 #define CHECK(x) do {                                                         \
     if((err=(x)) < 0)                                                         \
-        throw al::backend_exception{ALC_INVALID_VALUE, #x " failed: %s", snd_strerror(err)}; \
+        throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
+            snd_strerror(err)};                                               \
 } while(0)
     CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
     /* set interleaved access */
@@ -720,37 +739,25 @@ bool AlsaPlayback::reset()
         }
     }
     CHECK(snd_pcm_hw_params_set_format(mPcmHandle, hp.get(), format));
-    /* test and set channels (implicitly sets frame bits) */
-    if(snd_pcm_hw_params_test_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()) < 0)
+    /* set channels (implicitly sets frame bits) */
+    if(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()) < 0)
     {
-        static const DevFmtChannels channellist[] = {
-            DevFmtStereo,
-            DevFmtQuad,
-            DevFmtX51,
-            DevFmtX71,
-            DevFmtMono,
-        };
-
-        for(const auto &chan : channellist)
-        {
-            if(snd_pcm_hw_params_test_channels(mPcmHandle, hp.get(), ChannelsFromDevFmt(chan, 0)) >= 0)
-            {
-                mDevice->FmtChans = chan;
-                mDevice->mAmbiOrder = 0;
-                break;
-            }
-        }
+        uint numchans{2u};
+        CHECK(snd_pcm_hw_params_set_channels_near(mPcmHandle, hp.get(), &numchans));
+        if(numchans < 1)
+            throw al::backend_exception{al::backend_error::DeviceError, "Got 0 device channels"};
+        if(numchans == 1) mDevice->FmtChans = DevFmtMono;
+        else mDevice->FmtChans = DevFmtStereo;
     }
-    CHECK(snd_pcm_hw_params_set_channels(mPcmHandle, hp.get(), mDevice->channelsFromFmt()));
     /* set rate (implicitly constrains period/buffer parameters) */
-    if(!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "allow-resampler", 0) ||
-       !mDevice->Flags.get<FrequencyRequest>())
+    if(!GetConfigValueBool(mDevice->DeviceName.c_str(), "alsa", "allow-resampler", false)
+        || !mDevice->Flags.test(FrequencyRequest))
     {
         if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 0) < 0)
-            ERR("Failed to disable ALSA resampler\n");
+            WARN("Failed to disable ALSA resampler\n");
     }
     else if(snd_pcm_hw_params_set_rate_resample(mPcmHandle, hp.get(), 1) < 0)
-        ERR("Failed to enable ALSA resampler\n");
+        WARN("Failed to enable ALSA resampler\n");
     CHECK(snd_pcm_hw_params_set_rate_near(mPcmHandle, hp.get(), &rate, nullptr));
     /* set period time (implicitly constrains period/buffer parameters) */
     if((err=snd_pcm_hw_params_set_period_time_near(mPcmHandle, hp.get(), &periodLen, nullptr)) < 0)
@@ -769,6 +776,7 @@ bool AlsaPlayback::reset()
     CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
     CHECK(snd_pcm_hw_params_get_period_size(hp.get(), &periodSizeInFrames, nullptr));
     CHECK(snd_pcm_hw_params_get_buffer_size(hp.get(), &bufferSizeInFrames));
+    CHECK(snd_pcm_hw_params_get_channels(hp.get(), &mFrameStep));
     hp = nullptr;
 
     SwParamsPtr sp{CreateSwParams()};
@@ -779,58 +787,52 @@ bool AlsaPlayback::reset()
 #undef CHECK
     sp = nullptr;
 
-    mDevice->BufferSize = static_cast<ALuint>(bufferSizeInFrames);
-    mDevice->UpdateSize = static_cast<ALuint>(periodSizeInFrames);
+    mDevice->BufferSize = static_cast<uint>(bufferSizeInFrames);
+    mDevice->UpdateSize = static_cast<uint>(periodSizeInFrames);
     mDevice->Frequency = rate;
 
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     return true;
 }
 
-bool AlsaPlayback::start()
+void AlsaPlayback::start()
 {
     int err{};
     snd_pcm_access_t access{};
     HwParamsPtr hp{CreateHwParams()};
 #define CHECK(x) do {                                                         \
     if((err=(x)) < 0)                                                         \
-        throw al::backend_exception{ALC_INVALID_VALUE, #x " failed: %s", snd_strerror(err)}; \
+        throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
+            snd_strerror(err)};                                               \
 } while(0)
     CHECK(snd_pcm_hw_params_current(mPcmHandle, hp.get()));
     /* retrieve configuration info */
     CHECK(snd_pcm_hw_params_get_access(hp.get(), &access));
-#undef CHECK
     hp = nullptr;
 
     int (AlsaPlayback::*thread_func)(){};
     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
     {
-        mBuffer.resize(
-            static_cast<size_t>(snd_pcm_frames_to_bytes(mPcmHandle, mDevice->UpdateSize)));
+        auto datalen = snd_pcm_frames_to_bytes(mPcmHandle, mDevice->UpdateSize);
+        mBuffer.resize(static_cast<size_t>(datalen));
         thread_func = &AlsaPlayback::mixerNoMMapProc;
     }
     else
     {
-        err = snd_pcm_prepare(mPcmHandle);
-        if(err < 0)
-        {
-            ERR("snd_pcm_prepare(data->mPcmHandle) failed: %s\n", snd_strerror(err));
-            return false;
-        }
+        CHECK(snd_pcm_prepare(mPcmHandle));
         thread_func = &AlsaPlayback::mixerProc;
     }
+#undef CHECK
 
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(thread_func), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    mBuffer.clear();
-    return false;
 }
 
 void AlsaPlayback::stop()
@@ -840,13 +842,16 @@ void AlsaPlayback::stop()
     mThread.join();
 
     mBuffer.clear();
+    int err{snd_pcm_drop(mPcmHandle)};
+    if(err < 0)
+        ERR("snd_pcm_drop failed: %s\n", snd_strerror(err));
 }
 
 ClockLatency AlsaPlayback::getClockLatency()
 {
     ClockLatency ret;
 
-    std::lock_guard<AlsaPlayback> _{*this};
+    std::lock_guard<std::mutex> _{mMutex};
     ret.ClockTime = GetDeviceClockTime(mDevice);
     snd_pcm_sframes_t delay{};
     int err{snd_pcm_delay(mPcmHandle, &delay)};
@@ -863,14 +868,14 @@ ClockLatency AlsaPlayback::getClockLatency()
 
 
 struct AlsaCapture final : public BackendBase {
-    AlsaCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    AlsaCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~AlsaCapture() override;
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
     ClockLatency getClockLatency() override;
 
     snd_pcm_t *mPcmHandle{nullptr};
@@ -893,33 +898,33 @@ AlsaCapture::~AlsaCapture()
 }
 
 
-void AlsaCapture::open(const ALCchar *name)
+void AlsaCapture::open(const char *name)
 {
-    const char *driver{};
+    std::string driver{"default"};
     if(name)
     {
         if(CaptureDevices.empty())
             CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
 
         auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == CaptureDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
-        driver = iter->device_name.c_str();
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
+        driver = iter->device_name;
     }
     else
     {
         name = alsaDevice;
-        driver = GetConfigValue(nullptr, "alsa", "capture", "default");
+        if(auto driveropt = ConfigValueStr(nullptr, "alsa", "capture"))
+            driver = std::move(driveropt).value();
     }
 
-    TRACE("Opening device \"%s\"\n", driver);
-    int err{snd_pcm_open(&mPcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)};
+    TRACE("Opening device \"%s\"\n", driver.c_str());
+    int err{snd_pcm_open(&mPcmHandle, driver.c_str(), SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)};
     if(err < 0)
-        throw al::backend_exception{ALC_OUT_OF_MEMORY, "Could not open ALSA device \"%s\"",
-            driver};
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Could not open ALSA device \"%s\"", driver.c_str()};
 
     /* Free alsa's global config tree. Otherwise valgrind reports a ton of leaks. */
     snd_config_update_free_global();
@@ -957,7 +962,8 @@ void AlsaCapture::open(const ALCchar *name)
     HwParamsPtr hp{CreateHwParams()};
 #define CHECK(x) do {                                                         \
     if((err=(x)) < 0)                                                         \
-        throw al::backend_exception{ALC_INVALID_VALUE, #x " failed: %s", snd_strerror(err)}; \
+        throw al::backend_exception{al::backend_error::DeviceError, #x " failed: %s", \
+            snd_strerror(err)};                                               \
 } while(0)
     CHECK(snd_pcm_hw_params_any(mPcmHandle, hp.get()));
     /* set interleaved access */
@@ -985,26 +991,25 @@ void AlsaCapture::open(const ALCchar *name)
     hp = nullptr;
 
     if(needring)
-        mRing = CreateRingBuffer(mDevice->BufferSize, mDevice->frameSizeFromFmt(), false);
+        mRing = RingBuffer::Create(mDevice->BufferSize, mDevice->frameSizeFromFmt(), false);
 
     mDevice->DeviceName = name;
 }
 
 
-bool AlsaCapture::start()
+void AlsaCapture::start()
 {
     int err{snd_pcm_prepare(mPcmHandle)};
     if(err < 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "snd_pcm_prepare failed: %s",
+        throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_prepare failed: %s",
             snd_strerror(err)};
 
     err = snd_pcm_start(mPcmHandle);
     if(err < 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "snd_pcm_start failed: %s",
+        throw al::backend_exception{al::backend_error::DeviceError, "snd_pcm_start failed: %s",
             snd_strerror(err)};
 
     mDoCapture = true;
-    return true;
 }
 
 void AlsaCapture::stop()
@@ -1013,11 +1018,12 @@ void AlsaCapture::stop()
      * snd_pcm_drain is unreliable and snd_pcm_drop drops it. Capture what's
      * available now so it'll be available later after the drop.
      */
-    ALCuint avail{availableSamples()};
+    uint avail{availableSamples()};
     if(!mRing && avail > 0)
     {
         /* The ring buffer implicitly captures when checking availability.
-         * Direct access needs to explicitly capture it into temp storage. */
+         * Direct access needs to explicitly capture it into temp storage.
+         */
         auto temp = al::vector<al::byte>(
             static_cast<size_t>(snd_pcm_frames_to_bytes(mPcmHandle, avail)));
         captureSamples(temp.data(), avail);
@@ -1029,12 +1035,12 @@ void AlsaCapture::stop()
     mDoCapture = false;
 }
 
-ALCenum AlsaCapture::captureSamples(al::byte *buffer, ALCuint samples)
+void AlsaCapture::captureSamples(al::byte *buffer, uint samples)
 {
     if(mRing)
     {
         mRing->read(buffer, samples);
-        return ALC_NO_ERROR;
+        return;
     }
 
     mLastAvail -= samples;
@@ -1072,7 +1078,7 @@ ALCenum AlsaCapture::captureSamples(al::byte *buffer, ALCuint samples)
             {
                 const char *err{snd_strerror(static_cast<int>(amt))};
                 ERR("restore error: %s\n", err);
-                aluHandleDisconnect(mDevice, "Capture recovery failure: %s", err);
+                mDevice->handleDisconnect("Capture recovery failure: %s", err);
                 break;
             }
             /* If the amount available is less than what's asked, we lost it
@@ -1083,16 +1089,14 @@ ALCenum AlsaCapture::captureSamples(al::byte *buffer, ALCuint samples)
         }
 
         buffer = buffer + amt;
-        samples -= static_cast<ALCuint>(amt);
+        samples -= static_cast<uint>(amt);
     }
     if(samples > 0)
         std::fill_n(buffer, snd_pcm_frames_to_bytes(mPcmHandle, samples),
             al::byte((mDevice->FmtType == DevFmtUByte) ? 0x80 : 0));
-
-    return ALC_NO_ERROR;
 }
 
-ALCuint AlsaCapture::availableSamples()
+uint AlsaCapture::availableSamples()
 {
     snd_pcm_sframes_t avail{0};
     if(mDevice->Connected.load(std::memory_order_acquire) && mDoCapture)
@@ -1112,7 +1116,7 @@ ALCuint AlsaCapture::availableSamples()
         {
             const char *err{snd_strerror(static_cast<int>(avail))};
             ERR("restore error: %s\n", err);
-            aluHandleDisconnect(mDevice, "Capture recovery failure: %s", err);
+            mDevice->handleDisconnect("Capture recovery failure: %s", err);
         }
     }
 
@@ -1121,7 +1125,7 @@ ALCuint AlsaCapture::availableSamples()
         if(avail < 0) avail = 0;
         avail += snd_pcm_bytes_to_frames(mPcmHandle, static_cast<ssize_t>(mBuffer.size()));
         if(avail > mLastAvail) mLastAvail = avail;
-        return static_cast<ALCuint>(mLastAvail);
+        return static_cast<uint>(mLastAvail);
     }
 
     while(avail > 0)
@@ -1148,7 +1152,7 @@ ALCuint AlsaCapture::availableSamples()
             {
                 const char *err{snd_strerror(static_cast<int>(amt))};
                 ERR("restore error: %s\n", err);
-                aluHandleDisconnect(mDevice, "Capture recovery failure: %s", err);
+                mDevice->handleDisconnect("Capture recovery failure: %s", err);
                 break;
             }
             avail = amt;
@@ -1159,14 +1163,13 @@ ALCuint AlsaCapture::availableSamples()
         avail -= amt;
     }
 
-    return static_cast<ALCuint>(mRing->readSpace());
+    return static_cast<uint>(mRing->readSpace());
 }
 
 ClockLatency AlsaCapture::getClockLatency()
 {
     ClockLatency ret;
 
-    std::lock_guard<AlsaCapture> _{*this};
     ret.ClockTime = GetDeviceClockTime(mDevice);
     snd_pcm_sframes_t delay{};
     int err{snd_pcm_delay(mPcmHandle, &delay)};
@@ -1197,10 +1200,10 @@ bool AlsaBackendFactory::init()
         if(!alsa_handle)
         {
             WARN("Failed to load %s\n", "libasound.so.2");
-            return ALC_FALSE;
+            return false;
         }
 
-        error = ALC_FALSE;
+        error = false;
 #define LOAD_FUNC(f) do {                                                     \
     p##f = reinterpret_cast<decltype(p##f)>(GetSymbol(alsa_handle, #f));      \
     if(p##f == nullptr) {                                                     \
@@ -1226,30 +1229,34 @@ bool AlsaBackendFactory::init()
 bool AlsaBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void AlsaBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string AlsaBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const DevMap &entry) -> void
+    std::string outnames;
+
+    auto add_device = [&outnames](const DevMap &entry) -> void
     {
         /* +1 to also append the null char (to ensure a null-separated list and
          * double-null terminated list).
          */
-        outnames->append(entry.name.c_str(), entry.name.length()+1);
+        outnames.append(entry.name.c_str(), entry.name.length()+1);
     };
     switch(type)
     {
-        case DevProbe::Playback:
-            PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
-            std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
-            break;
+    case BackendType::Playback:
+        PlaybackDevices = probe_devices(SND_PCM_STREAM_PLAYBACK);
+        std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
+        break;
 
-        case DevProbe::Capture:
-            CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
-            std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
-            break;
+    case BackendType::Capture:
+        CaptureDevices = probe_devices(SND_PCM_STREAM_CAPTURE);
+        std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
+        break;
     }
+
+    return outnames;
 }
 
-BackendPtr AlsaBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr AlsaBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new AlsaPlayback{device}};
diff --git a/alc/backends/alsa.h b/alc/backends/alsa.h
index fb9de006..b256dcf5 100644
--- a/alc/backends/alsa.h
+++ b/alc/backends/alsa.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_ALSA_H
 #define BACKENDS_ALSA_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct AlsaBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/base.cpp b/alc/backends/base.cpp
index 25531cf5..e5ad8494 100644
--- a/alc/backends/base.cpp
+++ b/alc/backends/base.cpp
@@ -3,49 +3,54 @@
 
 #include "base.h"
 
+#include <algorithm>
+#include <array>
 #include <atomic>
-#include <thread>
 
-#include "AL/al.h"
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <mmreg.h>
+
+#include "albit.h"
+#include "core/logging.h"
+#include "aloptional.h"
+#endif
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alnumeric.h"
 #include "atomic.h"
+#include "core/devformat.h"
+
 
+namespace al {
 
-ClockLatency GetClockLatency(ALCdevice *device)
+backend_exception::backend_exception(backend_error code, const char *msg, ...) : mErrorCode{code}
 {
-    BackendBase *backend{device->Backend.get()};
-    ClockLatency ret{backend->getClockLatency()};
-    ret.Latency += device->FixedLatency;
-    return ret;
+    std::va_list args;
+    va_start(args, msg);
+    setMessage(msg, args);
+    va_end(args);
 }
+backend_exception::~backend_exception() = default;
 
+} // namespace al
 
-/* BackendBase method implementations. */
-BackendBase::BackendBase(ALCdevice *device) noexcept : mDevice{device}
-{ }
-
-BackendBase::~BackendBase() = default;
 
 bool BackendBase::reset()
-{ throw al::backend_exception{ALC_INVALID_DEVICE, "Invalid BackendBase call"}; }
+{ throw al::backend_exception{al::backend_error::DeviceError, "Invalid BackendBase call"}; }
 
-ALCenum BackendBase::captureSamples(al::byte*, ALCuint)
-{ return ALC_INVALID_DEVICE; }
+void BackendBase::captureSamples(al::byte*, uint)
+{ }
 
-ALCuint BackendBase::availableSamples()
+uint BackendBase::availableSamples()
 { return 0; }
 
 ClockLatency BackendBase::getClockLatency()
 {
     ClockLatency ret;
 
-    ALuint refcount;
+    uint refcount;
     do {
-        while(((refcount=ReadRef(mDevice->MixCount))&1) != 0)
-            std::this_thread::yield();
+        refcount = mDevice->waitForMix();
         ret.ClockTime = GetDeviceClockTime(mDevice);
         std::atomic_thread_fence(std::memory_order_acquire);
     } while(refcount != ReadRef(mDevice->MixCount));
@@ -60,3 +65,138 @@ ClockLatency BackendBase::getClockLatency()
 
     return ret;
 }
+
+void BackendBase::setDefaultWFXChannelOrder()
+{
+    mDevice->RealOut.ChannelIndex.fill(InvalidChannelIndex);
+
+    switch(mDevice->FmtChans)
+    {
+    case DevFmtMono:
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 0;
+        break;
+    case DevFmtStereo:
+        mDevice->RealOut.ChannelIndex[FrontLeft]  = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight] = 1;
+        break;
+    case DevFmtQuad:
+        mDevice->RealOut.ChannelIndex[FrontLeft]  = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight] = 1;
+        mDevice->RealOut.ChannelIndex[BackLeft]   = 2;
+        mDevice->RealOut.ChannelIndex[BackRight]  = 3;
+        break;
+    case DevFmtX51:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 2;
+        mDevice->RealOut.ChannelIndex[LFE]         = 3;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 4;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 5;
+        break;
+    case DevFmtX61:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 2;
+        mDevice->RealOut.ChannelIndex[LFE]         = 3;
+        mDevice->RealOut.ChannelIndex[BackCenter]  = 4;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 5;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 6;
+        break;
+    case DevFmtX71:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 2;
+        mDevice->RealOut.ChannelIndex[LFE]         = 3;
+        mDevice->RealOut.ChannelIndex[BackLeft]    = 4;
+        mDevice->RealOut.ChannelIndex[BackRight]   = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 7;
+        break;
+    case DevFmtX714:
+        mDevice->RealOut.ChannelIndex[FrontLeft]     = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]    = 1;
+        mDevice->RealOut.ChannelIndex[FrontCenter]   = 2;
+        mDevice->RealOut.ChannelIndex[LFE]           = 3;
+        mDevice->RealOut.ChannelIndex[BackLeft]      = 4;
+        mDevice->RealOut.ChannelIndex[BackRight]     = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]      = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]     = 7;
+        mDevice->RealOut.ChannelIndex[TopFrontLeft]  = 8;
+        mDevice->RealOut.ChannelIndex[TopFrontRight] = 9;
+        mDevice->RealOut.ChannelIndex[TopBackLeft]   = 10;
+        mDevice->RealOut.ChannelIndex[TopBackRight]  = 11;
+        break;
+    case DevFmtX3D71:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 2;
+        mDevice->RealOut.ChannelIndex[LFE]         = 3;
+        mDevice->RealOut.ChannelIndex[Aux0]        = 4;
+        mDevice->RealOut.ChannelIndex[Aux1]        = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 7;
+        break;
+    case DevFmtAmbi3D:
+        break;
+    }
+}
+
+void BackendBase::setDefaultChannelOrder()
+{
+    mDevice->RealOut.ChannelIndex.fill(InvalidChannelIndex);
+
+    switch(mDevice->FmtChans)
+    {
+    case DevFmtX51:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 2;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 3;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 4;
+        mDevice->RealOut.ChannelIndex[LFE]         = 5;
+        return;
+    case DevFmtX71:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[BackLeft]    = 2;
+        mDevice->RealOut.ChannelIndex[BackRight]   = 3;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 4;
+        mDevice->RealOut.ChannelIndex[LFE]         = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 7;
+        return;
+    case DevFmtX714:
+        mDevice->RealOut.ChannelIndex[FrontLeft]     = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]    = 1;
+        mDevice->RealOut.ChannelIndex[BackLeft]      = 2;
+        mDevice->RealOut.ChannelIndex[BackRight]     = 3;
+        mDevice->RealOut.ChannelIndex[FrontCenter]   = 4;
+        mDevice->RealOut.ChannelIndex[LFE]           = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]      = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]     = 7;
+        mDevice->RealOut.ChannelIndex[TopFrontLeft]  = 8;
+        mDevice->RealOut.ChannelIndex[TopFrontRight] = 9;
+        mDevice->RealOut.ChannelIndex[TopBackLeft]   = 10;
+        mDevice->RealOut.ChannelIndex[TopBackRight]  = 11;
+        break;
+    case DevFmtX3D71:
+        mDevice->RealOut.ChannelIndex[FrontLeft]   = 0;
+        mDevice->RealOut.ChannelIndex[FrontRight]  = 1;
+        mDevice->RealOut.ChannelIndex[Aux0]        = 2;
+        mDevice->RealOut.ChannelIndex[Aux1]        = 3;
+        mDevice->RealOut.ChannelIndex[FrontCenter] = 4;
+        mDevice->RealOut.ChannelIndex[LFE]         = 5;
+        mDevice->RealOut.ChannelIndex[SideLeft]    = 6;
+        mDevice->RealOut.ChannelIndex[SideRight]   = 7;
+        return;
+
+    /* Same as WFX order */
+    case DevFmtMono:
+    case DevFmtStereo:
+    case DevFmtQuad:
+    case DevFmtX61:
+    case DevFmtAmbi3D:
+        setDefaultWFXChannelOrder();
+        break;
+    }
+}
diff --git a/alc/backends/base.h b/alc/backends/base.h
index d4856818..b6b3d922 100644
--- a/alc/backends/base.h
+++ b/alc/backends/base.h
@@ -2,70 +2,75 @@
 #define ALC_BACKENDS_BASE_H
 
 #include <chrono>
+#include <cstdarg>
 #include <memory>
-#include <mutex>
+#include <ratio>
 #include <string>
 
-#include "AL/alc.h"
-
-#include "alcmain.h"
 #include "albyte.h"
+#include "core/device.h"
+#include "core/except.h"
+
 
+using uint = unsigned int;
 
 struct ClockLatency {
     std::chrono::nanoseconds ClockTime;
     std::chrono::nanoseconds Latency;
 };
 
-/* Helper to get the current clock time from the device's ClockBase, and
- * SamplesDone converted from the sample rate.
- */
-inline std::chrono::nanoseconds GetDeviceClockTime(ALCdevice *device)
-{
-    using std::chrono::seconds;
-    using std::chrono::nanoseconds;
-
-    auto ns = nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
-    return device->ClockBase + ns;
-}
-
-ClockLatency GetClockLatency(ALCdevice *device);
-
 struct BackendBase {
-    virtual void open(const ALCchar *name) = 0;
+    virtual void open(const char *name) = 0;
 
     virtual bool reset();
-    virtual bool start() = 0;
+    virtual void start() = 0;
     virtual void stop() = 0;
 
-    virtual ALCenum captureSamples(al::byte *buffer, ALCuint samples);
-    virtual ALCuint availableSamples();
+    virtual void captureSamples(al::byte *buffer, uint samples);
+    virtual uint availableSamples();
 
     virtual ClockLatency getClockLatency();
 
-    virtual void lock() { mMutex.lock(); }
-    virtual void unlock() { mMutex.unlock(); }
+    DeviceBase *const mDevice;
 
-    ALCdevice *mDevice;
+    BackendBase(DeviceBase *device) noexcept : mDevice{device} { }
+    virtual ~BackendBase() = default;
 
-    std::recursive_mutex mMutex;
-
-    BackendBase(ALCdevice *device) noexcept;
-    virtual ~BackendBase();
+protected:
+    /** Sets the default channel order used by most non-WaveFormatEx-based APIs. */
+    void setDefaultChannelOrder();
+    /** Sets the default channel order used by WaveFormatEx. */
+    void setDefaultWFXChannelOrder();
 };
 using BackendPtr = std::unique_ptr<BackendBase>;
-using BackendUniqueLock = std::unique_lock<BackendBase>;
-using BackendLockGuard = std::lock_guard<BackendBase>;
 
 enum class BackendType {
     Playback,
     Capture
 };
 
-enum class DevProbe {
-    Playback,
-    Capture
-};
+
+/* Helper to get the current clock time from the device's ClockBase, and
+ * SamplesDone converted from the sample rate.
+ */
+inline std::chrono::nanoseconds GetDeviceClockTime(DeviceBase *device)
+{
+    using std::chrono::seconds;
+    using std::chrono::nanoseconds;
+
+    auto ns = nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
+    return device->ClockBase + ns;
+}
+
+/* Helper to get the device latency from the backend, including any fixed
+ * latency from post-processing.
+ */
+inline ClockLatency GetClockLatency(DeviceBase *device, BackendBase *backend)
+{
+    ClockLatency ret{backend->getClockLatency()};
+    ret.Latency += device->FixedLatency;
+    return ret;
+}
 
 
 struct BackendFactory {
@@ -73,12 +78,37 @@ struct BackendFactory {
 
     virtual bool querySupport(BackendType type) = 0;
 
-    virtual void probe(DevProbe type, std::string *outnames) = 0;
+    virtual std::string probe(BackendType type) = 0;
 
-    virtual BackendPtr createBackend(ALCdevice *device, BackendType type) = 0;
+    virtual BackendPtr createBackend(DeviceBase *device, BackendType type) = 0;
 
 protected:
     virtual ~BackendFactory() = default;
 };
 
+namespace al {
+
+enum class backend_error {
+    NoDevice,
+    DeviceError,
+    OutOfMemory
+};
+
+class backend_exception final : public base_exception {
+    backend_error mErrorCode;
+
+public:
+#ifdef __USE_MINGW_ANSI_STDIO
+    [[gnu::format(gnu_printf, 3, 4)]]
+#else
+    [[gnu::format(printf, 3, 4)]]
+#endif
+    backend_exception(backend_error code, const char *msg, ...);
+    ~backend_exception() override;
+
+    backend_error errorCode() const noexcept { return mErrorCode; }
+};
+
+} // namespace al
+
 #endif /* ALC_BACKENDS_BASE_H */
diff --git a/alc/backends/coreaudio.cpp b/alc/backends/coreaudio.cpp
index 7c18287b..8b0e75fd 100644
--- a/alc/backends/coreaudio.cpp
+++ b/alc/backends/coreaudio.cpp
@@ -20,31 +20,241 @@
 
 #include "config.h"
 
-#include "backends/coreaudio.h"
+#include "coreaudio.h"
 
+#include <inttypes.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#include <cmath>
+#include <memory>
+#include <string>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
+#include "alnumeric.h"
+#include "core/converter.h"
+#include "core/device.h"
+#include "core/logging.h"
 #include "ringbuffer.h"
-#include "converter.h"
-#include "backends/base.h"
 
-#include <unistd.h>
 #include <AudioUnit/AudioUnit.h>
 #include <AudioToolbox/AudioToolbox.h>
 
 
 namespace {
 
-static const ALCchar ca_device[] = "CoreAudio Default";
+#if TARGET_OS_IOS || TARGET_OS_TV
+#define CAN_ENUMERATE 0
+#else
+#define CAN_ENUMERATE 1
+#endif
+
+constexpr auto OutputElement = 0;
+constexpr auto InputElement = 1;
+
+#if CAN_ENUMERATE
+struct DeviceEntry {
+    AudioDeviceID mId;
+    std::string mName;
+};
+
+std::vector<DeviceEntry> PlaybackList;
+std::vector<DeviceEntry> CaptureList;
+
+
+OSStatus GetHwProperty(AudioHardwarePropertyID propId, UInt32 dataSize, void *propData)
+{
+    const AudioObjectPropertyAddress addr{propId, kAudioObjectPropertyScopeGlobal,
+        kAudioObjectPropertyElementMaster};
+    return AudioObjectGetPropertyData(kAudioObjectSystemObject, &addr, 0, nullptr, &dataSize,
+        propData);
+}
+
+OSStatus GetHwPropertySize(AudioHardwarePropertyID propId, UInt32 *outSize)
+{
+    const AudioObjectPropertyAddress addr{propId, kAudioObjectPropertyScopeGlobal,
+        kAudioObjectPropertyElementMaster};
+    return AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &addr, 0, nullptr, outSize);
+}
+
+OSStatus GetDevProperty(AudioDeviceID devId, AudioDevicePropertyID propId, bool isCapture,
+    UInt32 elem, UInt32 dataSize, void *propData)
+{
+    static const AudioObjectPropertyScope scopes[2]{kAudioDevicePropertyScopeOutput,
+        kAudioDevicePropertyScopeInput};
+    const AudioObjectPropertyAddress addr{propId, scopes[isCapture], elem};
+    return AudioObjectGetPropertyData(devId, &addr, 0, nullptr, &dataSize, propData);
+}
+
+OSStatus GetDevPropertySize(AudioDeviceID devId, AudioDevicePropertyID inPropertyID,
+    bool isCapture, UInt32 elem, UInt32 *outSize)
+{
+    static const AudioObjectPropertyScope scopes[2]{kAudioDevicePropertyScopeOutput,
+        kAudioDevicePropertyScopeInput};
+    const AudioObjectPropertyAddress addr{inPropertyID, scopes[isCapture], elem};
+    return AudioObjectGetPropertyDataSize(devId, &addr, 0, nullptr, outSize);
+}
+
+
+std::string GetDeviceName(AudioDeviceID devId)
+{
+    std::string devname;
+    CFStringRef nameRef;
+
+    /* Try to get the device name as a CFString, for Unicode name support. */
+    OSStatus err{GetDevProperty(devId, kAudioDevicePropertyDeviceNameCFString, false, 0,
+        sizeof(nameRef), &nameRef)};
+    if(err == noErr)
+    {
+        const CFIndex propSize{CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef),
+            kCFStringEncodingUTF8)};
+        devname.resize(static_cast<size_t>(propSize)+1, '\0');
+
+        CFStringGetCString(nameRef, &devname[0], propSize+1, kCFStringEncodingUTF8);
+        CFRelease(nameRef);
+    }
+    else
+    {
+        /* If that failed, just get the C string. Hopefully there's nothing bad
+         * with this.
+         */
+        UInt32 propSize{};
+        if(GetDevPropertySize(devId, kAudioDevicePropertyDeviceName, false, 0, &propSize))
+            return devname;
+
+        devname.resize(propSize+1, '\0');
+        if(GetDevProperty(devId, kAudioDevicePropertyDeviceName, false, 0, propSize, &devname[0]))
+        {
+            devname.clear();
+            return devname;
+        }
+    }
+
+    /* Clear extraneous nul chars that may have been written with the name
+     * string, and return it.
+     */
+    while(!devname.back())
+        devname.pop_back();
+    return devname;
+}
+
+UInt32 GetDeviceChannelCount(AudioDeviceID devId, bool isCapture)
+{
+    UInt32 propSize{};
+    auto err = GetDevPropertySize(devId, kAudioDevicePropertyStreamConfiguration, isCapture, 0,
+        &propSize);
+    if(err)
+    {
+        ERR("kAudioDevicePropertyStreamConfiguration size query failed: %u\n", err);
+        return 0;
+    }
+
+    auto buflist_data = std::make_unique<char[]>(propSize);
+    auto *buflist = reinterpret_cast<AudioBufferList*>(buflist_data.get());
+
+    err = GetDevProperty(devId, kAudioDevicePropertyStreamConfiguration, isCapture, 0, propSize,
+        buflist);
+    if(err)
+    {
+        ERR("kAudioDevicePropertyStreamConfiguration query failed: %u\n", err);
+        return 0;
+    }
+
+    UInt32 numChannels{0};
+    for(size_t i{0};i < buflist->mNumberBuffers;++i)
+        numChannels += buflist->mBuffers[i].mNumberChannels;
+
+    return numChannels;
+}
+
+
+void EnumerateDevices(std::vector<DeviceEntry> &list, bool isCapture)
+{
+    UInt32 propSize{};
+    if(auto err = GetHwPropertySize(kAudioHardwarePropertyDevices, &propSize))
+    {
+        ERR("Failed to get device list size: %u\n", err);
+        return;
+    }
+
+    auto devIds = std::vector<AudioDeviceID>(propSize/sizeof(AudioDeviceID), kAudioDeviceUnknown);
+    if(auto err = GetHwProperty(kAudioHardwarePropertyDevices, propSize, devIds.data()))
+    {
+        ERR("Failed to get device list: %u\n", err);
+        return;
+    }
+
+    std::vector<DeviceEntry> newdevs;
+    newdevs.reserve(devIds.size());
+
+    AudioDeviceID defaultId{kAudioDeviceUnknown};
+    GetHwProperty(isCapture ? kAudioHardwarePropertyDefaultInputDevice :
+        kAudioHardwarePropertyDefaultOutputDevice, sizeof(defaultId), &defaultId);
+
+    if(defaultId != kAudioDeviceUnknown)
+    {
+        newdevs.emplace_back(DeviceEntry{defaultId, GetDeviceName(defaultId)});
+        const auto &entry = newdevs.back();
+        TRACE("Got device: %s = ID %u\n", entry.mName.c_str(), entry.mId);
+    }
+    for(const AudioDeviceID devId : devIds)
+    {
+        if(devId == kAudioDeviceUnknown)
+            continue;
+
+        auto match_devid = [devId](const DeviceEntry &entry) noexcept -> bool
+        { return entry.mId == devId; };
+        auto match = std::find_if(newdevs.cbegin(), newdevs.cend(), match_devid);
+        if(match != newdevs.cend()) continue;
+
+        auto numChannels = GetDeviceChannelCount(devId, isCapture);
+        if(numChannels > 0)
+        {
+            newdevs.emplace_back(DeviceEntry{devId, GetDeviceName(devId)});
+            const auto &entry = newdevs.back();
+            TRACE("Got device: %s = ID %u\n", entry.mName.c_str(), entry.mId);
+        }
+    }
+
+    if(newdevs.size() > 1)
+    {
+        /* Rename entries that have matching names, by appending '#2', '#3',
+         * etc, as needed.
+         */
+        for(auto curitem = newdevs.begin()+1;curitem != newdevs.end();++curitem)
+        {
+            auto check_match = [curitem](const DeviceEntry &entry) -> bool
+            { return entry.mName == curitem->mName; };
+            if(std::find_if(newdevs.begin(), curitem, check_match) != curitem)
+            {
+                std::string name{curitem->mName};
+                size_t count{1};
+                auto check_name = [&name](const DeviceEntry &entry) -> bool
+                { return entry.mName == name; };
+                do {
+                    name = curitem->mName;
+                    name += " #";
+                    name += std::to_string(++count);
+                } while(std::find_if(newdevs.begin(), curitem, check_name) != curitem);
+                curitem->mName = std::move(name);
+            }
+        }
+    }
+
+    newdevs.shrink_to_fit();
+    newdevs.swap(list);
+}
+
+#else
+
+static constexpr char ca_device[] = "CoreAudio Default";
+#endif
 
 
 struct CoreAudioPlayback final : public BackendBase {
-    CoreAudioPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    CoreAudioPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~CoreAudioPlayback() override;
 
     OSStatus MixerProc(AudioUnitRenderActionFlags *ioActionFlags,
@@ -58,14 +268,14 @@ struct CoreAudioPlayback final : public BackendBase {
             inBusNumber, inNumberFrames, ioData);
     }
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     AudioUnit mAudioUnit{};
 
-    ALuint mFrameSize{0u};
+    uint mFrameSize{0u};
     AudioStreamBasicDescription mFormat{}; // This is the OpenAL format as a CoreAudio ASBD
 
     DEF_NEWDEL(CoreAudioPlayback)
@@ -81,26 +291,53 @@ CoreAudioPlayback::~CoreAudioPlayback()
 OSStatus CoreAudioPlayback::MixerProc(AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32,
     UInt32, AudioBufferList *ioData) noexcept
 {
-    std::lock_guard<CoreAudioPlayback> _{*this};
-    aluMixData(mDevice, ioData->mBuffers[0].mData, ioData->mBuffers[0].mDataByteSize/mFrameSize);
+    for(size_t i{0};i < ioData->mNumberBuffers;++i)
+    {
+        auto &buffer = ioData->mBuffers[i];
+        mDevice->renderSamples(buffer.mData, buffer.mDataByteSize/mFrameSize,
+            buffer.mNumberChannels);
+    }
     return noErr;
 }
 
 
-void CoreAudioPlayback::open(const ALCchar *name)
+void CoreAudioPlayback::open(const char *name)
 {
+#if CAN_ENUMERATE
+    AudioDeviceID audioDevice{kAudioDeviceUnknown};
+    if(!name)
+        GetHwProperty(kAudioHardwarePropertyDefaultOutputDevice, sizeof(audioDevice),
+            &audioDevice);
+    else
+    {
+        if(PlaybackList.empty())
+            EnumerateDevices(PlaybackList, false);
+
+        auto find_name = [name](const DeviceEntry &entry) -> bool
+        { return entry.mName == name; };
+        auto devmatch = std::find_if(PlaybackList.cbegin(), PlaybackList.cend(), find_name);
+        if(devmatch == PlaybackList.cend())
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
+
+        audioDevice = devmatch->mId;
+    }
+#else
     if(!name)
         name = ca_device;
     else if(strcmp(name, ca_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+#endif
 
     /* open the default output unit */
     AudioComponentDescription desc{};
     desc.componentType = kAudioUnitType_Output;
-#if TARGET_OS_IOS
-    desc.componentSubType = kAudioUnitSubType_RemoteIO;
+#if CAN_ENUMERATE
+    desc.componentSubType = (audioDevice == kAudioDeviceUnknown) ?
+        kAudioUnitSubType_DefaultOutput : kAudioUnitSubType_HALOutput;
 #else
-    desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+    desc.componentSubType = kAudioUnitSubType_RemoteIO;
 #endif
     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
     desc.componentFlags = 0;
@@ -108,19 +345,52 @@ void CoreAudioPlayback::open(const ALCchar *name)
 
     AudioComponent comp{AudioComponentFindNext(NULL, &desc)};
     if(comp == nullptr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not find audio component"};
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not find audio component"};
 
-    OSStatus err{AudioComponentInstanceNew(comp, &mAudioUnit)};
+    AudioUnit audioUnit{};
+    OSStatus err{AudioComponentInstanceNew(comp, &audioUnit)};
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not create component instance: %u",
-            err};
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Could not create component instance: %u", err};
 
-    /* init and start the default audio unit... */
-    err = AudioUnitInitialize(mAudioUnit);
+#if CAN_ENUMERATE
+    if(audioDevice != kAudioDeviceUnknown)
+        AudioUnitSetProperty(audioUnit, kAudioOutputUnitProperty_CurrentDevice,
+            kAudioUnitScope_Global, OutputElement, &audioDevice, sizeof(AudioDeviceID));
+#endif
+
+    err = AudioUnitInitialize(audioUnit);
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not initialize audio unit: %u", err};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not initialize audio unit: %u", err};
 
+    /* WARNING: I don't know if "valid" audio unit values are guaranteed to be
+     * non-0. If not, this logic is broken.
+     */
+    if(mAudioUnit)
+    {
+        AudioUnitUninitialize(mAudioUnit);
+        AudioComponentInstanceDispose(mAudioUnit);
+    }
+    mAudioUnit = audioUnit;
+
+#if CAN_ENUMERATE
+    if(name)
+        mDevice->DeviceName = name;
+    else
+    {
+        UInt32 propSize{sizeof(audioDevice)};
+        audioDevice = kAudioDeviceUnknown;
+        AudioUnitGetProperty(audioUnit, kAudioOutputUnitProperty_CurrentDevice,
+            kAudioUnitScope_Global, OutputElement, &audioDevice, &propSize);
+
+        std::string devname{GetDeviceName(audioDevice)};
+        if(!devname.empty()) mDevice->DeviceName = std::move(devname);
+        else mDevice->DeviceName = "Unknown Device Name";
+    }
+#else
     mDevice->DeviceName = name;
+#endif
 }
 
 bool CoreAudioPlayback::reset()
@@ -131,10 +401,10 @@ bool CoreAudioPlayback::reset()
 
     /* retrieve default output unit's properties (output side) */
     AudioStreamBasicDescription streamFormat{};
-    auto size = static_cast<UInt32>(sizeof(AudioStreamBasicDescription));
+    UInt32 size{sizeof(streamFormat)};
     err = AudioUnitGetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output,
-        0, &streamFormat, &size);
-    if(err != noErr || size != sizeof(AudioStreamBasicDescription))
+        OutputElement, &streamFormat, &size);
+    if(err != noErr || size != sizeof(streamFormat))
     {
         ERR("AudioUnitGetProperty failed\n");
         return false;
@@ -150,99 +420,65 @@ bool CoreAudioPlayback::reset()
     TRACE("  streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
 #endif
 
-    /* set default output unit's input side to match output side */
-    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
-        0, &streamFormat, size);
-    if(err != noErr)
-    {
-        ERR("AudioUnitSetProperty failed\n");
-        return false;
-    }
-
+    /* Use the sample rate from the output unit's current parameters, but reset
+     * everything else.
+     */
     if(mDevice->Frequency != streamFormat.mSampleRate)
     {
-        mDevice->BufferSize = static_cast<ALuint>(uint64_t{mDevice->BufferSize} *
-            streamFormat.mSampleRate / mDevice->Frequency);
-        mDevice->Frequency = static_cast<ALuint>(streamFormat.mSampleRate);
+        mDevice->BufferSize = static_cast<uint>(mDevice->BufferSize*streamFormat.mSampleRate/
+            mDevice->Frequency + 0.5);
+        mDevice->Frequency = static_cast<uint>(streamFormat.mSampleRate);
     }
 
     /* FIXME: How to tell what channels are what in the output device, and how
-     * to specify what we're giving?  eg, 6.0 vs 5.1 */
-    switch(streamFormat.mChannelsPerFrame)
-    {
-        case 1:
-            mDevice->FmtChans = DevFmtMono;
-            break;
-        case 2:
-            mDevice->FmtChans = DevFmtStereo;
-            break;
-        case 4:
-            mDevice->FmtChans = DevFmtQuad;
-            break;
-        case 6:
-            mDevice->FmtChans = DevFmtX51;
-            break;
-        case 7:
-            mDevice->FmtChans = DevFmtX61;
-            break;
-        case 8:
-            mDevice->FmtChans = DevFmtX71;
-            break;
-        default:
-            ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
-            mDevice->FmtChans = DevFmtStereo;
-            streamFormat.mChannelsPerFrame = 2;
-            break;
-    }
-    SetDefaultWFXChannelOrder(mDevice);
+     * to specify what we're giving? e.g. 6.0 vs 5.1
+     */
+    streamFormat.mChannelsPerFrame = mDevice->channelsFromFmt();
 
-    /* use channel count and sample rate from the default output unit's current
-     * parameters, but reset everything else */
     streamFormat.mFramesPerPacket = 1;
-    streamFormat.mFormatFlags = 0;
+    streamFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kLinearPCMFormatFlagIsPacked;
+    streamFormat.mFormatID = kAudioFormatLinearPCM;
     switch(mDevice->FmtType)
     {
         case DevFmtUByte:
             mDevice->FmtType = DevFmtByte;
             /* fall-through */
         case DevFmtByte:
-            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
             streamFormat.mBitsPerChannel = 8;
             break;
         case DevFmtUShort:
             mDevice->FmtType = DevFmtShort;
             /* fall-through */
         case DevFmtShort:
-            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
             streamFormat.mBitsPerChannel = 16;
             break;
         case DevFmtUInt:
             mDevice->FmtType = DevFmtInt;
             /* fall-through */
         case DevFmtInt:
-            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
             streamFormat.mBitsPerChannel = 32;
             break;
         case DevFmtFloat:
-            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat;
+            streamFormat.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
             streamFormat.mBitsPerChannel = 32;
             break;
     }
-    streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame *
-                                  streamFormat.mBitsPerChannel / 8;
-    streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame;
-    streamFormat.mFormatID = kAudioFormatLinearPCM;
-    streamFormat.mFormatFlags |= kAudioFormatFlagsNativeEndian |
-                                 kLinearPCMFormatFlagIsPacked;
+    streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame*streamFormat.mBitsPerChannel/8;
+    streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame*streamFormat.mFramesPerPacket;
 
     err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
-        0, &streamFormat, sizeof(AudioStreamBasicDescription));
+        OutputElement, &streamFormat, sizeof(streamFormat));
     if(err != noErr)
     {
         ERR("AudioUnitSetProperty failed\n");
         return false;
     }
 
+    setDefaultWFXChannelOrder();
+
     /* setup callback */
     mFrameSize = mDevice->frameSizeFromFmt();
     AURenderCallbackStruct input{};
@@ -250,7 +486,7 @@ bool CoreAudioPlayback::reset()
     input.inputProcRefCon = this;
 
     err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_SetRenderCallback,
-        kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
+        kAudioUnitScope_Input, OutputElement, &input, sizeof(AURenderCallbackStruct));
     if(err != noErr)
     {
         ERR("AudioUnitSetProperty failed\n");
@@ -268,15 +504,12 @@ bool CoreAudioPlayback::reset()
     return true;
 }
 
-bool CoreAudioPlayback::start()
+void CoreAudioPlayback::start()
 {
-    OSStatus err{AudioOutputUnitStart(mAudioUnit)};
+    const OSStatus err{AudioOutputUnitStart(mAudioUnit)};
     if(err != noErr)
-    {
-        ERR("AudioOutputUnitStart failed\n");
-        return false;
-    }
-    return true;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "AudioOutputUnitStart failed: %d", err};
 }
 
 void CoreAudioPlayback::stop()
@@ -288,7 +521,7 @@ void CoreAudioPlayback::stop()
 
 
 struct CoreAudioCapture final : public BackendBase {
-    CoreAudioCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    CoreAudioCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~CoreAudioCapture() override;
 
     OSStatus RecordProc(AudioUnitRenderActionFlags *ioActionFlags,
@@ -302,19 +535,21 @@ struct CoreAudioCapture final : public BackendBase {
             inBusNumber, inNumberFrames, ioData);
     }
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
     AudioUnit mAudioUnit{0};
 
-    ALuint mFrameSize{0u};
+    uint mFrameSize{0u};
     AudioStreamBasicDescription mFormat{};  // This is the OpenAL format as a CoreAudio ASBD
 
     SampleConverterPtr mConverter;
 
+    al::vector<char> mCaptureData;
+
     RingBufferPtr mRing{nullptr};
 
     DEF_NEWDEL(CoreAudioCapture)
@@ -328,181 +563,176 @@ CoreAudioCapture::~CoreAudioCapture()
 }
 
 
-OSStatus CoreAudioCapture::RecordProc(AudioUnitRenderActionFlags*,
-    const AudioTimeStamp *inTimeStamp, UInt32, UInt32 inNumberFrames,
+OSStatus CoreAudioCapture::RecordProc(AudioUnitRenderActionFlags *ioActionFlags,
+    const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames,
     AudioBufferList*) noexcept
 {
-    AudioUnitRenderActionFlags flags = 0;
     union {
-        al::byte _[sizeof(AudioBufferList) + sizeof(AudioBuffer)*2];
+        al::byte _[maxz(sizeof(AudioBufferList), offsetof(AudioBufferList, mBuffers[1]))];
         AudioBufferList list;
     } audiobuf{};
 
-    auto rec_vec = mRing->getWriteVector();
-    inNumberFrames = static_cast<UInt32>(minz(inNumberFrames,
-        rec_vec.first.len+rec_vec.second.len));
+    audiobuf.list.mNumberBuffers = 1;
+    audiobuf.list.mBuffers[0].mNumberChannels = mFormat.mChannelsPerFrame;
+    audiobuf.list.mBuffers[0].mData = mCaptureData.data();
+    audiobuf.list.mBuffers[0].mDataByteSize = static_cast<UInt32>(mCaptureData.size());
 
-    // Fill the ringbuffer's two segments with data from the input device
-    if(rec_vec.first.len >= inNumberFrames)
-    {
-        audiobuf.list.mNumberBuffers = 1;
-        audiobuf.list.mBuffers[0].mNumberChannels = mFormat.mChannelsPerFrame;
-        audiobuf.list.mBuffers[0].mData = rec_vec.first.buf;
-        audiobuf.list.mBuffers[0].mDataByteSize = inNumberFrames * mFormat.mBytesPerFrame;
-    }
-    else
-    {
-        const auto remaining = static_cast<ALuint>(inNumberFrames - rec_vec.first.len);
-        audiobuf.list.mNumberBuffers = 2;
-        audiobuf.list.mBuffers[0].mNumberChannels = mFormat.mChannelsPerFrame;
-        audiobuf.list.mBuffers[0].mData = rec_vec.first.buf;
-        audiobuf.list.mBuffers[0].mDataByteSize = static_cast<UInt32>(rec_vec.first.len) *
-            mFormat.mBytesPerFrame;
-        audiobuf.list.mBuffers[1].mNumberChannels = mFormat.mChannelsPerFrame;
-        audiobuf.list.mBuffers[1].mData = rec_vec.second.buf;
-        audiobuf.list.mBuffers[1].mDataByteSize = remaining * mFormat.mBytesPerFrame;
-    }
-    OSStatus err{AudioUnitRender(mAudioUnit, &flags, inTimeStamp, audiobuf.list.mNumberBuffers,
+    OSStatus err{AudioUnitRender(mAudioUnit, ioActionFlags, inTimeStamp, inBusNumber,
         inNumberFrames, &audiobuf.list)};
     if(err != noErr)
     {
-        ERR("AudioUnitRender error: %d\n", err);
+        ERR("AudioUnitRender capture error: %d\n", err);
         return err;
     }
 
-    mRing->writeAdvance(inNumberFrames);
+    mRing->write(mCaptureData.data(), inNumberFrames);
     return noErr;
 }
 
 
-void CoreAudioCapture::open(const ALCchar *name)
+void CoreAudioCapture::open(const char *name)
 {
-    AudioStreamBasicDescription requestedFormat;  // The application requested format
-    AudioStreamBasicDescription hardwareFormat;   // The hardware format
-    AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
-    AURenderCallbackStruct input;
-    AudioComponentDescription desc;
-    UInt32 outputFrameCount;
-    UInt32 propertySize;
-#if !TARGET_OS_IOS
-    AudioObjectPropertyAddress propertyAddress;
-#endif
-    UInt32 enableIO;
-    AudioComponent comp;
-    OSStatus err;
+#if CAN_ENUMERATE
+    AudioDeviceID audioDevice{kAudioDeviceUnknown};
+    if(!name)
+        GetHwProperty(kAudioHardwarePropertyDefaultInputDevice, sizeof(audioDevice),
+            &audioDevice);
+    else
+    {
+        if(CaptureList.empty())
+            EnumerateDevices(CaptureList, true);
+
+        auto find_name = [name](const DeviceEntry &entry) -> bool
+        { return entry.mName == name; };
+        auto devmatch = std::find_if(CaptureList.cbegin(), CaptureList.cend(), find_name);
+        if(devmatch == CaptureList.cend())
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
 
+        audioDevice = devmatch->mId;
+    }
+#else
     if(!name)
         name = ca_device;
     else if(strcmp(name, ca_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+#endif
 
+    AudioComponentDescription desc{};
     desc.componentType = kAudioUnitType_Output;
-#if TARGET_OS_IOS
-    desc.componentSubType = kAudioUnitSubType_RemoteIO;
+#if CAN_ENUMERATE
+    desc.componentSubType = (audioDevice == kAudioDeviceUnknown) ?
+        kAudioUnitSubType_DefaultOutput : kAudioUnitSubType_HALOutput;
 #else
-    desc.componentSubType = kAudioUnitSubType_HALOutput;
+    desc.componentSubType = kAudioUnitSubType_RemoteIO;
 #endif
     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
     desc.componentFlags = 0;
     desc.componentFlagsMask = 0;
 
     // Search for component with given description
-    comp = AudioComponentFindNext(NULL, &desc);
+    AudioComponent comp{AudioComponentFindNext(NULL, &desc)};
     if(comp == NULL)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not find audio component"};
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not find audio component"};
 
     // Open the component
-    err = AudioComponentInstanceNew(comp, &mAudioUnit);
+    OSStatus err{AudioComponentInstanceNew(comp, &mAudioUnit)};
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not create component instance: %u",
-            err};
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Could not create component instance: %u", err};
 
     // Turn off AudioUnit output
-    enableIO = 0;
+    UInt32 enableIO{0};
     err = AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_EnableIO,
-        kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
+        kAudioUnitScope_Output, OutputElement, &enableIO, sizeof(enableIO));
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Could not disable audio unit output property: %u", err};
 
     // Turn on AudioUnit input
     enableIO = 1;
     err = AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_EnableIO,
-        kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
+        kAudioUnitScope_Input, InputElement, &enableIO, sizeof(enableIO));
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Could not enable audio unit input property: %u", err};
 
-#if !TARGET_OS_IOS
-    {
-        // Get the default input device
-        AudioDeviceID inputDevice = kAudioDeviceUnknown;
-
-        propertySize = sizeof(AudioDeviceID);
-        propertyAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
-        propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
-        propertyAddress.mElement = kAudioObjectPropertyElementMaster;
-
-        err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, nullptr,
-            &propertySize, &inputDevice);
-        if(err != noErr)
-            throw al::backend_exception{ALC_INVALID_VALUE, "Could not get input device: %u", err};
-        if(inputDevice == kAudioDeviceUnknown)
-            throw al::backend_exception{ALC_INVALID_VALUE, "Unknown input device"};
-
-        // Track the input device
-        err = AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
-            kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
-        if(err != noErr)
-            throw al::backend_exception{ALC_INVALID_VALUE, "Could not set input device: %u", err};
-    }
+#if CAN_ENUMERATE
+    if(audioDevice != kAudioDeviceUnknown)
+        AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
+            kAudioUnitScope_Global, InputElement, &audioDevice, sizeof(AudioDeviceID));
 #endif
 
     // set capture callback
+    AURenderCallbackStruct input{};
     input.inputProc = CoreAudioCapture::RecordProcC;
     input.inputProcRefCon = this;
 
     err = AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_SetInputCallback,
-        kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
+        kAudioUnitScope_Global, InputElement, &input, sizeof(AURenderCallbackStruct));
+    if(err != noErr)
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not set capture callback: %u", err};
+
+    // Disable buffer allocation for capture
+    UInt32 flag{0};
+    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_ShouldAllocateBuffer,
+        kAudioUnitScope_Output, InputElement, &flag, sizeof(flag));
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not set capture callback: %u", err};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not disable buffer allocation property: %u", err};
 
     // Initialize the device
     err = AudioUnitInitialize(mAudioUnit);
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not initialize audio unit: %u", err};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not initialize audio unit: %u", err};
 
     // Get the hardware format
-    propertySize = sizeof(AudioStreamBasicDescription);
+    AudioStreamBasicDescription hardwareFormat{};
+    UInt32 propertySize{sizeof(hardwareFormat)};
     err = AudioUnitGetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
-        1, &hardwareFormat, &propertySize);
-    if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not get input format: %u", err};
+        InputElement, &hardwareFormat, &propertySize);
+    if(err != noErr || propertySize != sizeof(hardwareFormat))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not get input format: %u", err};
 
     // Set up the requested format description
+    AudioStreamBasicDescription requestedFormat{};
     switch(mDevice->FmtType)
     {
+    case DevFmtByte:
+        requestedFormat.mBitsPerChannel = 8;
+        requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
+        break;
     case DevFmtUByte:
         requestedFormat.mBitsPerChannel = 8;
         requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
         break;
     case DevFmtShort:
         requestedFormat.mBitsPerChannel = 16;
-        requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+        requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger
+            | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+        break;
+    case DevFmtUShort:
+        requestedFormat.mBitsPerChannel = 16;
+        requestedFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
         break;
     case DevFmtInt:
         requestedFormat.mBitsPerChannel = 32;
-        requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+        requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger
+            | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+        break;
+    case DevFmtUInt:
+        requestedFormat.mBitsPerChannel = 32;
+        requestedFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
         break;
     case DevFmtFloat:
         requestedFormat.mBitsPerChannel = 32;
-        requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
+        requestedFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat | kAudioFormatFlagsNativeEndian
+            | kAudioFormatFlagIsPacked;
         break;
-    case DevFmtByte:
-    case DevFmtUShort:
-    case DevFmtUInt:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s samples not suppoted",
-            DevFmtTypeString(mDevice->FmtType)};
     }
 
     switch(mDevice->FmtChans)
@@ -516,11 +746,12 @@ void CoreAudioCapture::open(const ALCchar *name)
 
     case DevFmtQuad:
     case DevFmtX51:
-    case DevFmtX51Rear:
     case DevFmtX61:
     case DevFmtX71:
+    case DevFmtX714:
+    case DevFmtX3D71:
     case DevFmtAmbi3D:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s not supported",
             DevFmtChannelsString(mDevice->FmtChans)};
     }
 
@@ -537,53 +768,73 @@ void CoreAudioCapture::open(const ALCchar *name)
 
     // Use intermediate format for sample rate conversion (outputFormat)
     // Set sample rate to the same as hardware for resampling later
-    outputFormat = requestedFormat;
+    AudioStreamBasicDescription outputFormat{requestedFormat};
     outputFormat.mSampleRate = hardwareFormat.mSampleRate;
 
     // The output format should be the requested format, but using the hardware sample rate
     // This is because the AudioUnit will automatically scale other properties, except for sample rate
     err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output,
-        1, &outputFormat, sizeof(outputFormat));
+        InputElement, &outputFormat, sizeof(outputFormat));
     if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not set input format: %u", err};
-
-    // Set the AudioUnit output format frame count
-    uint64_t FrameCount64{mDevice->UpdateSize};
-    FrameCount64 = static_cast<uint64_t>(FrameCount64*outputFormat.mSampleRate + mDevice->Frequency-1) /
-        mDevice->Frequency;
-    FrameCount64 += MAX_RESAMPLER_PADDING;
-    if(FrameCount64 > std::numeric_limits<uint32_t>::max()/2)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not set input format: %u", err};
+
+    /* Calculate the minimum AudioUnit output format frame count for the pre-
+     * conversion ring buffer. Ensure at least 100ms for the total buffer.
+     */
+    double srateScale{outputFormat.mSampleRate / mDevice->Frequency};
+    auto FrameCount64 = maxu64(static_cast<uint64_t>(std::ceil(mDevice->BufferSize*srateScale)),
+        static_cast<UInt32>(outputFormat.mSampleRate)/10);
+    FrameCount64 += MaxResamplerPadding;
+    if(FrameCount64 > std::numeric_limits<int32_t>::max())
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Calculated frame count is too large: %" PRIu64, FrameCount64};
 
-    outputFrameCount = static_cast<uint32_t>(FrameCount64);
-    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_MaximumFramesPerSlice,
-        kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
-    if(err != noErr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Failed to set capture frame count: %u",
-            err};
+    UInt32 outputFrameCount{};
+    propertySize = sizeof(outputFrameCount);
+    err = AudioUnitGetProperty(mAudioUnit, kAudioUnitProperty_MaximumFramesPerSlice,
+        kAudioUnitScope_Global, OutputElement, &outputFrameCount, &propertySize);
+    if(err != noErr || propertySize != sizeof(outputFrameCount))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Could not get input frame count: %u", err};
+
+    mCaptureData.resize(outputFrameCount * mFrameSize);
+
+    outputFrameCount = static_cast<UInt32>(maxu64(outputFrameCount, FrameCount64));
+    mRing = RingBuffer::Create(outputFrameCount, mFrameSize, false);
 
-    // Set up sample converter if needed
+    /* Set up sample converter if needed */
     if(outputFormat.mSampleRate != mDevice->Frequency)
-        mConverter = CreateSampleConverter(mDevice->FmtType, mDevice->FmtType,
-            mFormat.mChannelsPerFrame, static_cast<ALuint>(hardwareFormat.mSampleRate),
+        mConverter = SampleConverter::Create(mDevice->FmtType, mDevice->FmtType,
+            mFormat.mChannelsPerFrame, static_cast<uint>(hardwareFormat.mSampleRate),
             mDevice->Frequency, Resampler::FastBSinc24);
 
-    mRing = CreateRingBuffer(outputFrameCount, mFrameSize, false);
-
+#if CAN_ENUMERATE
+    if(name)
+        mDevice->DeviceName = name;
+    else
+    {
+        UInt32 propSize{sizeof(audioDevice)};
+        audioDevice = kAudioDeviceUnknown;
+        AudioUnitGetProperty(mAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
+            kAudioUnitScope_Global, InputElement, &audioDevice, &propSize);
+
+        std::string devname{GetDeviceName(audioDevice)};
+        if(!devname.empty()) mDevice->DeviceName = std::move(devname);
+        else mDevice->DeviceName = "Unknown Device Name";
+    }
+#else
     mDevice->DeviceName = name;
+#endif
 }
 
 
-bool CoreAudioCapture::start()
+void CoreAudioCapture::start()
 {
     OSStatus err{AudioOutputUnitStart(mAudioUnit)};
     if(err != noErr)
-    {
-        ERR("AudioOutputUnitStart failed\n");
-        return false;
-    }
-    return true;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "AudioOutputUnitStart failed: %d", err};
 }
 
 void CoreAudioCapture::stop()
@@ -593,35 +844,34 @@ void CoreAudioCapture::stop()
         ERR("AudioOutputUnitStop failed\n");
 }
 
-ALCenum CoreAudioCapture::captureSamples(al::byte *buffer, ALCuint samples)
+void CoreAudioCapture::captureSamples(al::byte *buffer, uint samples)
 {
     if(!mConverter)
     {
         mRing->read(buffer, samples);
-        return ALC_NO_ERROR;
+        return;
     }
 
     auto rec_vec = mRing->getReadVector();
     const void *src0{rec_vec.first.buf};
-    auto src0len = static_cast<ALuint>(rec_vec.first.len);
-    ALuint got{mConverter->convert(&src0, &src0len, buffer, samples)};
+    auto src0len = static_cast<uint>(rec_vec.first.len);
+    uint got{mConverter->convert(&src0, &src0len, buffer, samples)};
     size_t total_read{rec_vec.first.len - src0len};
     if(got < samples && !src0len && rec_vec.second.len > 0)
     {
         const void *src1{rec_vec.second.buf};
-        auto src1len = static_cast<ALuint>(rec_vec.second.len);
-        got += mConverter->convert(&src1, &src1len, buffer+got, samples-got);
+        auto src1len = static_cast<uint>(rec_vec.second.len);
+        got += mConverter->convert(&src1, &src1len, buffer + got*mFrameSize, samples-got);
         total_read += rec_vec.second.len - src1len;
     }
 
     mRing->readAdvance(total_read);
-    return ALC_NO_ERROR;
 }
 
-ALCuint CoreAudioCapture::availableSamples()
+uint CoreAudioCapture::availableSamples()
 {
-    if(!mConverter) return static_cast<ALCuint>(mRing->readSpace());
-    return mConverter->availableOut(static_cast<ALCuint>(mRing->readSpace()));
+    if(!mConverter) return static_cast<uint>(mRing->readSpace());
+    return mConverter->availableOut(static_cast<uint>(mRing->readSpace()));
 }
 
 } // namespace
@@ -637,19 +887,42 @@ bool CoreAudioBackendFactory::init() { return true; }
 bool CoreAudioBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback || type == BackendType::Capture; }
 
-void CoreAudioBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string CoreAudioBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
+#if CAN_ENUMERATE
+    auto append_name = [&outnames](const DeviceEntry &entry) -> void
+    {
+        /* Includes null char. */
+        outnames.append(entry.mName.c_str(), entry.mName.length()+1);
+    };
     switch(type)
     {
-        case DevProbe::Playback:
-        case DevProbe::Capture:
-            /* Includes null char. */
-            outnames->append(ca_device, sizeof(ca_device));
-            break;
+    case BackendType::Playback:
+        EnumerateDevices(PlaybackList, false);
+        std::for_each(PlaybackList.cbegin(), PlaybackList.cend(), append_name);
+        break;
+    case BackendType::Capture:
+        EnumerateDevices(CaptureList, true);
+        std::for_each(CaptureList.cbegin(), CaptureList.cend(), append_name);
+        break;
     }
+
+#else
+
+    switch(type)
+    {
+    case BackendType::Playback:
+    case BackendType::Capture:
+        /* Includes null char. */
+        outnames.append(ca_device, sizeof(ca_device));
+        break;
+    }
+#endif
+    return outnames;
 }
 
-BackendPtr CoreAudioBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr CoreAudioBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new CoreAudioPlayback{device}};
diff --git a/alc/backends/coreaudio.h b/alc/backends/coreaudio.h
index 37b9ebe5..1252edde 100644
--- a/alc/backends/coreaudio.h
+++ b/alc/backends/coreaudio.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_COREAUDIO_H
 #define BACKENDS_COREAUDIO_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct CoreAudioBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/dsound.cpp b/alc/backends/dsound.cpp
index c04ba9e4..f549c0fe 100644
--- a/alc/backends/dsound.cpp
+++ b/alc/backends/dsound.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/dsound.h"
+#include "dsound.h"
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -44,12 +44,13 @@
 #include <algorithm>
 #include <functional>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
-#include "ringbuffer.h"
-#include "compat.h"
+#include "alnumeric.h"
+#include "comptr.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "dynload.h"
+#include "ringbuffer.h"
 #include "strutils.h"
 #include "threads.h"
 
@@ -107,6 +108,15 @@ HRESULT (WINAPI *pDirectSoundCaptureEnumerateW)(LPDSENUMCALLBACKW pDSEnumCallbac
 #endif
 
 
+#define MONO SPEAKER_FRONT_CENTER
+#define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
+#define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
+#define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
+#define X5DOT1REAR (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
+#define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
+#define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
+#define X7DOT1DOT4 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT|SPEAKER_TOP_FRONT_LEFT|SPEAKER_TOP_FRONT_RIGHT|SPEAKER_TOP_BACK_LEFT|SPEAKER_TOP_BACK_RIGHT)
+
 #define MAX_UPDATES 128
 
 struct DevMap {
@@ -161,21 +171,21 @@ BOOL CALLBACK DSoundEnumDevices(GUID *guid, const WCHAR *desc, const WCHAR*, voi
 
 
 struct DSoundPlayback final : public BackendBase {
-    DSoundPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    DSoundPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~DSoundPlayback() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
-    IDirectSound       *mDS{nullptr};
-    IDirectSoundBuffer *mPrimaryBuffer{nullptr};
-    IDirectSoundBuffer *mBuffer{nullptr};
-    IDirectSoundNotify *mNotifies{nullptr};
-    HANDLE             mNotifyEvent{nullptr};
+    ComPtr<IDirectSound>       mDS;
+    ComPtr<IDirectSoundBuffer> mPrimaryBuffer;
+    ComPtr<IDirectSoundBuffer> mBuffer;
+    ComPtr<IDirectSoundNotify> mNotifies;
+    HANDLE mNotifyEvent{nullptr};
 
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
@@ -185,19 +195,11 @@ struct DSoundPlayback final : public BackendBase {
 
 DSoundPlayback::~DSoundPlayback()
 {
-    if(mNotifies)
-        mNotifies->Release();
     mNotifies = nullptr;
-    if(mBuffer)
-        mBuffer->Release();
     mBuffer = nullptr;
-    if(mPrimaryBuffer)
-        mPrimaryBuffer->Release();
     mPrimaryBuffer = nullptr;
-
-    if(mDS)
-        mDS->Release();
     mDS = nullptr;
+
     if(mNotifyEvent)
         CloseHandle(mNotifyEvent);
     mNotifyEvent = nullptr;
@@ -215,18 +217,19 @@ FORCE_ALIGN int DSoundPlayback::mixerProc()
     if(FAILED(err))
     {
         ERR("Failed to get buffer caps: 0x%lx\n", err);
-        aluHandleDisconnect(mDevice, "Failure retrieving playback buffer info: 0x%lx", err);
+        mDevice->handleDisconnect("Failure retrieving playback buffer info: 0x%lx", err);
         return 1;
     }
 
-    ALuint FrameSize{mDevice->frameSizeFromFmt()};
+    const size_t FrameStep{mDevice->channelsFromFmt()};
+    uint FrameSize{mDevice->frameSizeFromFmt()};
     DWORD FragSize{mDevice->UpdateSize * FrameSize};
 
     bool Playing{false};
     DWORD LastCursor{0u};
     mBuffer->GetCurrentPosition(&LastCursor, nullptr);
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         // Get current play cursor
         DWORD PlayCursor;
@@ -241,7 +244,7 @@ FORCE_ALIGN int DSoundPlayback::mixerProc()
                 if(FAILED(err))
                 {
                     ERR("Failed to play buffer: 0x%lx\n", err);
-                    aluHandleDisconnect(mDevice, "Failure starting playback: 0x%lx", err);
+                    mDevice->handleDisconnect("Failure starting playback: 0x%lx", err);
                     return 1;
                 }
                 Playing = true;
@@ -275,19 +278,16 @@ FORCE_ALIGN int DSoundPlayback::mixerProc()
 
         if(SUCCEEDED(err))
         {
-            std::unique_lock<DSoundPlayback> dlock{*this};
-            aluMixData(mDevice, WritePtr1, WriteCnt1/FrameSize);
+            mDevice->renderSamples(WritePtr1, WriteCnt1/FrameSize, FrameStep);
             if(WriteCnt2 > 0)
-                aluMixData(mDevice, WritePtr2, WriteCnt2/FrameSize);
-            dlock.unlock();
+                mDevice->renderSamples(WritePtr2, WriteCnt2/FrameSize, FrameStep);
 
             mBuffer->Unlock(WritePtr1, WriteCnt1, WritePtr2, WriteCnt2);
         }
         else
         {
             ERR("Buffer lock error: %#lx\n", err);
-            std::lock_guard<DSoundPlayback> _{*this};
-            aluHandleDisconnect(mDevice, "Failed to lock output buffer: 0x%lx", err);
+            mDevice->handleDisconnect("Failed to lock output buffer: 0x%lx", err);
             return 1;
         }
 
@@ -299,7 +299,7 @@ FORCE_ALIGN int DSoundPlayback::mixerProc()
     return 0;
 }
 
-void DSoundPlayback::open(const ALCchar *name)
+void DSoundPlayback::open(const char *name)
 {
     HRESULT hr;
     if(PlaybackDevices.empty())
@@ -322,155 +322,124 @@ void DSoundPlayback::open(const ALCchar *name)
     else
     {
         auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == PlaybackDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        {
+            GUID id{};
+            hr = CLSIDFromString(utf8_to_wstr(name).c_str(), &id);
+            if(SUCCEEDED(hr))
+                iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
+                    [&id](const DevMap &entry) -> bool { return entry.guid == id; });
+            if(iter == PlaybackDevices.cend())
+                throw al::backend_exception{al::backend_error::NoDevice,
+                    "Device name \"%s\" not found", name};
+        }
         guid = &iter->guid;
     }
 
     hr = DS_OK;
-    mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
-    if(!mNotifyEvent) hr = E_FAIL;
+    if(!mNotifyEvent)
+    {
+        mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
+        if(!mNotifyEvent) hr = E_FAIL;
+    }
 
     //DirectSound Init code
+    ComPtr<IDirectSound> ds;
     if(SUCCEEDED(hr))
-        hr = DirectSoundCreate(guid, &mDS, nullptr);
+        hr = DirectSoundCreate(guid, ds.getPtr(), nullptr);
     if(SUCCEEDED(hr))
-        hr = mDS->SetCooperativeLevel(GetForegroundWindow(), DSSCL_PRIORITY);
+        hr = ds->SetCooperativeLevel(GetForegroundWindow(), DSSCL_PRIORITY);
     if(FAILED(hr))
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
+        throw al::backend_exception{al::backend_error::DeviceError, "Device init failed: 0x%08lx",
+            hr};
+
+    mNotifies = nullptr;
+    mBuffer = nullptr;
+    mPrimaryBuffer = nullptr;
+    mDS = std::move(ds);
 
     mDevice->DeviceName = name;
 }
 
 bool DSoundPlayback::reset()
 {
-    if(mNotifies)
-        mNotifies->Release();
     mNotifies = nullptr;
-    if(mBuffer)
-        mBuffer->Release();
     mBuffer = nullptr;
-    if(mPrimaryBuffer)
-        mPrimaryBuffer->Release();
     mPrimaryBuffer = nullptr;
 
     switch(mDevice->FmtType)
     {
-        case DevFmtByte:
-            mDevice->FmtType = DevFmtUByte;
-            break;
-        case DevFmtFloat:
-            if(mDevice->Flags.get<SampleTypeRequest>())
-                break;
-            /* fall-through */
-        case DevFmtUShort:
-            mDevice->FmtType = DevFmtShort;
-            break;
-        case DevFmtUInt:
-            mDevice->FmtType = DevFmtInt;
-            break;
-        case DevFmtUByte:
-        case DevFmtShort:
-        case DevFmtInt:
+    case DevFmtByte:
+        mDevice->FmtType = DevFmtUByte;
+        break;
+    case DevFmtFloat:
+        if(mDevice->Flags.test(SampleTypeRequest))
             break;
+        /* fall-through */
+    case DevFmtUShort:
+        mDevice->FmtType = DevFmtShort;
+        break;
+    case DevFmtUInt:
+        mDevice->FmtType = DevFmtInt;
+        break;
+    case DevFmtUByte:
+    case DevFmtShort:
+    case DevFmtInt:
+        break;
     }
 
     WAVEFORMATEXTENSIBLE OutputType{};
-    DWORD speakers;
+    DWORD speakers{};
     HRESULT hr{mDS->GetSpeakerConfig(&speakers)};
-    if(SUCCEEDED(hr))
+    if(FAILED(hr))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to get speaker config: 0x%08lx", hr};
+
+    speakers = DSSPEAKER_CONFIG(speakers);
+    if(!mDevice->Flags.test(ChannelsRequest))
     {
-        speakers = DSSPEAKER_CONFIG(speakers);
-        if(!mDevice->Flags.get<ChannelsRequest>())
-        {
-            if(speakers == DSSPEAKER_MONO)
-                mDevice->FmtChans = DevFmtMono;
-            else if(speakers == DSSPEAKER_STEREO || speakers == DSSPEAKER_HEADPHONE)
-                mDevice->FmtChans = DevFmtStereo;
-            else if(speakers == DSSPEAKER_QUAD)
-                mDevice->FmtChans = DevFmtQuad;
-            else if(speakers == DSSPEAKER_5POINT1_SURROUND)
-                mDevice->FmtChans = DevFmtX51;
-            else if(speakers == DSSPEAKER_5POINT1_BACK)
-                mDevice->FmtChans = DevFmtX51Rear;
-            else if(speakers == DSSPEAKER_7POINT1 || speakers == DSSPEAKER_7POINT1_SURROUND)
-                mDevice->FmtChans = DevFmtX71;
-            else
-                ERR("Unknown system speaker config: 0x%lx\n", speakers);
-        }
-        mDevice->IsHeadphones = (mDevice->FmtChans == DevFmtStereo &&
-                                 speakers == DSSPEAKER_HEADPHONE);
+        if(speakers == DSSPEAKER_MONO)
+            mDevice->FmtChans = DevFmtMono;
+        else if(speakers == DSSPEAKER_STEREO || speakers == DSSPEAKER_HEADPHONE)
+            mDevice->FmtChans = DevFmtStereo;
+        else if(speakers == DSSPEAKER_QUAD)
+            mDevice->FmtChans = DevFmtQuad;
+        else if(speakers == DSSPEAKER_5POINT1_SURROUND || speakers == DSSPEAKER_5POINT1_BACK)
+            mDevice->FmtChans = DevFmtX51;
+        else if(speakers == DSSPEAKER_7POINT1 || speakers == DSSPEAKER_7POINT1_SURROUND)
+            mDevice->FmtChans = DevFmtX71;
+        else
+            ERR("Unknown system speaker config: 0x%lx\n", speakers);
+    }
+    mDevice->Flags.set(DirectEar, (speakers == DSSPEAKER_HEADPHONE));
+    const bool isRear51{speakers == DSSPEAKER_5POINT1_BACK};
 
-        switch(mDevice->FmtChans)
-        {
-            case DevFmtMono:
-                OutputType.dwChannelMask = SPEAKER_FRONT_CENTER;
-                break;
-            case DevFmtAmbi3D:
-                mDevice->FmtChans = DevFmtStereo;
-                /*fall-through*/
-            case DevFmtStereo:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT;
-                break;
-            case DevFmtQuad:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT |
-                                           SPEAKER_BACK_LEFT |
-                                           SPEAKER_BACK_RIGHT;
-                break;
-            case DevFmtX51:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT |
-                                           SPEAKER_FRONT_CENTER |
-                                           SPEAKER_LOW_FREQUENCY |
-                                           SPEAKER_SIDE_LEFT |
-                                           SPEAKER_SIDE_RIGHT;
-                break;
-            case DevFmtX51Rear:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT |
-                                           SPEAKER_FRONT_CENTER |
-                                           SPEAKER_LOW_FREQUENCY |
-                                           SPEAKER_BACK_LEFT |
-                                           SPEAKER_BACK_RIGHT;
-                break;
-            case DevFmtX61:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT |
-                                           SPEAKER_FRONT_CENTER |
-                                           SPEAKER_LOW_FREQUENCY |
-                                           SPEAKER_BACK_CENTER |
-                                           SPEAKER_SIDE_LEFT |
-                                           SPEAKER_SIDE_RIGHT;
-                break;
-            case DevFmtX71:
-                OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
-                                           SPEAKER_FRONT_RIGHT |
-                                           SPEAKER_FRONT_CENTER |
-                                           SPEAKER_LOW_FREQUENCY |
-                                           SPEAKER_BACK_LEFT |
-                                           SPEAKER_BACK_RIGHT |
-                                           SPEAKER_SIDE_LEFT |
-                                           SPEAKER_SIDE_RIGHT;
-                break;
-        }
+    switch(mDevice->FmtChans)
+    {
+    case DevFmtMono: OutputType.dwChannelMask = MONO; break;
+    case DevFmtAmbi3D: mDevice->FmtChans = DevFmtStereo;
+        /* fall-through */
+    case DevFmtStereo: OutputType.dwChannelMask = STEREO; break;
+    case DevFmtQuad: OutputType.dwChannelMask = QUAD; break;
+    case DevFmtX51: OutputType.dwChannelMask = isRear51 ? X5DOT1REAR : X5DOT1; break;
+    case DevFmtX61: OutputType.dwChannelMask = X6DOT1; break;
+    case DevFmtX71: OutputType.dwChannelMask = X7DOT1; break;
+    case DevFmtX714: OutputType.dwChannelMask = X7DOT1DOT4; break;
+    case DevFmtX3D71: OutputType.dwChannelMask = X7DOT1; break;
+    }
 
 retry_open:
-        hr = S_OK;
-        OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
-        OutputType.Format.nChannels = static_cast<WORD>(mDevice->channelsFromFmt());
-        OutputType.Format.wBitsPerSample = static_cast<WORD>(mDevice->bytesFromFmt() * 8);
-        OutputType.Format.nBlockAlign = static_cast<WORD>(OutputType.Format.nChannels *
-            OutputType.Format.wBitsPerSample / 8);
-        OutputType.Format.nSamplesPerSec = mDevice->Frequency;
-        OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
-            OutputType.Format.nBlockAlign;
-        OutputType.Format.cbSize = 0;
-    }
+    hr = S_OK;
+    OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
+    OutputType.Format.nChannels = static_cast<WORD>(mDevice->channelsFromFmt());
+    OutputType.Format.wBitsPerSample = static_cast<WORD>(mDevice->bytesFromFmt() * 8);
+    OutputType.Format.nBlockAlign = static_cast<WORD>(OutputType.Format.nChannels *
+        OutputType.Format.wBitsPerSample / 8);
+    OutputType.Format.nSamplesPerSec = mDevice->Frequency;
+    OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
+        OutputType.Format.nBlockAlign;
+    OutputType.Format.cbSize = 0;
 
     if(OutputType.Format.nChannels > 2 || mDevice->FmtType == DevFmtFloat)
     {
@@ -482,8 +451,6 @@ retry_open:
         else
             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
-        if(mPrimaryBuffer)
-            mPrimaryBuffer->Release();
         mPrimaryBuffer = nullptr;
     }
     else
@@ -493,7 +460,7 @@ retry_open:
             DSBUFFERDESC DSBDescription{};
             DSBDescription.dwSize = sizeof(DSBDescription);
             DSBDescription.dwFlags = DSBCAPS_PRIMARYBUFFER;
-            hr = mDS->CreateSoundBuffer(&DSBDescription, &mPrimaryBuffer, nullptr);
+            hr = mDS->CreateSoundBuffer(&DSBDescription, mPrimaryBuffer.getPtr(), nullptr);
         }
         if(SUCCEEDED(hr))
             hr = mPrimaryBuffer->SetFormat(&OutputType.Format);
@@ -501,19 +468,19 @@ retry_open:
 
     if(SUCCEEDED(hr))
     {
-        ALuint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
+        uint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
         if(num_updates > MAX_UPDATES)
             num_updates = MAX_UPDATES;
         mDevice->BufferSize = mDevice->UpdateSize * num_updates;
 
         DSBUFFERDESC DSBDescription{};
         DSBDescription.dwSize = sizeof(DSBDescription);
-        DSBDescription.dwFlags = DSBCAPS_CTRLPOSITIONNOTIFY | DSBCAPS_GETCURRENTPOSITION2 |
-                                 DSBCAPS_GLOBALFOCUS;
+        DSBDescription.dwFlags = DSBCAPS_CTRLPOSITIONNOTIFY | DSBCAPS_GETCURRENTPOSITION2
+            | DSBCAPS_GLOBALFOCUS;
         DSBDescription.dwBufferBytes = mDevice->BufferSize * OutputType.Format.nBlockAlign;
         DSBDescription.lpwfxFormat = &OutputType.Format;
 
-        hr = mDS->CreateSoundBuffer(&DSBDescription, &mBuffer, nullptr);
+        hr = mDS->CreateSoundBuffer(&DSBDescription, mBuffer.getPtr(), nullptr);
         if(FAILED(hr) && mDevice->FmtType == DevFmtFloat)
         {
             mDevice->FmtType = DevFmtShort;
@@ -527,56 +494,46 @@ retry_open:
         hr = mBuffer->QueryInterface(IID_IDirectSoundNotify, &ptr);
         if(SUCCEEDED(hr))
         {
-            auto Notifies = static_cast<IDirectSoundNotify*>(ptr);
-            mNotifies = Notifies;
+            mNotifies = ComPtr<IDirectSoundNotify>{static_cast<IDirectSoundNotify*>(ptr)};
 
-            ALuint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
+            uint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
             assert(num_updates <= MAX_UPDATES);
 
             std::array<DSBPOSITIONNOTIFY,MAX_UPDATES> nots;
-            for(ALuint i{0};i < num_updates;++i)
+            for(uint i{0};i < num_updates;++i)
             {
                 nots[i].dwOffset = i * mDevice->UpdateSize * OutputType.Format.nBlockAlign;
                 nots[i].hEventNotify = mNotifyEvent;
             }
-            if(Notifies->SetNotificationPositions(num_updates, nots.data()) != DS_OK)
+            if(mNotifies->SetNotificationPositions(num_updates, nots.data()) != DS_OK)
                 hr = E_FAIL;
         }
     }
 
     if(FAILED(hr))
     {
-        if(mNotifies)
-            mNotifies->Release();
         mNotifies = nullptr;
-        if(mBuffer)
-            mBuffer->Release();
         mBuffer = nullptr;
-        if(mPrimaryBuffer)
-            mPrimaryBuffer->Release();
         mPrimaryBuffer = nullptr;
         return false;
     }
 
     ResetEvent(mNotifyEvent);
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
 
     return true;
 }
 
-bool DSoundPlayback::start()
+void DSoundPlayback::start()
 {
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&DSoundPlayback::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Failed to start mixing thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    return false;
 }
 
 void DSoundPlayback::stop()
@@ -590,17 +547,17 @@ void DSoundPlayback::stop()
 
 
 struct DSoundCapture final : public BackendBase {
-    DSoundCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    DSoundCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~DSoundCapture() override;
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
-    IDirectSoundCapture *mDSC{nullptr};
-    IDirectSoundCaptureBuffer *mDSCbuffer{nullptr};
+    ComPtr<IDirectSoundCapture> mDSC;
+    ComPtr<IDirectSoundCaptureBuffer> mDSCbuffer;
     DWORD mBufferBytes{0u};
     DWORD mCursor{0u};
 
@@ -614,17 +571,13 @@ DSoundCapture::~DSoundCapture()
     if(mDSCbuffer)
     {
         mDSCbuffer->Stop();
-        mDSCbuffer->Release();
         mDSCbuffer = nullptr;
     }
-
-    if(mDSC)
-        mDSC->Release();
     mDSC = nullptr;
 }
 
 
-void DSoundCapture::open(const ALCchar *name)
+void DSoundCapture::open(const char *name)
 {
     HRESULT hr;
     if(CaptureDevices.empty())
@@ -647,11 +600,18 @@ void DSoundCapture::open(const ALCchar *name)
     else
     {
         auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == CaptureDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        {
+            GUID id{};
+            hr = CLSIDFromString(utf8_to_wstr(name).c_str(), &id);
+            if(SUCCEEDED(hr))
+                iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
+                    [&id](const DevMap &entry) -> bool { return entry.guid == id; });
+            if(iter == CaptureDevices.cend())
+                throw al::backend_exception{al::backend_error::NoDevice,
+                    "Device name \"%s\" not found", name};
+        }
         guid = &iter->guid;
     }
 
@@ -661,8 +621,8 @@ void DSoundCapture::open(const ALCchar *name)
     case DevFmtUShort:
     case DevFmtUInt:
         WARN("%s capture samples not supported\n", DevFmtTypeString(mDevice->FmtType));
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture samples not supported",
-            DevFmtTypeString(mDevice->FmtType)};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
 
     case DevFmtUByte:
     case DevFmtShort:
@@ -674,36 +634,17 @@ void DSoundCapture::open(const ALCchar *name)
     WAVEFORMATEXTENSIBLE InputType{};
     switch(mDevice->FmtChans)
     {
-    case DevFmtMono:
-        InputType.dwChannelMask = SPEAKER_FRONT_CENTER;
-        break;
-    case DevFmtStereo:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
-        break;
-    case DevFmtQuad:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT |
-            SPEAKER_BACK_RIGHT;
-        break;
-    case DevFmtX51:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER |
-            SPEAKER_LOW_FREQUENCY | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT;
-        break;
-    case DevFmtX51Rear:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER |
-            SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT;
-        break;
-    case DevFmtX61:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER |
-            SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_CENTER | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT;
-        break;
-    case DevFmtX71:
-        InputType.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER |
-            SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_LEFT |
-            SPEAKER_SIDE_RIGHT;
-        break;
+    case DevFmtMono: InputType.dwChannelMask = MONO; break;
+    case DevFmtStereo: InputType.dwChannelMask = STEREO; break;
+    case DevFmtQuad: InputType.dwChannelMask = QUAD; break;
+    case DevFmtX51: InputType.dwChannelMask = X5DOT1; break;
+    case DevFmtX61: InputType.dwChannelMask = X6DOT1; break;
+    case DevFmtX71: InputType.dwChannelMask = X7DOT1; break;
+    case DevFmtX714: InputType.dwChannelMask = X7DOT1DOT4; break;
+    case DevFmtX3D71:
     case DevFmtAmbi3D:
         WARN("%s capture not supported\n", DevFmtChannelsString(mDevice->FmtChans));
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s capture not supported",
             DevFmtChannelsString(mDevice->FmtChans)};
     }
 
@@ -728,7 +669,7 @@ void DSoundCapture::open(const ALCchar *name)
         InputType.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
     }
 
-    ALuint samples{mDevice->BufferSize};
+    uint samples{mDevice->BufferSize};
     samples = maxu(samples, 100 * mDevice->Frequency / 1000);
 
     DSCBUFFERDESC DSCBDescription{};
@@ -738,41 +679,34 @@ void DSoundCapture::open(const ALCchar *name)
     DSCBDescription.lpwfxFormat = &InputType.Format;
 
     //DirectSoundCapture Init code
-    hr = DirectSoundCaptureCreate(guid, &mDSC, nullptr);
+    hr = DirectSoundCaptureCreate(guid, mDSC.getPtr(), nullptr);
     if(SUCCEEDED(hr))
-        mDSC->CreateCaptureBuffer(&DSCBDescription, &mDSCbuffer, nullptr);
+        mDSC->CreateCaptureBuffer(&DSCBDescription, mDSCbuffer.getPtr(), nullptr);
     if(SUCCEEDED(hr))
-         mRing = CreateRingBuffer(mDevice->BufferSize, InputType.Format.nBlockAlign, false);
+         mRing = RingBuffer::Create(mDevice->BufferSize, InputType.Format.nBlockAlign, false);
 
     if(FAILED(hr))
     {
         mRing = nullptr;
-        if(mDSCbuffer)
-            mDSCbuffer->Release();
         mDSCbuffer = nullptr;
-        if(mDSC)
-            mDSC->Release();
         mDSC = nullptr;
 
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
+        throw al::backend_exception{al::backend_error::DeviceError, "Device init failed: 0x%08lx",
+            hr};
     }
 
     mBufferBytes = DSCBDescription.dwBufferBytes;
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
 
     mDevice->DeviceName = name;
 }
 
-bool DSoundCapture::start()
+void DSoundCapture::start()
 {
-    HRESULT hr{mDSCbuffer->Start(DSCBSTART_LOOPING)};
+    const HRESULT hr{mDSCbuffer->Start(DSCBSTART_LOOPING)};
     if(FAILED(hr))
-    {
-        ERR("start failed: 0x%08lx\n", hr);
-        aluHandleDisconnect(mDevice, "Failure starting capture: 0x%lx", hr);
-        return false;
-    }
-    return true;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failure starting capture: 0x%lx", hr};
 }
 
 void DSoundCapture::stop()
@@ -781,24 +715,21 @@ void DSoundCapture::stop()
     if(FAILED(hr))
     {
         ERR("stop failed: 0x%08lx\n", hr);
-        aluHandleDisconnect(mDevice, "Failure stopping capture: 0x%lx", hr);
+        mDevice->handleDisconnect("Failure stopping capture: 0x%lx", hr);
     }
 }
 
-ALCenum DSoundCapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+void DSoundCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
-ALCuint DSoundCapture::availableSamples()
+uint DSoundCapture::availableSamples()
 {
     if(!mDevice->Connected.load(std::memory_order_acquire))
-        return static_cast<ALCuint>(mRing->readSpace());
+        return static_cast<uint>(mRing->readSpace());
 
-    ALuint FrameSize{mDevice->frameSizeFromFmt()};
-    DWORD BufferBytes{mBufferBytes};
-    DWORD LastCursor{mCursor};
+    const uint FrameSize{mDevice->frameSizeFromFmt()};
+    const DWORD BufferBytes{mBufferBytes};
+    const DWORD LastCursor{mCursor};
 
     DWORD ReadCursor{};
     void *ReadPtr1{}, *ReadPtr2{};
@@ -806,8 +737,8 @@ ALCuint DSoundCapture::availableSamples()
     HRESULT hr{mDSCbuffer->GetCurrentPosition(nullptr, &ReadCursor)};
     if(SUCCEEDED(hr))
     {
-        DWORD NumBytes{(ReadCursor-LastCursor + BufferBytes) % BufferBytes};
-        if(!NumBytes) return static_cast<ALCubyte>(mRing->readSpace());
+        const DWORD NumBytes{(BufferBytes+ReadCursor-LastCursor) % BufferBytes};
+        if(!NumBytes) return static_cast<uint>(mRing->readSpace());
         hr = mDSCbuffer->Lock(LastCursor, NumBytes, &ReadPtr1, &ReadCnt1, &ReadPtr2, &ReadCnt2, 0);
     }
     if(SUCCEEDED(hr))
@@ -816,16 +747,16 @@ ALCuint DSoundCapture::availableSamples()
         if(ReadPtr2 != nullptr && ReadCnt2 > 0)
             mRing->write(ReadPtr2, ReadCnt2/FrameSize);
         hr = mDSCbuffer->Unlock(ReadPtr1, ReadCnt1, ReadPtr2, ReadCnt2);
-        mCursor = (LastCursor+ReadCnt1+ReadCnt2) % BufferBytes;
+        mCursor = ReadCursor;
     }
 
     if(FAILED(hr))
     {
         ERR("update failed: 0x%08lx\n", hr);
-        aluHandleDisconnect(mDevice, "Failure retrieving capture data: 0x%lx", hr);
+        mDevice->handleDisconnect("Failure retrieving capture data: 0x%lx", hr);
     }
 
-    return static_cast<ALCuint>(mRing->readSpace());
+    return static_cast<uint>(mRing->readSpace());
 }
 
 } // namespace
@@ -871,14 +802,15 @@ bool DSoundBackendFactory::init()
 bool DSoundBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void DSoundBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string DSoundBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const DevMap &entry) -> void
+    std::string outnames;
+    auto add_device = [&outnames](const DevMap &entry) -> void
     {
         /* +1 to also append the null char (to ensure a null-separated list and
          * double-null terminated list).
          */
-        outnames->append(entry.name.c_str(), entry.name.length()+1);
+        outnames.append(entry.name.c_str(), entry.name.length()+1);
     };
 
     /* Initialize COM to prevent name truncation */
@@ -886,27 +818,29 @@ void DSoundBackendFactory::probe(DevProbe type, std::string *outnames)
     HRESULT hrcom{CoInitialize(nullptr)};
     switch(type)
     {
-        case DevProbe::Playback:
-            PlaybackDevices.clear();
-            hr = DirectSoundEnumerateW(DSoundEnumDevices, &PlaybackDevices);
-            if(FAILED(hr))
-                ERR("Error enumerating DirectSound playback devices (0x%lx)!\n", hr);
-            std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
-            break;
+    case BackendType::Playback:
+        PlaybackDevices.clear();
+        hr = DirectSoundEnumerateW(DSoundEnumDevices, &PlaybackDevices);
+        if(FAILED(hr))
+            ERR("Error enumerating DirectSound playback devices (0x%lx)!\n", hr);
+        std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
+        break;
 
-        case DevProbe::Capture:
-            CaptureDevices.clear();
-            hr = DirectSoundCaptureEnumerateW(DSoundEnumDevices, &CaptureDevices);
-            if(FAILED(hr))
-                ERR("Error enumerating DirectSound capture devices (0x%lx)!\n", hr);
-            std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
-            break;
+    case BackendType::Capture:
+        CaptureDevices.clear();
+        hr = DirectSoundCaptureEnumerateW(DSoundEnumDevices, &CaptureDevices);
+        if(FAILED(hr))
+            ERR("Error enumerating DirectSound capture devices (0x%lx)!\n", hr);
+        std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
+        break;
     }
     if(SUCCEEDED(hrcom))
         CoUninitialize();
+
+    return outnames;
 }
 
-BackendPtr DSoundBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr DSoundBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new DSoundPlayback{device}};
diff --git a/alc/backends/dsound.h b/alc/backends/dsound.h
index 6bef0bfc..787f227a 100644
--- a/alc/backends/dsound.h
+++ b/alc/backends/dsound.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_DSOUND_H
 #define BACKENDS_DSOUND_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct DSoundBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/jack.cpp b/alc/backends/jack.cpp
index c7bf8469..791002ca 100644
--- a/alc/backends/jack.cpp
+++ b/alc/backends/jack.cpp
@@ -20,19 +20,22 @@
 
 #include "config.h"
 
-#include "backends/jack.h"
+#include "jack.h"
 
 #include <cstdlib>
 #include <cstdio>
+#include <cstring>
 #include <memory.h>
 
+#include <array>
 #include <thread>
 #include <functional>
 
-#include "alcmain.h"
-#include "alu.h"
-#include "alconfig.h"
-#include "alexcpt.h"
+#include "alc/alconfig.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "dynload.h"
 #include "ringbuffer.h"
 #include "threads.h"
@@ -43,9 +46,6 @@
 
 namespace {
 
-constexpr ALCchar jackDevice[] = "JACK Default";
-
-
 #ifdef HAVE_DYNLOAD
 #define JACK_FUNCS(MAGIC)          \
     MAGIC(jack_client_open);       \
@@ -70,7 +70,7 @@ constexpr ALCchar jackDevice[] = "JACK Default";
 
 void *jack_handle;
 #define MAKE_FUNC(f) decltype(f) * p##f
-JACK_FUNCS(MAKE_FUNC);
+JACK_FUNCS(MAKE_FUNC)
 decltype(jack_error_callback) * pjack_error_callback;
 #undef MAKE_FUNC
 
@@ -99,11 +99,13 @@ decltype(jack_error_callback) * pjack_error_callback;
 #endif
 
 
+constexpr char JackDefaultAudioType[] = JACK_DEFAULT_AUDIO_TYPE;
+
 jack_options_t ClientOptions = JackNullOption;
 
-ALCboolean jack_load()
+bool jack_load()
 {
-    ALCboolean error = ALC_FALSE;
+    bool error{false};
 
 #ifdef HAVE_DYNLOAD
     if(!jack_handle)
@@ -119,14 +121,14 @@ ALCboolean jack_load()
         if(!jack_handle)
         {
             WARN("Failed to load %s\n", JACKLIB);
-            return ALC_FALSE;
+            return false;
         }
 
-        error = ALC_FALSE;
+        error = false;
 #define LOAD_FUNC(f) do {                                                     \
     p##f = reinterpret_cast<decltype(p##f)>(GetSymbol(jack_handle, #f));      \
     if(p##f == nullptr) {                                                     \
-        error = ALC_TRUE;                                                     \
+        error = true;                                                         \
         missing_funcs += "\n" #f;                                             \
     }                                                                         \
 } while(0)
@@ -150,13 +152,142 @@ ALCboolean jack_load()
 }
 
 
+struct JackDeleter {
+    void operator()(void *ptr) { jack_free(ptr); }
+};
+using JackPortsPtr = std::unique_ptr<const char*[],JackDeleter>;
+
+struct DeviceEntry {
+    std::string mName;
+    std::string mPattern;
+
+    template<typename T, typename U>
+    DeviceEntry(T&& name, U&& pattern)
+        : mName{std::forward<T>(name)}, mPattern{std::forward<U>(pattern)}
+    { }
+};
+
+al::vector<DeviceEntry> PlaybackList;
+
+
+void EnumerateDevices(jack_client_t *client, al::vector<DeviceEntry> &list)
+{
+    std::remove_reference_t<decltype(list)>{}.swap(list);
+
+    if(JackPortsPtr ports{jack_get_ports(client, nullptr, JackDefaultAudioType, JackPortIsInput)})
+    {
+        for(size_t i{0};ports[i];++i)
+        {
+            const char *sep{std::strchr(ports[i], ':')};
+            if(!sep || ports[i] == sep) continue;
+
+            const al::span<const char> portdev{ports[i], sep};
+            auto check_name = [portdev](const DeviceEntry &entry) -> bool
+            {
+                const size_t len{portdev.size()};
+                return entry.mName.length() == len
+                    && entry.mName.compare(0, len, portdev.data(), len) == 0;
+            };
+            if(std::find_if(list.cbegin(), list.cend(), check_name) != list.cend())
+                continue;
+
+            std::string name{portdev.data(), portdev.size()};
+            list.emplace_back(name, name+":");
+            const auto &entry = list.back();
+            TRACE("Got device: %s = %s\n", entry.mName.c_str(), entry.mPattern.c_str());
+        }
+        /* There are ports but couldn't get device names from them. Add a
+         * generic entry.
+         */
+        if(ports[0] && list.empty())
+        {
+            WARN("No device names found in available ports, adding a generic name.\n");
+            list.emplace_back("JACK", "");
+        }
+    }
+
+    if(auto listopt = ConfigValueStr(nullptr, "jack", "custom-devices"))
+    {
+        for(size_t strpos{0};strpos < listopt->size();)
+        {
+            size_t nextpos{listopt->find(';', strpos)};
+            size_t seppos{listopt->find('=', strpos)};
+            if(seppos >= nextpos || seppos == strpos)
+            {
+                const std::string entry{listopt->substr(strpos, nextpos-strpos)};
+                ERR("Invalid device entry: \"%s\"\n", entry.c_str());
+                if(nextpos != std::string::npos) ++nextpos;
+                strpos = nextpos;
+                continue;
+            }
+
+            const al::span<const char> name{listopt->data()+strpos, seppos-strpos};
+            const al::span<const char> pattern{listopt->data()+(seppos+1),
+                std::min(nextpos, listopt->size())-(seppos+1)};
+
+            /* Check if this custom pattern already exists in the list. */
+            auto check_pattern = [pattern](const DeviceEntry &entry) -> bool
+            {
+                const size_t len{pattern.size()};
+                return entry.mPattern.length() == len
+                    && entry.mPattern.compare(0, len, pattern.data(), len) == 0;
+            };
+            auto itemmatch = std::find_if(list.begin(), list.end(), check_pattern);
+            if(itemmatch != list.end())
+            {
+                /* If so, replace the name with this custom one. */
+                itemmatch->mName.assign(name.data(), name.size());
+                TRACE("Customized device name: %s = %s\n", itemmatch->mName.c_str(),
+                    itemmatch->mPattern.c_str());
+            }
+            else
+            {
+                /* Otherwise, add a new device entry. */
+                list.emplace_back(std::string{name.data(), name.size()},
+                    std::string{pattern.data(), pattern.size()});
+                const auto &entry = list.back();
+                TRACE("Got custom device: %s = %s\n", entry.mName.c_str(), entry.mPattern.c_str());
+            }
+
+            if(nextpos != std::string::npos) ++nextpos;
+            strpos = nextpos;
+        }
+    }
+
+    if(list.size() > 1)
+    {
+        /* Rename entries that have matching names, by appending '#2', '#3',
+         * etc, as needed.
+         */
+        for(auto curitem = list.begin()+1;curitem != list.end();++curitem)
+        {
+            auto check_match = [curitem](const DeviceEntry &entry) -> bool
+            { return entry.mName == curitem->mName; };
+            if(std::find_if(list.begin(), curitem, check_match) != curitem)
+            {
+                std::string name{curitem->mName};
+                size_t count{1};
+                auto check_name = [&name](const DeviceEntry &entry) -> bool
+                { return entry.mName == name; };
+                do {
+                    name = curitem->mName;
+                    name += " #";
+                    name += std::to_string(++count);
+                } while(std::find_if(list.begin(), curitem, check_name) != curitem);
+                curitem->mName = std::move(name);
+            }
+        }
+    }
+}
+
+
 struct JackPlayback final : public BackendBase {
-    JackPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    JackPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~JackPlayback() override;
 
-    int bufferSizeNotify(jack_nframes_t numframes) noexcept;
-    static int bufferSizeNotifyC(jack_nframes_t numframes, void *arg) noexcept
-    { return static_cast<JackPlayback*>(arg)->bufferSizeNotify(numframes); }
+    int processRt(jack_nframes_t numframes) noexcept;
+    static int processRtC(jack_nframes_t numframes, void *arg) noexcept
+    { return static_cast<JackPlayback*>(arg)->processRt(numframes); }
 
     int process(jack_nframes_t numframes) noexcept;
     static int processC(jack_nframes_t numframes, void *arg) noexcept
@@ -164,15 +295,21 @@ struct JackPlayback final : public BackendBase {
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
     ClockLatency getClockLatency() override;
 
+    std::string mPortPattern;
+
     jack_client_t *mClient{nullptr};
-    jack_port_t *mPort[MAX_OUTPUT_CHANNELS]{};
+    std::array<jack_port_t*,MAX_OUTPUT_CHANNELS> mPort{};
+
+    std::mutex mMutex;
 
+    std::atomic<bool> mPlaying{false};
+    bool mRTMixing{false};
     RingBufferPtr mRing;
     al::semaphore mSem;
 
@@ -187,31 +324,35 @@ JackPlayback::~JackPlayback()
     if(!mClient)
         return;
 
-    std::for_each(std::begin(mPort), std::end(mPort),
-        [this](jack_port_t *port) -> void
-        { if(port) jack_port_unregister(mClient, port); }
-    );
-    std::fill(std::begin(mPort), std::end(mPort), nullptr);
+    auto unregister_port = [this](jack_port_t *port) -> void
+    { if(port) jack_port_unregister(mClient, port); };
+    std::for_each(mPort.begin(), mPort.end(), unregister_port);
+    mPort.fill(nullptr);
+
     jack_client_close(mClient);
     mClient = nullptr;
 }
 
 
-int JackPlayback::bufferSizeNotify(jack_nframes_t numframes) noexcept
+int JackPlayback::processRt(jack_nframes_t numframes) noexcept
 {
-    std::lock_guard<std::mutex> _{mDevice->StateLock};
-    mDevice->UpdateSize = numframes;
-    mDevice->BufferSize = numframes*2;
-
-    const char *devname{mDevice->DeviceName.c_str()};
-    ALuint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
-    bufsize = maxu(NextPowerOf2(bufsize), mDevice->UpdateSize);
-    mDevice->BufferSize = bufsize + mDevice->UpdateSize;
-
-    TRACE("%u / %u buffer\n", mDevice->UpdateSize, mDevice->BufferSize);
+    std::array<jack_default_audio_sample_t*,MAX_OUTPUT_CHANNELS> out;
+    size_t numchans{0};
+    for(auto port : mPort)
+    {
+        if(!port || numchans == mDevice->RealOut.Buffer.size())
+            break;
+        out[numchans++] = static_cast<float*>(jack_port_get_buffer(port, numframes));
+    }
 
-    mRing = nullptr;
-    mRing = CreateRingBuffer(bufsize, mDevice->frameSizeFromFmt(), true);
+    if(mPlaying.load(std::memory_order_acquire)) LIKELY
+        mDevice->renderSamples({out.data(), numchans}, static_cast<uint>(numframes));
+    else
+    {
+        auto clear_buf = [numframes](float *outbuf) -> void
+        { std::fill_n(outbuf, numframes, 0.0f); };
+        std::for_each(out.begin(), out.begin()+numchans, clear_buf);
+    }
 
     return 0;
 }
@@ -219,69 +360,64 @@ int JackPlayback::bufferSizeNotify(jack_nframes_t numframes) noexcept
 
 int JackPlayback::process(jack_nframes_t numframes) noexcept
 {
-    jack_default_audio_sample_t *out[MAX_OUTPUT_CHANNELS];
-    ALsizei numchans{0};
+    std::array<jack_default_audio_sample_t*,MAX_OUTPUT_CHANNELS> out;
+    size_t numchans{0};
     for(auto port : mPort)
     {
         if(!port) break;
         out[numchans++] = static_cast<float*>(jack_port_get_buffer(port, numframes));
     }
 
-    auto data = mRing->getReadVector();
-    jack_nframes_t todo{minu(numframes, static_cast<ALuint>(data.first.len))};
-    std::transform(out, out+numchans, out,
-        [&data,numchans,todo](ALfloat *outbuf) -> ALfloat*
+    jack_nframes_t total{0};
+    if(mPlaying.load(std::memory_order_acquire)) LIKELY
+    {
+        auto data = mRing->getReadVector();
+        jack_nframes_t todo{minu(numframes, static_cast<uint>(data.first.len))};
+        auto write_first = [&data,numchans,todo](float *outbuf) -> float*
         {
-            const ALfloat *RESTRICT in = reinterpret_cast<ALfloat*>(data.first.buf);
-            std::generate_n(outbuf, todo,
-                [&in,numchans]() noexcept -> ALfloat
+            const float *RESTRICT in = reinterpret_cast<float*>(data.first.buf);
+            auto deinterlace_input = [&in,numchans]() noexcept -> float
+            {
+                float ret{*in};
+                in += numchans;
+                return ret;
+            };
+            std::generate_n(outbuf, todo, deinterlace_input);
+            data.first.buf += sizeof(float);
+            return outbuf + todo;
+        };
+        std::transform(out.begin(), out.begin()+numchans, out.begin(), write_first);
+        total += todo;
+
+        todo = minu(numframes-total, static_cast<uint>(data.second.len));
+        if(todo > 0)
+        {
+            auto write_second = [&data,numchans,todo](float *outbuf) -> float*
+            {
+                const float *RESTRICT in = reinterpret_cast<float*>(data.second.buf);
+                auto deinterlace_input = [&in,numchans]() noexcept -> float
                 {
-                    ALfloat ret{*in};
+                    float ret{*in};
                     in += numchans;
                     return ret;
-                }
-            );
-            data.first.buf += sizeof(ALfloat);
-            return outbuf + todo;
+                };
+                std::generate_n(outbuf, todo, deinterlace_input);
+                data.second.buf += sizeof(float);
+                return outbuf + todo;
+            };
+            std::transform(out.begin(), out.begin()+numchans, out.begin(), write_second);
+            total += todo;
         }
-    );
-    jack_nframes_t total{todo};
 
-    todo = minu(numframes-total, static_cast<ALuint>(data.second.len));
-    if(todo > 0)
-    {
-        std::transform(out, out+numchans, out,
-            [&data,numchans,todo](ALfloat *outbuf) -> ALfloat*
-            {
-                const ALfloat *RESTRICT in = reinterpret_cast<ALfloat*>(data.second.buf);
-                std::generate_n(outbuf, todo,
-                    [&in,numchans]() noexcept -> ALfloat
-                    {
-                        ALfloat ret{*in};
-                        in += numchans;
-                        return ret;
-                    }
-                );
-                data.second.buf += sizeof(ALfloat);
-                return outbuf + todo;
-            }
-        );
-        total += todo;
+        mRing->readAdvance(total);
+        mSem.post();
     }
 
-    mRing->readAdvance(total);
-    mSem.post();
-
     if(numframes > total)
     {
-        todo = numframes-total;
-        std::transform(out, out+numchans, out,
-            [todo](ALfloat *outbuf) -> ALfloat*
-            {
-                std::fill_n(outbuf, todo, 0.0f);
-                return outbuf + todo;
-            }
-        );
+        const jack_nframes_t todo{numframes - total};
+        auto clear_buf = [todo](float *outbuf) -> void { std::fill_n(outbuf, todo, 0.0f); };
+        std::for_each(out.begin(), out.begin()+numchans, clear_buf);
     }
 
     return 0;
@@ -292,28 +428,28 @@ int JackPlayback::mixerProc()
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    std::unique_lock<JackPlayback> dlock{*this};
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    const size_t frame_step{mDevice->channelsFromFmt()};
+
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         if(mRing->writeSpace() < mDevice->UpdateSize)
         {
-            dlock.unlock();
             mSem.wait();
-            dlock.lock();
             continue;
         }
 
         auto data = mRing->getWriteVector();
-        auto todo = static_cast<ALuint>(data.first.len + data.second.len);
+        size_t todo{data.first.len + data.second.len};
         todo -= todo%mDevice->UpdateSize;
 
-        ALuint len1{minu(static_cast<ALuint>(data.first.len), todo)};
-        ALuint len2{minu(static_cast<ALuint>(data.second.len), todo-len1)};
+        const auto len1 = static_cast<uint>(minz(data.first.len, todo));
+        const auto len2 = static_cast<uint>(minz(data.second.len, todo-len1));
 
-        aluMixData(mDevice, data.first.buf, len1);
+        std::lock_guard<std::mutex> _{mMutex};
+        mDevice->renderSamples(data.first.buf, len1, frame_step);
         if(len2 > 0)
-            aluMixData(mDevice, data.second.buf, len2);
+            mDevice->renderSamples(data.second.buf, len2, frame_step);
         mRing->writeAdvance(todo);
     }
 
@@ -321,77 +457,105 @@ int JackPlayback::mixerProc()
 }
 
 
-void JackPlayback::open(const ALCchar *name)
+void JackPlayback::open(const char *name)
 {
-    if(!name)
-        name = jackDevice;
-    else if(strcmp(name, jackDevice) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+    if(!mClient)
+    {
+        const PathNamePair &binname = GetProcBinary();
+        const char *client_name{binname.fname.empty() ? "alsoft" : binname.fname.c_str()};
+
+        jack_status_t status;
+        mClient = jack_client_open(client_name, ClientOptions, &status, nullptr);
+        if(mClient == nullptr)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to open client connection: 0x%02x", status};
+        if((status&JackServerStarted))
+            TRACE("JACK server started\n");
+        if((status&JackNameNotUnique))
+        {
+            client_name = jack_get_client_name(mClient);
+            TRACE("Client name not unique, got '%s' instead\n", client_name);
+        }
+    }
 
-    const char *client_name{"alsoft"};
-    jack_status_t status;
-    mClient = jack_client_open(client_name, ClientOptions, &status, nullptr);
-    if(mClient == nullptr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Failed to open client connection: 0x%02x",
-            status};
-
-    if((status&JackServerStarted))
-        TRACE("JACK server started\n");
-    if((status&JackNameNotUnique))
+    if(PlaybackList.empty())
+        EnumerateDevices(mClient, PlaybackList);
+
+    if(!name && !PlaybackList.empty())
     {
-        client_name = jack_get_client_name(mClient);
-        TRACE("Client name not unique, got `%s' instead\n", client_name);
+        name = PlaybackList[0].mName.c_str();
+        mPortPattern = PlaybackList[0].mPattern;
+    }
+    else
+    {
+        auto check_name = [name](const DeviceEntry &entry) -> bool
+        { return entry.mName == name; };
+        auto iter = std::find_if(PlaybackList.cbegin(), PlaybackList.cend(), check_name);
+        if(iter == PlaybackList.cend())
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name?name:""};
+        mPortPattern = iter->mPattern;
     }
 
-    jack_set_process_callback(mClient, &JackPlayback::processC, this);
-    jack_set_buffer_size_callback(mClient, &JackPlayback::bufferSizeNotifyC, this);
+    mRTMixing = GetConfigValueBool(name, "jack", "rt-mix", true);
+    jack_set_process_callback(mClient,
+        mRTMixing ? &JackPlayback::processRtC : &JackPlayback::processC, this);
 
     mDevice->DeviceName = name;
 }
 
 bool JackPlayback::reset()
 {
-    std::for_each(std::begin(mPort), std::end(mPort),
-        [this](jack_port_t *port) -> void
-        { if(port) jack_port_unregister(mClient, port); }
-    );
-    std::fill(std::begin(mPort), std::end(mPort), nullptr);
+    auto unregister_port = [this](jack_port_t *port) -> void
+    { if(port) jack_port_unregister(mClient, port); };
+    std::for_each(mPort.begin(), mPort.end(), unregister_port);
+    mPort.fill(nullptr);
 
     /* Ignore the requested buffer metrics and just keep one JACK-sized buffer
      * ready for when requested.
      */
     mDevice->Frequency = jack_get_sample_rate(mClient);
     mDevice->UpdateSize = jack_get_buffer_size(mClient);
-    mDevice->BufferSize = mDevice->UpdateSize * 2;
-
-    const char *devname{mDevice->DeviceName.c_str()};
-    ALuint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
-    bufsize = maxu(NextPowerOf2(bufsize), mDevice->UpdateSize);
-    mDevice->BufferSize = bufsize + mDevice->UpdateSize;
+    if(mRTMixing)
+    {
+        /* Assume only two periods when directly mixing. Should try to query
+         * the total port latency when connected.
+         */
+        mDevice->BufferSize = mDevice->UpdateSize * 2;
+    }
+    else
+    {
+        const char *devname{mDevice->DeviceName.c_str()};
+        uint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
+        bufsize = maxu(NextPowerOf2(bufsize), mDevice->UpdateSize);
+        mDevice->BufferSize = bufsize + mDevice->UpdateSize;
+    }
 
     /* Force 32-bit float output. */
     mDevice->FmtType = DevFmtFloat;
 
-    auto ports_end = std::begin(mPort) + mDevice->channelsFromFmt();
-    auto bad_port = std::find_if_not(std::begin(mPort), ports_end,
-        [this](jack_port_t *&port) -> bool
-        {
-            std::string name{"channel_" + std::to_string(&port - mPort + 1)};
-            port = jack_port_register(mClient, name.c_str(), JACK_DEFAULT_AUDIO_TYPE,
-                JackPortIsOutput, 0);
-            return port != nullptr;
-        }
-    );
+    int port_num{0};
+    auto ports_end = mPort.begin() + mDevice->channelsFromFmt();
+    auto bad_port = mPort.begin();
+    while(bad_port != ports_end)
+    {
+        std::string name{"channel_" + std::to_string(++port_num)};
+        *bad_port = jack_port_register(mClient, name.c_str(), JackDefaultAudioType,
+            JackPortIsOutput | JackPortIsTerminal, 0);
+        if(!*bad_port) break;
+        ++bad_port;
+    }
     if(bad_port != ports_end)
     {
-        ERR("Not enough JACK ports available for %s output\n", DevFmtChannelsString(mDevice->FmtChans));
-        if(bad_port == std::begin(mPort)) return false;
+        ERR("Failed to register enough JACK ports for %s output\n",
+            DevFmtChannelsString(mDevice->FmtChans));
+        if(bad_port == mPort.begin()) return false;
 
-        if(bad_port == std::begin(mPort)+1)
+        if(bad_port == mPort.begin()+1)
             mDevice->FmtChans = DevFmtMono;
         else
         {
-            ports_end = mPort+2;
+            ports_end = mPort.begin()+2;
             while(bad_port != ports_end)
             {
                 jack_port_unregister(mClient, *(--bad_port));
@@ -401,70 +565,87 @@ bool JackPlayback::reset()
         }
     }
 
-    mRing = nullptr;
-    mRing = CreateRingBuffer(bufsize, mDevice->frameSizeFromFmt(), true);
-
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     return true;
 }
 
-bool JackPlayback::start()
+void JackPlayback::start()
 {
     if(jack_activate(mClient))
-    {
-        ERR("Failed to activate client\n");
-        return false;
-    }
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to activate client"};
 
-    const char **ports{jack_get_ports(mClient, nullptr, nullptr,
-        JackPortIsPhysical|JackPortIsInput)};
-    if(ports == nullptr)
+    const char *devname{mDevice->DeviceName.c_str()};
+    if(ConfigValueBool(devname, "jack", "connect-ports").value_or(true))
     {
-        ERR("No physical playback ports found\n");
-        jack_deactivate(mClient);
-        return false;
-    }
-    std::mismatch(std::begin(mPort), std::end(mPort), ports,
-        [this](const jack_port_t *port, const char *pname) -> bool
+        JackPortsPtr pnames{jack_get_ports(mClient, mPortPattern.c_str(), JackDefaultAudioType,
+            JackPortIsInput)};
+        if(!pnames)
         {
-            if(!port) return false;
-            if(!pname)
+            jack_deactivate(mClient);
+            throw al::backend_exception{al::backend_error::DeviceError, "No playback ports found"};
+        }
+
+        for(size_t i{0};i < al::size(mPort) && mPort[i];++i)
+        {
+            if(!pnames[i])
             {
-                ERR("No physical playback port for \"%s\"\n", jack_port_name(port));
-                return false;
+                ERR("No physical playback port for \"%s\"\n", jack_port_name(mPort[i]));
+                break;
             }
-            if(jack_connect(mClient, jack_port_name(port), pname))
-                ERR("Failed to connect output port \"%s\" to \"%s\"\n", jack_port_name(port),
-                    pname);
-            return true;
+            if(jack_connect(mClient, jack_port_name(mPort[i]), pnames[i]))
+                ERR("Failed to connect output port \"%s\" to \"%s\"\n", jack_port_name(mPort[i]),
+                    pnames[i]);
         }
-    );
-    jack_free(ports);
-
-    try {
-        mKillNow.store(false, std::memory_order_release);
-        mThread = std::thread{std::mem_fn(&JackPlayback::mixerProc), this};
-        return true;
     }
-    catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
-    }
-    catch(...) {
+
+    /* Reconfigure buffer metrics in case the server changed it since the reset
+     * (it won't change again after jack_activate), then allocate the ring
+     * buffer with the appropriate size.
+     */
+    mDevice->Frequency = jack_get_sample_rate(mClient);
+    mDevice->UpdateSize = jack_get_buffer_size(mClient);
+    mDevice->BufferSize = mDevice->UpdateSize * 2;
+
+    mRing = nullptr;
+    if(mRTMixing)
+        mPlaying.store(true, std::memory_order_release);
+    else
+    {
+        uint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
+        bufsize = maxu(NextPowerOf2(bufsize), mDevice->UpdateSize);
+        mDevice->BufferSize = bufsize + mDevice->UpdateSize;
+
+        mRing = RingBuffer::Create(bufsize, mDevice->frameSizeFromFmt(), true);
+
+        try {
+            mPlaying.store(true, std::memory_order_release);
+            mKillNow.store(false, std::memory_order_release);
+            mThread = std::thread{std::mem_fn(&JackPlayback::mixerProc), this};
+        }
+        catch(std::exception& e) {
+            jack_deactivate(mClient);
+            mPlaying.store(false, std::memory_order_release);
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to start mixing thread: %s", e.what()};
+        }
     }
-    jack_deactivate(mClient);
-    return false;
 }
 
 void JackPlayback::stop()
 {
-    if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
-        return;
-
-    mSem.post();
-    mThread.join();
+    if(mPlaying.load(std::memory_order_acquire))
+    {
+        mKillNow.store(true, std::memory_order_release);
+        if(mThread.joinable())
+        {
+            mSem.post();
+            mThread.join();
+        }
 
-    jack_deactivate(mClient);
+        jack_deactivate(mClient);
+        mPlaying.store(false, std::memory_order_release);
+    }
 }
 
 
@@ -472,9 +653,9 @@ ClockLatency JackPlayback::getClockLatency()
 {
     ClockLatency ret;
 
-    std::lock_guard<JackPlayback> _{*this};
+    std::lock_guard<std::mutex> _{mMutex};
     ret.ClockTime = GetDeviceClockTime(mDevice);
-    ret.Latency  = std::chrono::seconds{mRing->readSpace()};
+    ret.Latency  = std::chrono::seconds{mRing ? mRing->readSpace() : mDevice->UpdateSize};
     ret.Latency /= mDevice->Frequency;
 
     return ret;
@@ -493,13 +674,16 @@ bool JackBackendFactory::init()
     if(!jack_load())
         return false;
 
-    if(!GetConfigValueBool(nullptr, "jack", "spawn-server", 0))
+    if(!GetConfigValueBool(nullptr, "jack", "spawn-server", false))
         ClientOptions = static_cast<jack_options_t>(ClientOptions | JackNoStartServer);
 
+    const PathNamePair &binname = GetProcBinary();
+    const char *client_name{binname.fname.empty() ? "alsoft" : binname.fname.c_str()};
+
     void (*old_error_cb)(const char*){&jack_error_callback ? jack_error_callback : nullptr};
     jack_set_error_function(jack_msg_handler);
     jack_status_t status;
-    jack_client_t *client{jack_client_open("alsoft", ClientOptions, &status, nullptr)};
+    jack_client_t *client{jack_client_open(client_name, ClientOptions, &status, nullptr)};
     jack_set_error_function(old_error_cb);
     if(!client)
     {
@@ -516,21 +700,37 @@ bool JackBackendFactory::init()
 bool JackBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback); }
 
-void JackBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string JackBackendFactory::probe(BackendType type)
 {
-    switch(type)
+    std::string outnames;
+    auto append_name = [&outnames](const DeviceEntry &entry) -> void
     {
-        case DevProbe::Playback:
-            /* Includes null char. */
-            outnames->append(jackDevice, sizeof(jackDevice));
-            break;
+        /* Includes null char. */
+        outnames.append(entry.mName.c_str(), entry.mName.length()+1);
+    };
 
-        case DevProbe::Capture:
-            break;
+    const PathNamePair &binname = GetProcBinary();
+    const char *client_name{binname.fname.empty() ? "alsoft" : binname.fname.c_str()};
+    jack_status_t status;
+    switch(type)
+    {
+    case BackendType::Playback:
+        if(jack_client_t *client{jack_client_open(client_name, ClientOptions, &status, nullptr)})
+        {
+            EnumerateDevices(client, PlaybackList);
+            jack_client_close(client);
+        }
+        else
+            WARN("jack_client_open() failed, 0x%02x\n", status);
+        std::for_each(PlaybackList.cbegin(), PlaybackList.cend(), append_name);
+        break;
+    case BackendType::Capture:
+        break;
     }
+    return outnames;
 }
 
-BackendPtr JackBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr JackBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new JackPlayback{device}};
diff --git a/alc/backends/jack.h b/alc/backends/jack.h
index 10beebfb..b83f24dd 100644
--- a/alc/backends/jack.h
+++ b/alc/backends/jack.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_JACK_H
 #define BACKENDS_JACK_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct JackBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/loopback.cpp b/alc/backends/loopback.cpp
index 511061f3..bf4ab246 100644
--- a/alc/backends/loopback.cpp
+++ b/alc/backends/loopback.cpp
@@ -20,39 +20,38 @@
 
 #include "config.h"
 
-#include "backends/loopback.h"
+#include "loopback.h"
 
-#include "alcmain.h"
-#include "alu.h"
+#include "core/device.h"
 
 
 namespace {
 
 struct LoopbackBackend final : public BackendBase {
-    LoopbackBackend(ALCdevice *device) noexcept : BackendBase{device} { }
+    LoopbackBackend(DeviceBase *device) noexcept : BackendBase{device} { }
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     DEF_NEWDEL(LoopbackBackend)
 };
 
 
-void LoopbackBackend::open(const ALCchar *name)
+void LoopbackBackend::open(const char *name)
 {
     mDevice->DeviceName = name;
 }
 
 bool LoopbackBackend::reset()
 {
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
     return true;
 }
 
-bool LoopbackBackend::start()
-{ return true; }
+void LoopbackBackend::start()
+{ }
 
 void LoopbackBackend::stop()
 { }
@@ -66,10 +65,10 @@ bool LoopbackBackendFactory::init()
 bool LoopbackBackendFactory::querySupport(BackendType)
 { return true; }
 
-void LoopbackBackendFactory::probe(DevProbe, std::string*)
-{ }
+std::string LoopbackBackendFactory::probe(BackendType)
+{ return std::string{}; }
 
-BackendPtr LoopbackBackendFactory::createBackend(ALCdevice *device, BackendType)
+BackendPtr LoopbackBackendFactory::createBackend(DeviceBase *device, BackendType)
 { return BackendPtr{new LoopbackBackend{device}}; }
 
 BackendFactory &LoopbackBackendFactory::getFactory()
diff --git a/alc/backends/loopback.h b/alc/backends/loopback.h
index 09c085b8..cb42b3c8 100644
--- a/alc/backends/loopback.h
+++ b/alc/backends/loopback.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_LOOPBACK_H
 #define BACKENDS_LOOPBACK_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct LoopbackBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/null.cpp b/alc/backends/null.cpp
index bc2a0c9c..5a8fc255 100644
--- a/alc/backends/null.cpp
+++ b/alc/backends/null.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/null.h"
+#include "null.h"
 
 #include <exception>
 #include <atomic>
@@ -30,11 +30,9 @@
 #include <functional>
 #include <thread>
 
-#include "alcmain.h"
-#include "alexcpt.h"
+#include "core/device.h"
 #include "almalloc.h"
-#include "alu.h"
-#include "logging.h"
+#include "core/helpers.h"
 #include "threads.h"
 
 
@@ -44,17 +42,17 @@ using std::chrono::seconds;
 using std::chrono::milliseconds;
 using std::chrono::nanoseconds;
 
-constexpr ALCchar nullDevice[] = "No Output";
+constexpr char nullDevice[] = "No Output";
 
 
 struct NullBackend final : public BackendBase {
-    NullBackend(ALCdevice *device) noexcept : BackendBase{device} { }
+    NullBackend(DeviceBase *device) noexcept : BackendBase{device} { }
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     std::atomic<bool> mKillNow{true};
@@ -72,8 +70,8 @@ int NullBackend::mixerProc()
 
     int64_t done{0};
     auto start = std::chrono::steady_clock::now();
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         auto now = std::chrono::steady_clock::now();
 
@@ -86,8 +84,7 @@ int NullBackend::mixerProc()
         }
         while(avail-done >= mDevice->UpdateSize)
         {
-            std::lock_guard<NullBackend> _{*this};
-            aluMixData(mDevice, nullptr, mDevice->UpdateSize);
+            mDevice->renderSamples(nullptr, mDevice->UpdateSize, 0u);
             done += mDevice->UpdateSize;
         }
 
@@ -108,35 +105,33 @@ int NullBackend::mixerProc()
 }
 
 
-void NullBackend::open(const ALCchar *name)
+void NullBackend::open(const char *name)
 {
     if(!name)
         name = nullDevice;
     else if(strcmp(name, nullDevice) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
     mDevice->DeviceName = name;
 }
 
 bool NullBackend::reset()
 {
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
     return true;
 }
 
-bool NullBackend::start()
+void NullBackend::start()
 {
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&NullBackend::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Failed to start mixing thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    return false;
 }
 
 void NullBackend::stop()
@@ -155,20 +150,22 @@ bool NullBackendFactory::init()
 bool NullBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback); }
 
-void NullBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string NullBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-            /* Includes null char. */
-            outnames->append(nullDevice, sizeof(nullDevice));
-            break;
-        case DevProbe::Capture:
-            break;
+    case BackendType::Playback:
+        /* Includes null char. */
+        outnames.append(nullDevice, sizeof(nullDevice));
+        break;
+    case BackendType::Capture:
+        break;
     }
+    return outnames;
 }
 
-BackendPtr NullBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr NullBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new NullBackend{device}};
diff --git a/alc/backends/null.h b/alc/backends/null.h
index f19d5b4d..7048cad6 100644
--- a/alc/backends/null.h
+++ b/alc/backends/null.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_NULL_H
 #define BACKENDS_NULL_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct NullBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/oboe.cpp b/alc/backends/oboe.cpp
new file mode 100644
index 00000000..461f5a6a
--- /dev/null
+++ b/alc/backends/oboe.cpp
@@ -0,0 +1,360 @@
+
+#include "config.h"
+
+#include "oboe.h"
+
+#include <cassert>
+#include <cstring>
+#include <stdint.h>
+
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/logging.h"
+#include "ringbuffer.h"
+
+#include "oboe/Oboe.h"
+
+
+namespace {
+
+constexpr char device_name[] = "Oboe Default";
+
+
+struct OboePlayback final : public BackendBase, public oboe::AudioStreamCallback {
+    OboePlayback(DeviceBase *device) : BackendBase{device} { }
+
+    oboe::ManagedStream mStream;
+
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream *oboeStream, void *audioData,
+        int32_t numFrames) override;
+
+    void open(const char *name) override;
+    bool reset() override;
+    void start() override;
+    void stop() override;
+};
+
+
+oboe::DataCallbackResult OboePlayback::onAudioReady(oboe::AudioStream *oboeStream, void *audioData,
+    int32_t numFrames)
+{
+    assert(numFrames > 0);
+    const int32_t numChannels{oboeStream->getChannelCount()};
+
+    mDevice->renderSamples(audioData, static_cast<uint32_t>(numFrames),
+        static_cast<uint32_t>(numChannels));
+    return oboe::DataCallbackResult::Continue;
+}
+
+
+void OboePlayback::open(const char *name)
+{
+    if(!name)
+        name = device_name;
+    else if(std::strcmp(name, device_name) != 0)
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+
+    /* Open a basic output stream, just to ensure it can work. */
+    oboe::ManagedStream stream;
+    oboe::Result result{oboe::AudioStreamBuilder{}.setDirection(oboe::Direction::Output)
+        ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+        ->openManagedStream(stream)};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to create stream: %s",
+            oboe::convertToText(result)};
+
+    mDevice->DeviceName = name;
+}
+
+bool OboePlayback::reset()
+{
+    oboe::AudioStreamBuilder builder;
+    builder.setDirection(oboe::Direction::Output);
+    builder.setPerformanceMode(oboe::PerformanceMode::LowLatency);
+    /* Don't let Oboe convert. We should be able to handle anything it gives
+     * back.
+     */
+    builder.setSampleRateConversionQuality(oboe::SampleRateConversionQuality::None);
+    builder.setChannelConversionAllowed(false);
+    builder.setFormatConversionAllowed(false);
+    builder.setCallback(this);
+
+    if(mDevice->Flags.test(FrequencyRequest))
+    {
+        builder.setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High);
+        builder.setSampleRate(static_cast<int32_t>(mDevice->Frequency));
+    }
+    if(mDevice->Flags.test(ChannelsRequest))
+    {
+        /* Only use mono or stereo at user request. There's no telling what
+         * other counts may be inferred as.
+         */
+        builder.setChannelCount((mDevice->FmtChans==DevFmtMono) ? oboe::ChannelCount::Mono
+            : (mDevice->FmtChans==DevFmtStereo) ? oboe::ChannelCount::Stereo
+            : oboe::ChannelCount::Unspecified);
+    }
+    if(mDevice->Flags.test(SampleTypeRequest))
+    {
+        oboe::AudioFormat format{oboe::AudioFormat::Unspecified};
+        switch(mDevice->FmtType)
+        {
+        case DevFmtByte:
+        case DevFmtUByte:
+        case DevFmtShort:
+        case DevFmtUShort:
+            format = oboe::AudioFormat::I16;
+            break;
+        case DevFmtInt:
+        case DevFmtUInt:
+#if OBOE_VERSION_MAJOR > 1 || (OBOE_VERSION_MAJOR == 1 && OBOE_VERSION_MINOR >= 6)
+            format = oboe::AudioFormat::I32;
+            break;
+#endif
+        case DevFmtFloat:
+            format = oboe::AudioFormat::Float;
+            break;
+        }
+        builder.setFormat(format);
+    }
+
+    oboe::Result result{builder.openManagedStream(mStream)};
+    /* If the format failed, try asking for the defaults. */
+    while(result == oboe::Result::ErrorInvalidFormat)
+    {
+        if(builder.getFormat() != oboe::AudioFormat::Unspecified)
+            builder.setFormat(oboe::AudioFormat::Unspecified);
+        else if(builder.getSampleRate() != oboe::kUnspecified)
+            builder.setSampleRate(oboe::kUnspecified);
+        else if(builder.getChannelCount() != oboe::ChannelCount::Unspecified)
+            builder.setChannelCount(oboe::ChannelCount::Unspecified);
+        else
+            break;
+        result = builder.openManagedStream(mStream);
+    }
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to create stream: %s",
+            oboe::convertToText(result)};
+    mStream->setBufferSizeInFrames(mini(static_cast<int32_t>(mDevice->BufferSize),
+        mStream->getBufferCapacityInFrames()));
+    TRACE("Got stream with properties:\n%s", oboe::convertToText(mStream.get()));
+
+    if(static_cast<uint>(mStream->getChannelCount()) != mDevice->channelsFromFmt())
+    {
+        if(mStream->getChannelCount() >= 2)
+            mDevice->FmtChans = DevFmtStereo;
+        else if(mStream->getChannelCount() == 1)
+            mDevice->FmtChans = DevFmtMono;
+        else
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Got unhandled channel count: %d", mStream->getChannelCount()};
+    }
+    setDefaultWFXChannelOrder();
+
+    switch(mStream->getFormat())
+    {
+    case oboe::AudioFormat::I16:
+        mDevice->FmtType = DevFmtShort;
+        break;
+    case oboe::AudioFormat::Float:
+        mDevice->FmtType = DevFmtFloat;
+        break;
+#if OBOE_VERSION_MAJOR > 1 || (OBOE_VERSION_MAJOR == 1 && OBOE_VERSION_MINOR >= 6)
+    case oboe::AudioFormat::I32:
+        mDevice->FmtType = DevFmtInt;
+        break;
+    case oboe::AudioFormat::I24:
+#endif
+    case oboe::AudioFormat::Unspecified:
+    case oboe::AudioFormat::Invalid:
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Got unhandled sample type: %s", oboe::convertToText(mStream->getFormat())};
+    }
+    mDevice->Frequency = static_cast<uint32_t>(mStream->getSampleRate());
+
+    /* Ensure the period size is no less than 10ms. It's possible for FramesPerCallback to be 0
+     * indicating variable updates, but OpenAL should have a reasonable minimum update size set.
+     * FramesPerBurst may not necessarily be correct, but hopefully it can act as a minimum
+     * update size.
+     */
+    mDevice->UpdateSize = maxu(mDevice->Frequency / 100,
+        static_cast<uint32_t>(mStream->getFramesPerBurst()));
+    mDevice->BufferSize = maxu(mDevice->UpdateSize * 2,
+        static_cast<uint32_t>(mStream->getBufferSizeInFrames()));
+
+    return true;
+}
+
+void OboePlayback::start()
+{
+    const oboe::Result result{mStream->start()};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to start stream: %s",
+            oboe::convertToText(result)};
+}
+
+void OboePlayback::stop()
+{
+    oboe::Result result{mStream->stop()};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to stop stream: %s",
+            oboe::convertToText(result)};
+}
+
+
+struct OboeCapture final : public BackendBase, public oboe::AudioStreamCallback {
+    OboeCapture(DeviceBase *device) : BackendBase{device} { }
+
+    oboe::ManagedStream mStream;
+
+    RingBufferPtr mRing{nullptr};
+
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream *oboeStream, void *audioData,
+        int32_t numFrames) override;
+
+    void open(const char *name) override;
+    void start() override;
+    void stop() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
+};
+
+oboe::DataCallbackResult OboeCapture::onAudioReady(oboe::AudioStream*, void *audioData,
+    int32_t numFrames)
+{
+    mRing->write(audioData, static_cast<uint32_t>(numFrames));
+    return oboe::DataCallbackResult::Continue;
+}
+
+
+void OboeCapture::open(const char *name)
+{
+    if(!name)
+        name = device_name;
+    else if(std::strcmp(name, device_name) != 0)
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+
+    oboe::AudioStreamBuilder builder;
+    builder.setDirection(oboe::Direction::Input)
+        ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+        ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
+        ->setChannelConversionAllowed(true)
+        ->setFormatConversionAllowed(true)
+        ->setSampleRate(static_cast<int32_t>(mDevice->Frequency))
+        ->setCallback(this);
+    /* Only use mono or stereo at user request. There's no telling what
+     * other counts may be inferred as.
+     */
+    switch(mDevice->FmtChans)
+    {
+    case DevFmtMono:
+        builder.setChannelCount(oboe::ChannelCount::Mono);
+        break;
+    case DevFmtStereo:
+        builder.setChannelCount(oboe::ChannelCount::Stereo);
+        break;
+    case DevFmtQuad:
+    case DevFmtX51:
+    case DevFmtX61:
+    case DevFmtX71:
+    case DevFmtX714:
+    case DevFmtX3D71:
+    case DevFmtAmbi3D:
+        throw al::backend_exception{al::backend_error::DeviceError, "%s capture not supported",
+            DevFmtChannelsString(mDevice->FmtChans)};
+    }
+
+    /* FIXME: This really should support UByte, but Oboe doesn't. We'll need to
+     * convert.
+     */
+    switch(mDevice->FmtType)
+    {
+    case DevFmtShort:
+        builder.setFormat(oboe::AudioFormat::I16);
+        break;
+    case DevFmtFloat:
+        builder.setFormat(oboe::AudioFormat::Float);
+        break;
+    case DevFmtInt:
+#if OBOE_VERSION_MAJOR > 1 || (OBOE_VERSION_MAJOR == 1 && OBOE_VERSION_MINOR >= 6)
+        builder.setFormat(oboe::AudioFormat::I32);
+        break;
+#endif
+    case DevFmtByte:
+    case DevFmtUByte:
+    case DevFmtUShort:
+    case DevFmtUInt:
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
+    }
+
+    oboe::Result result{builder.openManagedStream(mStream)};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to create stream: %s",
+            oboe::convertToText(result)};
+
+    TRACE("Got stream with properties:\n%s", oboe::convertToText(mStream.get()));
+
+    /* Ensure a minimum ringbuffer size of 100ms. */
+    mRing = RingBuffer::Create(maxu(mDevice->BufferSize, mDevice->Frequency/10),
+        static_cast<uint32_t>(mStream->getBytesPerFrame()), false);
+
+    mDevice->DeviceName = name;
+}
+
+void OboeCapture::start()
+{
+    const oboe::Result result{mStream->start()};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to start stream: %s",
+            oboe::convertToText(result)};
+}
+
+void OboeCapture::stop()
+{
+    const oboe::Result result{mStream->stop()};
+    if(result != oboe::Result::OK)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to stop stream: %s",
+            oboe::convertToText(result)};
+}
+
+uint OboeCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
+
+void OboeCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
+
+} // namespace
+
+bool OboeBackendFactory::init() { return true; }
+
+bool OboeBackendFactory::querySupport(BackendType type)
+{ return type == BackendType::Playback || type == BackendType::Capture; }
+
+std::string OboeBackendFactory::probe(BackendType type)
+{
+    switch(type)
+    {
+    case BackendType::Playback:
+    case BackendType::Capture:
+        /* Includes null char. */
+        return std::string{device_name, sizeof(device_name)};
+    }
+    return std::string{};
+}
+
+BackendPtr OboeBackendFactory::createBackend(DeviceBase *device, BackendType type)
+{
+    if(type == BackendType::Playback)
+        return BackendPtr{new OboePlayback{device}};
+    if(type == BackendType::Capture)
+        return BackendPtr{new OboeCapture{device}};
+    return BackendPtr{};
+}
+
+BackendFactory &OboeBackendFactory::getFactory()
+{
+    static OboeBackendFactory factory{};
+    return factory;
+}
diff --git a/alc/backends/oboe.h b/alc/backends/oboe.h
new file mode 100644
index 00000000..a39c2445
--- /dev/null
+++ b/alc/backends/oboe.h
@@ -0,0 +1,19 @@
+#ifndef BACKENDS_OBOE_H
+#define BACKENDS_OBOE_H
+
+#include "base.h"
+
+struct OboeBackendFactory final : public BackendFactory {
+public:
+    bool init() override;
+
+    bool querySupport(BackendType type) override;
+
+    std::string probe(BackendType type) override;
+
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
+
+    static BackendFactory &getFactory();
+};
+
+#endif /* BACKENDS_OBOE_H */
diff --git a/alc/backends/opensl.cpp b/alc/backends/opensl.cpp
index a1fdccc7..f5b98fb8 100644
--- a/alc/backends/opensl.cpp
+++ b/alc/backends/opensl.cpp
@@ -21,7 +21,7 @@
 
 #include "config.h"
 
-#include "backends/opensl.h"
+#include "opensl.h"
 
 #include <stdlib.h>
 #include <jni.h>
@@ -32,11 +32,12 @@
 #include <thread>
 #include <functional>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
-#include "compat.h"
-#include "endiantest.h"
+#include "albit.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
+#include "opthelpers.h"
 #include "ringbuffer.h"
 #include "threads.h"
 
@@ -53,10 +54,10 @@ namespace {
 #define VCALL0(obj, func)  ((*(obj))->func((obj) EXTRACT_VCALL_ARGS
 
 
-constexpr ALCchar opensl_device[] = "OpenSL";
+constexpr char opensl_device[] = "OpenSL";
 
 
-SLuint32 GetChannelMask(DevFmtChannels chans)
+constexpr SLuint32 GetChannelMask(DevFmtChannels chans) noexcept
 {
     switch(chans)
     {
@@ -67,15 +68,18 @@ SLuint32 GetChannelMask(DevFmtChannels chans)
     case DevFmtX51: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
         SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY | SL_SPEAKER_SIDE_LEFT |
         SL_SPEAKER_SIDE_RIGHT;
-    case DevFmtX51Rear: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
-        SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY | SL_SPEAKER_BACK_LEFT |
-        SL_SPEAKER_BACK_RIGHT;
     case DevFmtX61: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
         SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY | SL_SPEAKER_BACK_CENTER |
         SL_SPEAKER_SIDE_LEFT | SL_SPEAKER_SIDE_RIGHT;
-    case DevFmtX71: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
+    case DevFmtX71:
+    case DevFmtX3D71: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
         SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY | SL_SPEAKER_BACK_LEFT |
         SL_SPEAKER_BACK_RIGHT | SL_SPEAKER_SIDE_LEFT | SL_SPEAKER_SIDE_RIGHT;
+    case DevFmtX714: return SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
+        SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY | SL_SPEAKER_BACK_LEFT |
+        SL_SPEAKER_BACK_RIGHT | SL_SPEAKER_SIDE_LEFT | SL_SPEAKER_SIDE_RIGHT |
+        SL_SPEAKER_TOP_FRONT_LEFT | SL_SPEAKER_TOP_FRONT_RIGHT | SL_SPEAKER_TOP_BACK_LEFT |
+        SL_SPEAKER_TOP_BACK_RIGHT;
     case DevFmtAmbi3D:
         break;
     }
@@ -83,7 +87,7 @@ SLuint32 GetChannelMask(DevFmtChannels chans)
 }
 
 #ifdef SL_ANDROID_DATAFORMAT_PCM_EX
-SLuint32 GetTypeRepresentation(DevFmtType type)
+constexpr SLuint32 GetTypeRepresentation(DevFmtType type) noexcept
 {
     switch(type)
     {
@@ -102,7 +106,14 @@ SLuint32 GetTypeRepresentation(DevFmtType type)
 }
 #endif
 
-const char *res_str(SLresult result)
+constexpr SLuint32 GetByteOrderEndianness() noexcept
+{
+    if(al::endian::native == al::endian::little)
+        return SL_BYTEORDER_LITTLEENDIAN;
+    return SL_BYTEORDER_BIGENDIAN;
+}
+
+constexpr const char *res_str(SLresult result) noexcept
 {
     switch(result)
     {
@@ -136,14 +147,15 @@ const char *res_str(SLresult result)
     return "Unknown error code";
 }
 
-#define PRINTERR(x, s) do {                                                      \
-    if UNLIKELY((x) != SL_RESULT_SUCCESS)                                        \
-        ERR("%s: %s\n", (s), res_str((x)));                                      \
-} while(0)
+inline void PrintErr(SLresult res, const char *str)
+{
+    if(res != SL_RESULT_SUCCESS) UNLIKELY
+        ERR("%s: %s\n", str, res_str(res));
+}
 
 
 struct OpenSLPlayback final : public BackendBase {
-    OpenSLPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    OpenSLPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~OpenSLPlayback() override;
 
     void process(SLAndroidSimpleBufferQueueItf bq) noexcept;
@@ -152,9 +164,9 @@ struct OpenSLPlayback final : public BackendBase {
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
     ClockLatency getClockLatency() override;
 
@@ -171,7 +183,9 @@ struct OpenSLPlayback final : public BackendBase {
     RingBufferPtr mRing{nullptr};
     al::semaphore mSem;
 
-    ALuint mFrameSize{0};
+    std::mutex mMutex;
+
+    uint mFrameSize{0};
 
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
@@ -221,55 +235,56 @@ int OpenSLPlayback::mixerProc()
     SLAndroidSimpleBufferQueueItf bufferQueue;
     SLresult result{VCALL(mBufferQueueObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
         &bufferQueue)};
-    PRINTERR(result, "bufferQueue->GetInterface SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
+    PrintErr(result, "bufferQueue->GetInterface SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mBufferQueueObj,GetInterface)(SL_IID_PLAY, &player);
-        PRINTERR(result, "bufferQueue->GetInterface SL_IID_PLAY");
+        PrintErr(result, "bufferQueue->GetInterface SL_IID_PLAY");
     }
 
-    std::unique_lock<OpenSLPlayback> dlock{*this};
+    const size_t frame_step{mDevice->channelsFromFmt()};
+
     if(SL_RESULT_SUCCESS != result)
-        aluHandleDisconnect(mDevice, "Failed to get playback buffer: 0x%08x", result);
+        mDevice->handleDisconnect("Failed to get playback buffer: 0x%08x", result);
 
-    while(SL_RESULT_SUCCESS == result && !mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(SL_RESULT_SUCCESS == result && !mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         if(mRing->writeSpace() == 0)
         {
             SLuint32 state{0};
 
             result = VCALL(player,GetPlayState)(&state);
-            PRINTERR(result, "player->GetPlayState");
+            PrintErr(result, "player->GetPlayState");
             if(SL_RESULT_SUCCESS == result && state != SL_PLAYSTATE_PLAYING)
             {
                 result = VCALL(player,SetPlayState)(SL_PLAYSTATE_PLAYING);
-                PRINTERR(result, "player->SetPlayState");
+                PrintErr(result, "player->SetPlayState");
             }
             if(SL_RESULT_SUCCESS != result)
             {
-                aluHandleDisconnect(mDevice, "Failed to start platback: 0x%08x", result);
+                mDevice->handleDisconnect("Failed to start playback: 0x%08x", result);
                 break;
             }
 
             if(mRing->writeSpace() == 0)
             {
-                dlock.unlock();
                 mSem.wait();
-                dlock.lock();
                 continue;
             }
         }
 
+        std::unique_lock<std::mutex> dlock{mMutex};
         auto data = mRing->getWriteVector();
-        aluMixData(mDevice, data.first.buf,
-            static_cast<ALuint>(data.first.len*mDevice->UpdateSize));
+        mDevice->renderSamples(data.first.buf,
+            static_cast<uint>(data.first.len)*mDevice->UpdateSize, frame_step);
         if(data.second.len > 0)
-            aluMixData(mDevice, data.second.buf,
-                static_cast<ALuint>(data.second.len*mDevice->UpdateSize));
+            mDevice->renderSamples(data.second.buf,
+                static_cast<uint>(data.second.len)*mDevice->UpdateSize, frame_step);
 
         size_t todo{data.first.len + data.second.len};
         mRing->writeAdvance(todo);
+        dlock.unlock();
 
         for(size_t i{0};i < todo;i++)
         {
@@ -281,10 +296,10 @@ int OpenSLPlayback::mixerProc()
             }
 
             result = VCALL(bufferQueue,Enqueue)(data.first.buf, mDevice->UpdateSize*mFrameSize);
-            PRINTERR(result, "bufferQueue->Enqueue");
+            PrintErr(result, "bufferQueue->Enqueue");
             if(SL_RESULT_SUCCESS != result)
             {
-                aluHandleDisconnect(mDevice, "Failed to queue audio: 0x%08x", result);
+                mDevice->handleDisconnect("Failed to queue audio: 0x%08x", result);
                 break;
             }
 
@@ -297,35 +312,39 @@ int OpenSLPlayback::mixerProc()
 }
 
 
-void OpenSLPlayback::open(const ALCchar *name)
+void OpenSLPlayback::open(const char *name)
 {
     if(!name)
         name = opensl_device;
     else if(strcmp(name, opensl_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+
+    /* There's only one device, so if it's already open, there's nothing to do. */
+    if(mEngineObj) return;
 
     // create engine
     SLresult result{slCreateEngine(&mEngineObj, 0, nullptr, 0, nullptr, nullptr)};
-    PRINTERR(result, "slCreateEngine");
+    PrintErr(result, "slCreateEngine");
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mEngineObj,Realize)(SL_BOOLEAN_FALSE);
-        PRINTERR(result, "engine->Realize");
+        PrintErr(result, "engine->Realize");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mEngineObj,GetInterface)(SL_IID_ENGINE, &mEngine);
-        PRINTERR(result, "engine->GetInterface");
+        PrintErr(result, "engine->GetInterface");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mEngine,CreateOutputMix)(&mOutputMix, 0, nullptr, nullptr);
-        PRINTERR(result, "engine->CreateOutputMix");
+        PrintErr(result, "engine->CreateOutputMix");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mOutputMix,Realize)(SL_BOOLEAN_FALSE);
-        PRINTERR(result, "outputMix->Realize");
+        PrintErr(result, "outputMix->Realize");
     }
 
     if(SL_RESULT_SUCCESS != result)
@@ -339,7 +358,7 @@ void OpenSLPlayback::open(const ALCchar *name)
         mEngineObj = nullptr;
         mEngine = nullptr;
 
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Failed to initialize OpenSL device: 0x%08x", result};
     }
 
@@ -427,7 +446,7 @@ bool OpenSLPlayback::reset()
     mDevice->FmtChans = DevFmtStereo;
     mDevice->FmtType = DevFmtShort;
 
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
     mFrameSize = mDevice->frameSizeFromFmt();
 
 
@@ -455,7 +474,7 @@ bool OpenSLPlayback::reset()
     format_pcm_ex.bitsPerSample = mDevice->bytesFromFmt() * 8;
     format_pcm_ex.containerSize = format_pcm_ex.bitsPerSample;
     format_pcm_ex.channelMask = GetChannelMask(mDevice->FmtChans);
-    format_pcm_ex.endianness = IS_LITTLE_ENDIAN ? SL_BYTEORDER_LITTLEENDIAN : SL_BYTEORDER_BIGENDIAN;
+    format_pcm_ex.endianness = GetByteOrderEndianness();
     format_pcm_ex.representation = GetTypeRepresentation(mDevice->FmtType);
 
     audioSrc.pLocator = &loc_bufq;
@@ -486,28 +505,27 @@ bool OpenSLPlayback::reset()
         format_pcm.bitsPerSample = mDevice->bytesFromFmt() * 8;
         format_pcm.containerSize = format_pcm.bitsPerSample;
         format_pcm.channelMask = GetChannelMask(mDevice->FmtChans);
-        format_pcm.endianness = IS_LITTLE_ENDIAN ? SL_BYTEORDER_LITTLEENDIAN :
-            SL_BYTEORDER_BIGENDIAN;
+        format_pcm.endianness = GetByteOrderEndianness();
 
         audioSrc.pLocator = &loc_bufq;
         audioSrc.pFormat = &format_pcm;
 
         result = VCALL(mEngine,CreateAudioPlayer)(&mBufferQueueObj, &audioSrc, &audioSnk, ids.size(),
             ids.data(), reqs.data());
-        PRINTERR(result, "engine->CreateAudioPlayer");
+        PrintErr(result, "engine->CreateAudioPlayer");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         /* Set the stream type to "media" (games, music, etc), if possible. */
         SLAndroidConfigurationItf config;
         result = VCALL(mBufferQueueObj,GetInterface)(SL_IID_ANDROIDCONFIGURATION, &config);
-        PRINTERR(result, "bufferQueue->GetInterface SL_IID_ANDROIDCONFIGURATION");
+        PrintErr(result, "bufferQueue->GetInterface SL_IID_ANDROIDCONFIGURATION");
         if(SL_RESULT_SUCCESS == result)
         {
             SLint32 streamType = SL_ANDROID_STREAM_MEDIA;
             result = VCALL(config,SetConfiguration)(SL_ANDROID_KEY_STREAM_TYPE, &streamType,
                 sizeof(streamType));
-            PRINTERR(result, "config->SetConfiguration");
+            PrintErr(result, "config->SetConfiguration");
         }
 
         /* Clear any error since this was optional. */
@@ -516,12 +534,12 @@ bool OpenSLPlayback::reset()
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mBufferQueueObj,Realize)(SL_BOOLEAN_FALSE);
-        PRINTERR(result, "bufferQueue->Realize");
+        PrintErr(result, "bufferQueue->Realize");
     }
     if(SL_RESULT_SUCCESS == result)
     {
-        const ALuint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
-        mRing = CreateRingBuffer(num_updates, mFrameSize*mDevice->UpdateSize, true);
+        const uint num_updates{mDevice->BufferSize / mDevice->UpdateSize};
+        mRing = RingBuffer::Create(num_updates, mFrameSize*mDevice->UpdateSize, true);
     }
 
     if(SL_RESULT_SUCCESS != result)
@@ -536,32 +554,31 @@ bool OpenSLPlayback::reset()
     return true;
 }
 
-bool OpenSLPlayback::start()
+void OpenSLPlayback::start()
 {
     mRing->reset();
 
     SLAndroidSimpleBufferQueueItf bufferQueue;
     SLresult result{VCALL(mBufferQueueObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
         &bufferQueue)};
-    PRINTERR(result, "bufferQueue->GetInterface");
+    PrintErr(result, "bufferQueue->GetInterface");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(bufferQueue,RegisterCallback)(&OpenSLPlayback::processC, this);
+        PrintErr(result, "bufferQueue->RegisterCallback");
+    }
     if(SL_RESULT_SUCCESS != result)
-        return false;
-
-    result = VCALL(bufferQueue,RegisterCallback)(&OpenSLPlayback::processC, this);
-    PRINTERR(result, "bufferQueue->RegisterCallback");
-    if(SL_RESULT_SUCCESS != result) return false;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to register callback: 0x%08x", result};
 
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread(std::mem_fn(&OpenSLPlayback::mixerProc), this);
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    return false;
 }
 
 void OpenSLPlayback::stop()
@@ -574,25 +591,25 @@ void OpenSLPlayback::stop()
 
     SLPlayItf player;
     SLresult result{VCALL(mBufferQueueObj,GetInterface)(SL_IID_PLAY, &player)};
-    PRINTERR(result, "bufferQueue->GetInterface");
+    PrintErr(result, "bufferQueue->GetInterface");
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(player,SetPlayState)(SL_PLAYSTATE_STOPPED);
-        PRINTERR(result, "player->SetPlayState");
+        PrintErr(result, "player->SetPlayState");
     }
 
     SLAndroidSimpleBufferQueueItf bufferQueue;
     result = VCALL(mBufferQueueObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &bufferQueue);
-    PRINTERR(result, "bufferQueue->GetInterface");
+    PrintErr(result, "bufferQueue->GetInterface");
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL0(bufferQueue,Clear)();
-        PRINTERR(result, "bufferQueue->Clear");
+        PrintErr(result, "bufferQueue->Clear");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(bufferQueue,RegisterCallback)(nullptr, nullptr);
-        PRINTERR(result, "bufferQueue->RegisterCallback");
+        PrintErr(result, "bufferQueue->RegisterCallback");
     }
     if(SL_RESULT_SUCCESS == result)
     {
@@ -601,7 +618,9 @@ void OpenSLPlayback::stop()
             std::this_thread::yield();
             result = VCALL(bufferQueue,GetState)(&state);
         } while(SL_RESULT_SUCCESS == result && state.count > 0);
-        PRINTERR(result, "bufferQueue->GetState");
+        PrintErr(result, "bufferQueue->GetState");
+
+        mRing->reset();
     }
 }
 
@@ -609,7 +628,7 @@ ClockLatency OpenSLPlayback::getClockLatency()
 {
     ClockLatency ret;
 
-    std::lock_guard<OpenSLPlayback> _{*this};
+    std::lock_guard<std::mutex> _{mMutex};
     ret.ClockTime = GetDeviceClockTime(mDevice);
     ret.Latency  = std::chrono::seconds{mRing->readSpace() * mDevice->UpdateSize};
     ret.Latency /= mDevice->Frequency;
@@ -619,18 +638,18 @@ ClockLatency OpenSLPlayback::getClockLatency()
 
 
 struct OpenSLCapture final : public BackendBase {
-    OpenSLCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    OpenSLCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~OpenSLCapture() override;
 
     void process(SLAndroidSimpleBufferQueueItf bq) noexcept;
     static void processC(SLAndroidSimpleBufferQueueItf bq, void *context) noexcept
     { static_cast<OpenSLCapture*>(context)->process(bq); }
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
     /* engine interfaces */
     SLObjectItf mEngineObj{nullptr};
@@ -640,9 +659,9 @@ struct OpenSLCapture final : public BackendBase {
     SLObjectItf mRecordObj{nullptr};
 
     RingBufferPtr mRing{nullptr};
-    ALCuint mSplOffset{0u};
+    uint mSplOffset{0u};
 
-    ALuint mFrameSize{0};
+    uint mFrameSize{0};
 
     DEF_NEWDEL(OpenSLCapture)
 };
@@ -667,39 +686,40 @@ void OpenSLCapture::process(SLAndroidSimpleBufferQueueItf) noexcept
 }
 
 
-void OpenSLCapture::open(const ALCchar* name)
+void OpenSLCapture::open(const char* name)
 {
     if(!name)
         name = opensl_device;
     else if(strcmp(name, opensl_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
     SLresult result{slCreateEngine(&mEngineObj, 0, nullptr, 0, nullptr, nullptr)};
-    PRINTERR(result, "slCreateEngine");
+    PrintErr(result, "slCreateEngine");
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mEngineObj,Realize)(SL_BOOLEAN_FALSE);
-        PRINTERR(result, "engine->Realize");
+        PrintErr(result, "engine->Realize");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mEngineObj,GetInterface)(SL_IID_ENGINE, &mEngine);
-        PRINTERR(result, "engine->GetInterface");
+        PrintErr(result, "engine->GetInterface");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         mFrameSize = mDevice->frameSizeFromFmt();
         /* Ensure the total length is at least 100ms */
-        ALuint length{maxu(mDevice->BufferSize, mDevice->Frequency/10)};
+        uint length{maxu(mDevice->BufferSize, mDevice->Frequency/10)};
         /* Ensure the per-chunk length is at least 10ms, and no more than 50ms. */
-        ALuint update_len{clampu(mDevice->BufferSize/3, mDevice->Frequency/100,
+        uint update_len{clampu(mDevice->BufferSize/3, mDevice->Frequency/100,
             mDevice->Frequency/100*5)};
-        ALuint num_updates{(length+update_len-1) / update_len};
+        uint num_updates{(length+update_len-1) / update_len};
 
-        mRing = CreateRingBuffer(num_updates, update_len*mFrameSize, false);
+        mRing = RingBuffer::Create(num_updates, update_len*mFrameSize, false);
 
         mDevice->UpdateSize = update_len;
-        mDevice->BufferSize = static_cast<ALuint>(mRing->writeSpace() * update_len);
+        mDevice->BufferSize = static_cast<uint>(mRing->writeSpace() * update_len);
     }
     if(SL_RESULT_SUCCESS == result)
     {
@@ -729,8 +749,7 @@ void OpenSLCapture::open(const ALCchar* name)
         format_pcm_ex.bitsPerSample = mDevice->bytesFromFmt() * 8;
         format_pcm_ex.containerSize = format_pcm_ex.bitsPerSample;
         format_pcm_ex.channelMask = GetChannelMask(mDevice->FmtChans);
-        format_pcm_ex.endianness = IS_LITTLE_ENDIAN ? SL_BYTEORDER_LITTLEENDIAN :
-            SL_BYTEORDER_BIGENDIAN;
+        format_pcm_ex.endianness = GetByteOrderEndianness();
         format_pcm_ex.representation = GetTypeRepresentation(mDevice->FmtType);
 
         audioSnk.pLocator = &loc_bq;
@@ -753,15 +772,14 @@ void OpenSLCapture::open(const ALCchar* name)
                 format_pcm.bitsPerSample = mDevice->bytesFromFmt() * 8;
                 format_pcm.containerSize = format_pcm.bitsPerSample;
                 format_pcm.channelMask = GetChannelMask(mDevice->FmtChans);
-                format_pcm.endianness = IS_LITTLE_ENDIAN ? SL_BYTEORDER_LITTLEENDIAN :
-                    SL_BYTEORDER_BIGENDIAN;
+                format_pcm.endianness = GetByteOrderEndianness();
 
                 audioSnk.pLocator = &loc_bq;
                 audioSnk.pFormat = &format_pcm;
                 result = VCALL(mEngine,CreateAudioRecorder)(&mRecordObj, &audioSrc, &audioSnk,
                     ids.size(), ids.data(), reqs.data());
             }
-            PRINTERR(result, "engine->CreateAudioRecorder");
+            PrintErr(result, "engine->CreateAudioRecorder");
         }
     }
     if(SL_RESULT_SUCCESS == result)
@@ -769,13 +787,13 @@ void OpenSLCapture::open(const ALCchar* name)
         /* Set the record preset to "generic", if possible. */
         SLAndroidConfigurationItf config;
         result = VCALL(mRecordObj,GetInterface)(SL_IID_ANDROIDCONFIGURATION, &config);
-        PRINTERR(result, "recordObj->GetInterface SL_IID_ANDROIDCONFIGURATION");
+        PrintErr(result, "recordObj->GetInterface SL_IID_ANDROIDCONFIGURATION");
         if(SL_RESULT_SUCCESS == result)
         {
             SLuint32 preset = SL_ANDROID_RECORDING_PRESET_GENERIC;
             result = VCALL(config,SetConfiguration)(SL_ANDROID_KEY_RECORDING_PRESET, &preset,
                 sizeof(preset));
-            PRINTERR(result, "config->SetConfiguration");
+            PrintErr(result, "config->SetConfiguration");
         }
 
         /* Clear any error since this was optional. */
@@ -784,34 +802,37 @@ void OpenSLCapture::open(const ALCchar* name)
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mRecordObj,Realize)(SL_BOOLEAN_FALSE);
-        PRINTERR(result, "recordObj->Realize");
+        PrintErr(result, "recordObj->Realize");
     }
 
     SLAndroidSimpleBufferQueueItf bufferQueue;
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(mRecordObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &bufferQueue);
-        PRINTERR(result, "recordObj->GetInterface");
+        PrintErr(result, "recordObj->GetInterface");
     }
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(bufferQueue,RegisterCallback)(&OpenSLCapture::processC, this);
-        PRINTERR(result, "bufferQueue->RegisterCallback");
+        PrintErr(result, "bufferQueue->RegisterCallback");
     }
     if(SL_RESULT_SUCCESS == result)
     {
-        const ALuint chunk_size{mDevice->UpdateSize * mFrameSize};
+        const uint chunk_size{mDevice->UpdateSize * mFrameSize};
+        const auto silence = (mDevice->FmtType == DevFmtUByte) ? al::byte{0x80} : al::byte{0};
 
         auto data = mRing->getWriteVector();
+        std::fill_n(data.first.buf, data.first.len*chunk_size, silence);
+        std::fill_n(data.second.buf, data.second.len*chunk_size, silence);
         for(size_t i{0u};i < data.first.len && SL_RESULT_SUCCESS == result;i++)
         {
             result = VCALL(bufferQueue,Enqueue)(data.first.buf + chunk_size*i, chunk_size);
-            PRINTERR(result, "bufferQueue->Enqueue");
+            PrintErr(result, "bufferQueue->Enqueue");
         }
         for(size_t i{0u};i < data.second.len && SL_RESULT_SUCCESS == result;i++)
         {
             result = VCALL(bufferQueue,Enqueue)(data.second.buf + chunk_size*i, chunk_size);
-            PRINTERR(result, "bufferQueue->Enqueue");
+            PrintErr(result, "bufferQueue->Enqueue");
         }
     }
 
@@ -826,108 +847,126 @@ void OpenSLCapture::open(const ALCchar* name)
         mEngineObj = nullptr;
         mEngine = nullptr;
 
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Failed to initialize OpenSL device: 0x%08x", result};
     }
 
     mDevice->DeviceName = name;
 }
 
-bool OpenSLCapture::start()
+void OpenSLCapture::start()
 {
     SLRecordItf record;
     SLresult result{VCALL(mRecordObj,GetInterface)(SL_IID_RECORD, &record)};
-    PRINTERR(result, "recordObj->GetInterface");
+    PrintErr(result, "recordObj->GetInterface");
 
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(record,SetRecordState)(SL_RECORDSTATE_RECORDING);
-        PRINTERR(result, "record->SetRecordState");
+        PrintErr(result, "record->SetRecordState");
     }
-
     if(SL_RESULT_SUCCESS != result)
-    {
-        aluHandleDisconnect(mDevice, "Failed to start capture: 0x%08x", result);
-        return false;
-    }
-
-    return true;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start capture: 0x%08x", result};
 }
 
 void OpenSLCapture::stop()
 {
     SLRecordItf record;
     SLresult result{VCALL(mRecordObj,GetInterface)(SL_IID_RECORD, &record)};
-    PRINTERR(result, "recordObj->GetInterface");
+    PrintErr(result, "recordObj->GetInterface");
 
     if(SL_RESULT_SUCCESS == result)
     {
         result = VCALL(record,SetRecordState)(SL_RECORDSTATE_PAUSED);
-        PRINTERR(result, "record->SetRecordState");
+        PrintErr(result, "record->SetRecordState");
     }
 }
 
-ALCenum OpenSLCapture::captureSamples(al::byte *buffer, ALCuint samples)
+void OpenSLCapture::captureSamples(al::byte *buffer, uint samples)
 {
-    SLAndroidSimpleBufferQueueItf bufferQueue{};
-    if LIKELY(mDevice->Connected.load(std::memory_order_acquire))
-    {
-        const SLresult result{VCALL(mRecordObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
-            &bufferQueue)};
-        PRINTERR(result, "recordObj->GetInterface");
-        if UNLIKELY(SL_RESULT_SUCCESS != result)
-        {
-            aluHandleDisconnect(mDevice, "Failed to get capture buffer queue: 0x%08x", result);
-            bufferQueue = nullptr;
-        }
-    }
-
-    const ALuint update_size{mDevice->UpdateSize};
-    const ALuint chunk_size{update_size * mFrameSize};
+    const uint update_size{mDevice->UpdateSize};
+    const uint chunk_size{update_size * mFrameSize};
 
     /* Read the desired samples from the ring buffer then advance its read
      * pointer.
      */
-    auto data = mRing->getReadVector();
-    for(ALCuint i{0};i < samples;)
+    size_t adv_count{0};
+    auto rdata = mRing->getReadVector();
+    for(uint i{0};i < samples;)
     {
-        const ALCuint rem{minu(samples - i, update_size - mSplOffset)};
-        std::copy_n(data.first.buf + mSplOffset*mFrameSize, rem*mFrameSize, buffer + i*mFrameSize);
+        const uint rem{minu(samples - i, update_size - mSplOffset)};
+        std::copy_n(rdata.first.buf + mSplOffset*size_t{mFrameSize}, rem*size_t{mFrameSize},
+            buffer + i*size_t{mFrameSize});
 
         mSplOffset += rem;
         if(mSplOffset == update_size)
         {
             /* Finished a chunk, reset the offset and advance the read pointer. */
             mSplOffset = 0;
-            mRing->readAdvance(1);
-
-            if LIKELY(bufferQueue)
-            {
-                const SLresult result{VCALL(bufferQueue,Enqueue)(data.first.buf, chunk_size)};
-                PRINTERR(result, "bufferQueue->Enqueue");
-                if UNLIKELY(SL_RESULT_SUCCESS != result)
-                {
-                    aluHandleDisconnect(mDevice, "Failed to update capture buffer: 0x%08x",
-                        result);
-                    bufferQueue = nullptr;
-                }
-            }
 
-            data.first.len--;
-            if(!data.first.len)
-                data.first = data.second;
+            ++adv_count;
+            rdata.first.len -= 1;
+            if(!rdata.first.len)
+                rdata.first = rdata.second;
             else
-                data.first.buf += chunk_size;
+                rdata.first.buf += chunk_size;
         }
 
         i += rem;
     }
 
-    return ALC_NO_ERROR;
+    SLAndroidSimpleBufferQueueItf bufferQueue{};
+    if(mDevice->Connected.load(std::memory_order_acquire)) LIKELY
+    {
+        const SLresult result{VCALL(mRecordObj,GetInterface)(SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
+            &bufferQueue)};
+        PrintErr(result, "recordObj->GetInterface");
+        if(SL_RESULT_SUCCESS != result) UNLIKELY
+        {
+            mDevice->handleDisconnect("Failed to get capture buffer queue: 0x%08x", result);
+            bufferQueue = nullptr;
+        }
+    }
+    if(!bufferQueue || adv_count == 0)
+        return;
+
+    /* For each buffer chunk that was fully read, queue another writable buffer
+     * chunk to keep the OpenSL queue full. This is rather convulated, as a
+     * result of the ring buffer holding more elements than are writable at a
+     * given time. The end of the write vector increments when the read pointer
+     * advances, which will "expose" a previously unwritable element. So for
+     * every element that we've finished reading, we queue that many elements
+     * from the end of the write vector.
+     */
+    mRing->readAdvance(adv_count);
+
+    SLresult result{SL_RESULT_SUCCESS};
+    auto wdata = mRing->getWriteVector();
+    if(adv_count > wdata.second.len) LIKELY
+    {
+        auto len1 = std::min(wdata.first.len, adv_count-wdata.second.len);
+        auto buf1 = wdata.first.buf + chunk_size*(wdata.first.len-len1);
+        for(size_t i{0u};i < len1 && SL_RESULT_SUCCESS == result;i++)
+        {
+            result = VCALL(bufferQueue,Enqueue)(buf1 + chunk_size*i, chunk_size);
+            PrintErr(result, "bufferQueue->Enqueue");
+        }
+    }
+    if(wdata.second.len > 0)
+    {
+        auto len2 = std::min(wdata.second.len, adv_count);
+        auto buf2 = wdata.second.buf + chunk_size*(wdata.second.len-len2);
+        for(size_t i{0u};i < len2 && SL_RESULT_SUCCESS == result;i++)
+        {
+            result = VCALL(bufferQueue,Enqueue)(buf2 + chunk_size*i, chunk_size);
+            PrintErr(result, "bufferQueue->Enqueue");
+        }
+    }
 }
 
-ALCuint OpenSLCapture::availableSamples()
-{ return static_cast<ALuint>(mRing->readSpace()*mDevice->UpdateSize - mSplOffset); }
+uint OpenSLCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()*mDevice->UpdateSize - mSplOffset); }
 
 } // namespace
 
@@ -936,19 +975,21 @@ bool OSLBackendFactory::init() { return true; }
 bool OSLBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void OSLBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string OSLBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-        case DevProbe::Capture:
-            /* Includes null char. */
-            outnames->append(opensl_device, sizeof(opensl_device));
-            break;
+    case BackendType::Playback:
+    case BackendType::Capture:
+        /* Includes null char. */
+        outnames.append(opensl_device, sizeof(opensl_device));
+        break;
     }
+    return outnames;
 }
 
-BackendPtr OSLBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr OSLBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new OpenSLPlayback{device}};
diff --git a/alc/backends/opensl.h b/alc/backends/opensl.h
index 809aa339..b8162447 100644
--- a/alc/backends/opensl.h
+++ b/alc/backends/opensl.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_OSL_H
 #define BACKENDS_OSL_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct OSLBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/oss.cpp b/alc/backends/oss.cpp
index 59cc44e4..6d4fa261 100644
--- a/alc/backends/oss.cpp
+++ b/alc/backends/oss.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/oss.h"
+#include "oss.h"
 
 #include <fcntl.h>
 #include <poll.h>
@@ -41,16 +41,14 @@
 #include <thread>
 #include <utility>
 
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "alconfig.h"
-#include "alexcpt.h"
+#include "albyte.h"
+#include "alc/alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
 #include "aloptional.h"
-#include "alu.h"
-#include "logging.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "ringbuffer.h"
 #include "threads.h"
 #include "vector.h"
@@ -94,14 +92,6 @@ struct DevMap {
     std::string device_name;
 };
 
-bool checkName(const al::vector<DevMap> &list, const std::string &name)
-{
-    return std::find_if(list.cbegin(), list.cend(),
-        [&name](const DevMap &entry) -> bool
-        { return entry.name == name; }
-    ) != list.cend();
-}
-
 al::vector<DevMap> PlaybackDevices;
 al::vector<DevMap> CaptureDevices;
 
@@ -110,60 +100,59 @@ al::vector<DevMap> CaptureDevices;
 
 #define DSP_CAP_OUTPUT 0x00020000
 #define DSP_CAP_INPUT 0x00010000
-void ALCossListPopulate(al::vector<DevMap> *devlist, int type)
+void ALCossListPopulate(al::vector<DevMap> &devlist, int type)
 {
-    devlist->emplace_back(DevMap{DefaultName, (type==DSP_CAP_INPUT) ? DefaultCapture : DefaultPlayback});
+    devlist.emplace_back(DevMap{DefaultName, (type==DSP_CAP_INPUT) ? DefaultCapture : DefaultPlayback});
 }
 
 #else
 
-void ALCossListAppend(al::vector<DevMap> *list, const char *handle, size_t hlen, const char *path, size_t plen)
+void ALCossListAppend(al::vector<DevMap> &list, al::span<const char> handle, al::span<const char> path)
 {
 #ifdef ALC_OSS_DEVNODE_TRUC
-    for(size_t i{0};i < plen;i++)
+    for(size_t i{0};i < path.size();++i)
     {
-        if(path[i] == '.')
+        if(path[i] == '.' && handle.size() + i >= path.size())
         {
-            if(strncmp(path + i, handle + hlen + i - plen, plen - i) == 0)
-                hlen = hlen + i - plen;
-            plen = i;
+            const size_t hoffset{handle.size() + i - path.size()};
+            if(strncmp(path.data() + i, handle.data() + hoffset, path.size() - i) == 0)
+                handle = handle.first(hoffset);
+            path = path.first(i);
         }
     }
 #endif
-    if(handle[0] == '\0')
-    {
+    if(handle.empty())
         handle = path;
-        hlen = plen;
-    }
 
-    std::string basename{handle, hlen};
-    basename.erase(std::find(basename.begin(), basename.end(), '\0'), basename.end());
-    std::string devname{path, plen};
-    devname.erase(std::find(devname.begin(), devname.end(), '\0'), devname.end());
+    std::string basename{handle.data(), handle.size()};
+    std::string devname{path.data(), path.size()};
 
-    auto iter = std::find_if(list->cbegin(), list->cend(),
-        [&devname](const DevMap &entry) -> bool
-        { return entry.device_name == devname; }
-    );
-    if(iter != list->cend())
+    auto match_devname = [&devname](const DevMap &entry) -> bool
+    { return entry.device_name == devname; };
+    if(std::find_if(list.cbegin(), list.cend(), match_devname) != list.cend())
         return;
 
+    auto checkName = [&list](const std::string &name) -> bool
+    {
+        auto match_name = [&name](const DevMap &entry) -> bool { return entry.name == name; };
+        return std::find_if(list.cbegin(), list.cend(), match_name) != list.cend();
+    };
     int count{1};
     std::string newname{basename};
-    while(checkName(PlaybackDevices, newname))
+    while(checkName(newname))
     {
         newname = basename;
         newname += " #";
         newname += std::to_string(++count);
     }
 
-    list->emplace_back(DevMap{std::move(newname), std::move(devname)});
-    const DevMap &entry = list->back();
+    list.emplace_back(DevMap{std::move(newname), std::move(devname)});
+    const DevMap &entry = list.back();
 
     TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
 }
 
-void ALCossListPopulate(al::vector<DevMap> *devlist, int type_flag)
+void ALCossListPopulate(al::vector<DevMap> &devlist, int type_flag)
 {
     int fd{open("/dev/mixer", O_RDONLY)};
     if(fd < 0)
@@ -191,21 +180,14 @@ void ALCossListPopulate(al::vector<DevMap> *devlist, int type_flag)
         if(!(ai.caps&type_flag) || ai.devnode[0] == '\0')
             continue;
 
-        const char *handle;
-        size_t len;
+        al::span<const char> handle;
         if(ai.handle[0] != '\0')
-        {
-            len = strnlen(ai.handle, sizeof(ai.handle));
-            handle = ai.handle;
-        }
+            handle = {ai.handle, strnlen(ai.handle, sizeof(ai.handle))};
         else
-        {
-            len = strnlen(ai.name, sizeof(ai.name));
-            handle = ai.name;
-        }
+            handle = {ai.name, strnlen(ai.name, sizeof(ai.name))};
+        al::span<const char> devnode{ai.devnode, strnlen(ai.devnode, sizeof(ai.devnode))};
 
-        ALCossListAppend(devlist, handle, len, ai.devnode,
-                         strnlen(ai.devnode, sizeof(ai.devnode)));
+        ALCossListAppend(devlist, handle, devnode);
     }
 
 done:
@@ -214,26 +196,26 @@ done:
     fd = -1;
 
     const char *defdev{((type_flag==DSP_CAP_INPUT) ? DefaultCapture : DefaultPlayback).c_str()};
-    auto iter = std::find_if(devlist->cbegin(), devlist->cend(),
+    auto iter = std::find_if(devlist.cbegin(), devlist.cend(),
         [defdev](const DevMap &entry) -> bool
         { return entry.device_name == defdev; }
     );
-    if(iter == devlist->cend())
-        devlist->insert(devlist->begin(), DevMap{DefaultName, defdev});
+    if(iter == devlist.cend())
+        devlist.insert(devlist.begin(), DevMap{DefaultName, defdev});
     else
     {
         DevMap entry{std::move(*iter)};
-        devlist->erase(iter);
-        devlist->insert(devlist->begin(), std::move(entry));
+        devlist.erase(iter);
+        devlist.insert(devlist.begin(), std::move(entry));
     }
-    devlist->shrink_to_fit();
+    devlist.shrink_to_fit();
 }
 
 #endif
 
-ALCuint log2i(ALCuint x)
+uint log2i(uint x)
 {
-    ALCuint y{0};
+    uint y{0};
     while(x > 1)
     {
         x >>= 1;
@@ -244,19 +226,19 @@ ALCuint log2i(ALCuint x)
 
 
 struct OSSPlayback final : public BackendBase {
-    OSSPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    OSSPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~OSSPlayback() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     int mFd{-1};
 
-    al::vector<ALubyte> mMixData;
+    al::vector<al::byte> mMixData;
 
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
@@ -267,7 +249,7 @@ struct OSSPlayback final : public BackendBase {
 OSSPlayback::~OSSPlayback()
 {
     if(mFd != -1)
-        close(mFd);
+        ::close(mFd);
     mFd = -1;
 }
 
@@ -277,25 +259,23 @@ int OSSPlayback::mixerProc()
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    const ALuint frame_size{mDevice->frameSizeFromFmt()};
+    const size_t frame_step{mDevice->channelsFromFmt()};
+    const size_t frame_size{mDevice->frameSizeFromFmt()};
 
-    std::unique_lock<OSSPlayback> dlock{*this};
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         pollfd pollitem{};
         pollitem.fd = mFd;
         pollitem.events = POLLOUT;
 
-        dlock.unlock();
         int pret{poll(&pollitem, 1, 1000)};
-        dlock.lock();
         if(pret < 0)
         {
             if(errno == EINTR || errno == EAGAIN)
                 continue;
             ERR("poll failed: %s\n", strerror(errno));
-            aluHandleDisconnect(mDevice, "Failed waiting for playback buffer: %s", strerror(errno));
+            mDevice->handleDisconnect("Failed waiting for playback buffer: %s", strerror(errno));
             break;
         }
         else if(pret == 0)
@@ -304,9 +284,9 @@ int OSSPlayback::mixerProc()
             continue;
         }
 
-        ALubyte *write_ptr{mMixData.data()};
+        al::byte *write_ptr{mMixData.data()};
         size_t to_write{mMixData.size()};
-        aluMixData(mDevice, write_ptr, static_cast<ALuint>(to_write/frame_size));
+        mDevice->renderSamples(write_ptr, static_cast<uint>(to_write/frame_size), frame_step);
         while(to_write > 0 && !mKillNow.load(std::memory_order_acquire))
         {
             ssize_t wrote{write(mFd, write_ptr, to_write)};
@@ -315,8 +295,7 @@ int OSSPlayback::mixerProc()
                 if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
                     continue;
                 ERR("write failed: %s\n", strerror(errno));
-                aluHandleDisconnect(mDevice, "Failed writing playback samples: %s",
-                                    strerror(errno));
+                mDevice->handleDisconnect("Failed writing playback samples: %s", strerror(errno));
                 break;
             }
 
@@ -329,7 +308,7 @@ int OSSPlayback::mixerProc()
 }
 
 
-void OSSPlayback::open(const ALCchar *name)
+void OSSPlayback::open(const char *name)
 {
     const char *devname{DefaultPlayback.c_str()};
     if(!name)
@@ -337,22 +316,27 @@ void OSSPlayback::open(const ALCchar *name)
     else
     {
         if(PlaybackDevices.empty())
-            ALCossListPopulate(&PlaybackDevices, DSP_CAP_OUTPUT);
+            ALCossListPopulate(PlaybackDevices, DSP_CAP_OUTPUT);
 
         auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
             [&name](const DevMap &entry) -> bool
             { return entry.name == name; }
         );
         if(iter == PlaybackDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
         devname = iter->device_name.c_str();
     }
 
-    mFd = ::open(devname, O_WRONLY);
-    if(mFd == -1)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open %s: %s", devname,
+    int fd{::open(devname, O_WRONLY)};
+    if(fd == -1)
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not open %s: %s", devname,
             strerror(errno)};
 
+    if(mFd != -1)
+        ::close(mFd);
+    mFd = fd;
+
     mDevice->DeviceName = name;
 }
 
@@ -378,13 +362,13 @@ bool OSSPlayback::reset()
             break;
     }
 
-    ALuint periods{mDevice->BufferSize / mDevice->UpdateSize};
-    ALuint numChannels{mDevice->channelsFromFmt()};
-    ALuint ossSpeed{mDevice->Frequency};
-    ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
+    uint periods{mDevice->BufferSize / mDevice->UpdateSize};
+    uint numChannels{mDevice->channelsFromFmt()};
+    uint ossSpeed{mDevice->Frequency};
+    uint frameSize{numChannels * mDevice->bytesFromFmt()};
     /* According to the OSS spec, 16 bytes (log2(16)) is the minimum. */
-    ALuint log2FragmentSize{maxu(log2i(mDevice->UpdateSize*frameSize), 4)};
-    ALuint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
+    uint log2FragmentSize{maxu(log2i(mDevice->UpdateSize*frameSize), 4)};
+    uint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
 
     audio_buf_info info{};
     const char *err;
@@ -424,29 +408,26 @@ bool OSSPlayback::reset()
     }
 
     mDevice->Frequency = ossSpeed;
-    mDevice->UpdateSize = static_cast<ALuint>(info.fragsize) / frameSize;
-    mDevice->BufferSize = static_cast<ALuint>(info.fragments) * mDevice->UpdateSize;
+    mDevice->UpdateSize = static_cast<uint>(info.fragsize) / frameSize;
+    mDevice->BufferSize = static_cast<uint>(info.fragments) * mDevice->UpdateSize;
 
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     mMixData.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
 
     return true;
 }
 
-bool OSSPlayback::start()
+void OSSPlayback::start()
 {
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&OSSPlayback::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
-    }
-    catch(...) {
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    return false;
 }
 
 void OSSPlayback::stop()
@@ -461,16 +442,16 @@ void OSSPlayback::stop()
 
 
 struct OSScapture final : public BackendBase {
-    OSScapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    OSScapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~OSScapture() override;
 
     int recordProc();
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
     int mFd{-1};
 
@@ -495,7 +476,7 @@ int OSScapture::recordProc()
     SetRTPriority();
     althrd_setname(RECORD_THREAD_NAME);
 
-    const ALuint frame_size{mDevice->frameSizeFromFmt()};
+    const size_t frame_size{mDevice->frameSizeFromFmt()};
     while(!mKillNow.load(std::memory_order_acquire))
     {
         pollfd pollitem{};
@@ -508,7 +489,7 @@ int OSScapture::recordProc()
             if(errno == EINTR || errno == EAGAIN)
                 continue;
             ERR("poll failed: %s\n", strerror(errno));
-            aluHandleDisconnect(mDevice, "Failed to check capture samples: %s", strerror(errno));
+            mDevice->handleDisconnect("Failed to check capture samples: %s", strerror(errno));
             break;
         }
         else if(sret == 0)
@@ -524,11 +505,10 @@ int OSScapture::recordProc()
             if(amt < 0)
             {
                 ERR("read failed: %s\n", strerror(errno));
-                aluHandleDisconnect(mDevice, "Failed reading capture samples: %s",
-                    strerror(errno));
+                mDevice->handleDisconnect("Failed reading capture samples: %s", strerror(errno));
                 break;
             }
-            mRing->writeAdvance(static_cast<ALuint>(amt)/frame_size);
+            mRing->writeAdvance(static_cast<size_t>(amt)/frame_size);
         }
     }
 
@@ -536,7 +516,7 @@ int OSScapture::recordProc()
 }
 
 
-void OSScapture::open(const ALCchar *name)
+void OSScapture::open(const char *name)
 {
     const char *devname{DefaultCapture.c_str()};
     if(!name)
@@ -544,20 +524,21 @@ void OSScapture::open(const ALCchar *name)
     else
     {
         if(CaptureDevices.empty())
-            ALCossListPopulate(&CaptureDevices, DSP_CAP_INPUT);
+            ALCossListPopulate(CaptureDevices, DSP_CAP_INPUT);
 
         auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
             [&name](const DevMap &entry) -> bool
             { return entry.name == name; }
         );
         if(iter == CaptureDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
         devname = iter->device_name.c_str();
     }
 
     mFd = ::open(devname, O_RDONLY);
     if(mFd == -1)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open %s: %s", devname,
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not open %s: %s", devname,
             strerror(errno)};
 
     int ossFormat{};
@@ -576,21 +557,22 @@ void OSScapture::open(const ALCchar *name)
     case DevFmtInt:
     case DevFmtUInt:
     case DevFmtFloat:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture samples not supported",
-            DevFmtTypeString(mDevice->FmtType)};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
     }
 
-    ALuint periods{4};
-    ALuint numChannels{mDevice->channelsFromFmt()};
-    ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
-    ALuint ossSpeed{mDevice->Frequency};
+    uint periods{4};
+    uint numChannels{mDevice->channelsFromFmt()};
+    uint frameSize{numChannels * mDevice->bytesFromFmt()};
+    uint ossSpeed{mDevice->Frequency};
     /* according to the OSS spec, 16 bytes are the minimum */
-    ALuint log2FragmentSize{maxu(log2i(mDevice->BufferSize * frameSize / periods), 4)};
-    ALuint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
+    uint log2FragmentSize{maxu(log2i(mDevice->BufferSize * frameSize / periods), 4)};
+    uint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
 
     audio_buf_info info{};
 #define CHECKERR(func) if((func) < 0) {                                       \
-    throw al::backend_exception{ALC_INVALID_VALUE, #func " failed: %s", strerror(errno)}; \
+    throw al::backend_exception{al::backend_error::DeviceError, #func " failed: %s", \
+        strerror(errno)};                                                     \
 }
     CHECKERR(ioctl(mFd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
     CHECKERR(ioctl(mFd, SNDCTL_DSP_SETFMT, &ossFormat));
@@ -600,35 +582,32 @@ void OSScapture::open(const ALCchar *name)
 #undef CHECKERR
 
     if(mDevice->channelsFromFmt() != numChannels)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Failed to set %s, got %d channels instead", DevFmtChannelsString(mDevice->FmtChans),
             numChannels};
 
     if(!((ossFormat == AFMT_S8 && mDevice->FmtType == DevFmtByte)
         || (ossFormat == AFMT_U8 && mDevice->FmtType == DevFmtUByte)
         || (ossFormat == AFMT_S16_NE && mDevice->FmtType == DevFmtShort)))
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Failed to set %s samples, got OSS format %#x", DevFmtTypeString(mDevice->FmtType),
             ossFormat};
 
-    mRing = CreateRingBuffer(mDevice->BufferSize, frameSize, false);
+    mRing = RingBuffer::Create(mDevice->BufferSize, frameSize, false);
 
     mDevice->DeviceName = name;
 }
 
-bool OSScapture::start()
+void OSScapture::start()
 {
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&OSScapture::recordProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create record thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start recording thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    return false;
 }
 
 void OSScapture::stop()
@@ -641,14 +620,11 @@ void OSScapture::stop()
         ERR("Error resetting device: %s\n", strerror(errno));
 }
 
-ALCenum OSScapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+void OSScapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
-ALCuint OSScapture::availableSamples()
-{ return static_cast<ALCuint>(mRing->readSpace()); }
+uint OSScapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
 
 } // namespace
 
@@ -672,37 +648,39 @@ bool OSSBackendFactory::init()
 bool OSSBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void OSSBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string OSSBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const DevMap &entry) -> void
+    std::string outnames;
+
+    auto add_device = [&outnames](const DevMap &entry) -> void
     {
-#ifdef HAVE_STAT
         struct stat buf;
         if(stat(entry.device_name.c_str(), &buf) == 0)
-#endif
         {
             /* Includes null char. */
-            outnames->append(entry.name.c_str(), entry.name.length()+1);
+            outnames.append(entry.name.c_str(), entry.name.length()+1);
         }
     };
 
     switch(type)
     {
-        case DevProbe::Playback:
-            PlaybackDevices.clear();
-            ALCossListPopulate(&PlaybackDevices, DSP_CAP_OUTPUT);
-            std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
-            break;
+    case BackendType::Playback:
+        PlaybackDevices.clear();
+        ALCossListPopulate(PlaybackDevices, DSP_CAP_OUTPUT);
+        std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
+        break;
 
-        case DevProbe::Capture:
-            CaptureDevices.clear();
-            ALCossListPopulate(&CaptureDevices, DSP_CAP_INPUT);
-            std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
-            break;
+    case BackendType::Capture:
+        CaptureDevices.clear();
+        ALCossListPopulate(CaptureDevices, DSP_CAP_INPUT);
+        std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
+        break;
     }
+
+    return outnames;
 }
 
-BackendPtr OSSBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr OSSBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new OSSPlayback{device}};
diff --git a/alc/backends/oss.h b/alc/backends/oss.h
index 9e63d7b6..4f2c00b9 100644
--- a/alc/backends/oss.h
+++ b/alc/backends/oss.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_OSS_H
 #define BACKENDS_OSS_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct OSSBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/pipewire.cpp b/alc/backends/pipewire.cpp
new file mode 100644
index 00000000..c6569a74
--- /dev/null
+++ b/alc/backends/pipewire.cpp
@@ -0,0 +1,2166 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2010 by Chris Robinson
+ * 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 "pipewire.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cstring>
+#include <cerrno>
+#include <chrono>
+#include <ctime>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <stdint.h>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#include "albyte.h"
+#include "alc/alconfig.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "alstring.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
+#include "dynload.h"
+#include "opthelpers.h"
+#include "ringbuffer.h"
+
+/* Ignore warnings caused by PipeWire headers (lots in standard C++ mode). GCC
+ * doesn't support ignoring -Weverything, so we have the list the individual
+ * warnings to ignore (and ignoring -Winline doesn't seem to work).
+ */
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wpedantic\"")
+_Pragma("GCC diagnostic ignored \"-Wconversion\"")
+_Pragma("GCC diagnostic ignored \"-Wfloat-conversion\"")
+_Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"")
+_Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")
+_Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")
+_Pragma("GCC diagnostic ignored \"-Wsign-compare\"")
+_Pragma("GCC diagnostic ignored \"-Winline\"")
+_Pragma("GCC diagnostic ignored \"-Wpragmas\"")
+_Pragma("GCC diagnostic ignored \"-Weverything\"")
+#include "pipewire/pipewire.h"
+#include "pipewire/extensions/metadata.h"
+#include "spa/buffer/buffer.h"
+#include "spa/param/audio/format-utils.h"
+#include "spa/param/audio/raw.h"
+#include "spa/param/param.h"
+#include "spa/pod/builder.h"
+#include "spa/utils/json.h"
+
+namespace {
+/* Wrap some nasty macros here too... */
+template<typename ...Args>
+auto ppw_core_add_listener(pw_core *core, Args&& ...args)
+{ return pw_core_add_listener(core, std::forward<Args>(args)...); }
+template<typename ...Args>
+auto ppw_core_sync(pw_core *core, Args&& ...args)
+{ return pw_core_sync(core, std::forward<Args>(args)...); }
+template<typename ...Args>
+auto ppw_registry_add_listener(pw_registry *reg, Args&& ...args)
+{ return pw_registry_add_listener(reg, std::forward<Args>(args)...); }
+template<typename ...Args>
+auto ppw_node_add_listener(pw_node *node, Args&& ...args)
+{ return pw_node_add_listener(node, std::forward<Args>(args)...); }
+template<typename ...Args>
+auto ppw_node_subscribe_params(pw_node *node, Args&& ...args)
+{ return pw_node_subscribe_params(node, std::forward<Args>(args)...); }
+template<typename ...Args>
+auto ppw_metadata_add_listener(pw_metadata *mdata, Args&& ...args)
+{ return pw_metadata_add_listener(mdata, std::forward<Args>(args)...); }
+
+
+constexpr auto get_pod_type(const spa_pod *pod) noexcept
+{ return SPA_POD_TYPE(pod); }
+
+template<typename T>
+constexpr auto get_pod_body(const spa_pod *pod, size_t count) noexcept
+{ return al::span<T>{static_cast<T*>(SPA_POD_BODY(pod)), count}; }
+template<typename T, size_t N>
+constexpr auto get_pod_body(const spa_pod *pod) noexcept
+{ return al::span<T,N>{static_cast<T*>(SPA_POD_BODY(pod)), N}; }
+
+constexpr auto make_pod_builder(void *data, uint32_t size) noexcept
+{ return SPA_POD_BUILDER_INIT(data, size); }
+
+constexpr auto get_array_value_type(const spa_pod *pod) noexcept
+{ return SPA_POD_ARRAY_VALUE_TYPE(pod); }
+
+constexpr auto PwIdAny = PW_ID_ANY;
+
+} // namespace
+_Pragma("GCC diagnostic pop")
+
+namespace {
+
+/* Added in 0.3.33, but we currently only require 0.3.23. */
+#ifndef PW_KEY_NODE_RATE
+#define PW_KEY_NODE_RATE "node.rate"
+#endif
+
+using std::chrono::seconds;
+using std::chrono::milliseconds;
+using std::chrono::nanoseconds;
+using uint = unsigned int;
+
+constexpr char pwireDevice[] = "PipeWire Output";
+constexpr char pwireInput[] = "PipeWire Input";
+
+
+bool check_version(const char *version)
+{
+    /* There doesn't seem to be a function to get the version as an integer, so
+     * instead we have to parse the string, which hopefully won't break in the
+     * future.
+     */
+    int major{0}, minor{0}, revision{0};
+    int ret{sscanf(version, "%d.%d.%d", &major, &minor, &revision)};
+    if(ret == 3 && (major > PW_MAJOR || (major == PW_MAJOR && minor > PW_MINOR)
+        || (major == PW_MAJOR && minor == PW_MINOR && revision >= PW_MICRO)))
+        return true;
+    return false;
+}
+
+#ifdef HAVE_DYNLOAD
+#define PWIRE_FUNCS(MAGIC)                                                    \
+    MAGIC(pw_context_connect)                                                 \
+    MAGIC(pw_context_destroy)                                                 \
+    MAGIC(pw_context_new)                                                     \
+    MAGIC(pw_core_disconnect)                                                 \
+    MAGIC(pw_get_library_version)                                             \
+    MAGIC(pw_init)                                                            \
+    MAGIC(pw_properties_free)                                                 \
+    MAGIC(pw_properties_new)                                                  \
+    MAGIC(pw_properties_set)                                                  \
+    MAGIC(pw_properties_setf)                                                 \
+    MAGIC(pw_proxy_add_object_listener)                                       \
+    MAGIC(pw_proxy_destroy)                                                   \
+    MAGIC(pw_proxy_get_user_data)                                             \
+    MAGIC(pw_stream_add_listener)                                             \
+    MAGIC(pw_stream_connect)                                                  \
+    MAGIC(pw_stream_dequeue_buffer)                                           \
+    MAGIC(pw_stream_destroy)                                                  \
+    MAGIC(pw_stream_get_state)                                                \
+    MAGIC(pw_stream_new)                                                      \
+    MAGIC(pw_stream_queue_buffer)                                             \
+    MAGIC(pw_stream_set_active)                                               \
+    MAGIC(pw_thread_loop_new)                                                 \
+    MAGIC(pw_thread_loop_destroy)                                             \
+    MAGIC(pw_thread_loop_get_loop)                                            \
+    MAGIC(pw_thread_loop_start)                                               \
+    MAGIC(pw_thread_loop_stop)                                                \
+    MAGIC(pw_thread_loop_lock)                                                \
+    MAGIC(pw_thread_loop_wait)                                                \
+    MAGIC(pw_thread_loop_signal)                                              \
+    MAGIC(pw_thread_loop_unlock)
+#if PW_CHECK_VERSION(0,3,50)
+#define PWIRE_FUNCS2(MAGIC)                                                   \
+    MAGIC(pw_stream_get_time_n)
+#else
+#define PWIRE_FUNCS2(MAGIC)                                                   \
+    MAGIC(pw_stream_get_time)
+#endif
+
+void *pwire_handle;
+#define MAKE_FUNC(f) decltype(f) * p##f;
+PWIRE_FUNCS(MAKE_FUNC)
+PWIRE_FUNCS2(MAKE_FUNC)
+#undef MAKE_FUNC
+
+bool pwire_load()
+{
+    if(pwire_handle)
+        return true;
+
+    static constexpr char pwire_library[] = "libpipewire-0.3.so.0";
+    std::string missing_funcs;
+
+    pwire_handle = LoadLib(pwire_library);
+    if(!pwire_handle)
+    {
+        WARN("Failed to load %s\n", pwire_library);
+        return false;
+    }
+
+#define LOAD_FUNC(f) do {                                                     \
+    p##f = reinterpret_cast<decltype(p##f)>(GetSymbol(pwire_handle, #f));     \
+    if(p##f == nullptr) missing_funcs += "\n" #f;                             \
+} while(0);
+    PWIRE_FUNCS(LOAD_FUNC)
+    PWIRE_FUNCS2(LOAD_FUNC)
+#undef LOAD_FUNC
+
+    if(!missing_funcs.empty())
+    {
+        WARN("Missing expected functions:%s\n", missing_funcs.c_str());
+        CloseLib(pwire_handle);
+        pwire_handle = nullptr;
+        return false;
+    }
+
+    return true;
+}
+
+#ifndef IN_IDE_PARSER
+#define pw_context_connect ppw_context_connect
+#define pw_context_destroy ppw_context_destroy
+#define pw_context_new ppw_context_new
+#define pw_core_disconnect ppw_core_disconnect
+#define pw_get_library_version ppw_get_library_version
+#define pw_init ppw_init
+#define pw_properties_free ppw_properties_free
+#define pw_properties_new ppw_properties_new
+#define pw_properties_set ppw_properties_set
+#define pw_properties_setf ppw_properties_setf
+#define pw_proxy_add_object_listener ppw_proxy_add_object_listener
+#define pw_proxy_destroy ppw_proxy_destroy
+#define pw_proxy_get_user_data ppw_proxy_get_user_data
+#define pw_stream_add_listener ppw_stream_add_listener
+#define pw_stream_connect ppw_stream_connect
+#define pw_stream_dequeue_buffer ppw_stream_dequeue_buffer
+#define pw_stream_destroy ppw_stream_destroy
+#define pw_stream_get_state ppw_stream_get_state
+#define pw_stream_new ppw_stream_new
+#define pw_stream_queue_buffer ppw_stream_queue_buffer
+#define pw_stream_set_active ppw_stream_set_active
+#define pw_thread_loop_destroy ppw_thread_loop_destroy
+#define pw_thread_loop_get_loop ppw_thread_loop_get_loop
+#define pw_thread_loop_lock ppw_thread_loop_lock
+#define pw_thread_loop_new ppw_thread_loop_new
+#define pw_thread_loop_signal ppw_thread_loop_signal
+#define pw_thread_loop_start ppw_thread_loop_start
+#define pw_thread_loop_stop ppw_thread_loop_stop
+#define pw_thread_loop_unlock ppw_thread_loop_unlock
+#define pw_thread_loop_wait ppw_thread_loop_wait
+#if PW_CHECK_VERSION(0,3,50)
+#define pw_stream_get_time_n ppw_stream_get_time_n
+#else
+inline auto pw_stream_get_time_n(pw_stream *stream, pw_time *ptime, size_t /*size*/)
+{ return ppw_stream_get_time(stream, ptime); }
+#endif
+#endif
+
+#else
+
+constexpr bool pwire_load() { return true; }
+#endif
+
+/* Helpers for retrieving values from params */
+template<uint32_t T> struct PodInfo { };
+
+template<>
+struct PodInfo<SPA_TYPE_Int> {
+    using Type = int32_t;
+    static auto get_value(const spa_pod *pod, int32_t *val)
+    { return spa_pod_get_int(pod, val); }
+};
+template<>
+struct PodInfo<SPA_TYPE_Id> {
+    using Type = uint32_t;
+    static auto get_value(const spa_pod *pod, uint32_t *val)
+    { return spa_pod_get_id(pod, val); }
+};
+
+template<uint32_t T>
+using Pod_t = typename PodInfo<T>::Type;
+
+template<uint32_t T>
+al::span<const Pod_t<T>> get_array_span(const spa_pod *pod)
+{
+    uint32_t nvals;
+    if(void *v{spa_pod_get_array(pod, &nvals)})
+    {
+        if(get_array_value_type(pod) == T)
+            return {static_cast<const Pod_t<T>*>(v), nvals};
+    }
+    return {};
+}
+
+template<uint32_t T>
+al::optional<Pod_t<T>> get_value(const spa_pod *value)
+{
+    Pod_t<T> val{};
+    if(PodInfo<T>::get_value(value, &val) == 0)
+        return val;
+    return al::nullopt;
+}
+
+/* Internally, PipeWire types "inherit" from each other, but this is hidden
+ * from the API and the caller is expected to C-style cast to inherited types
+ * as needed. It's also not made very clear what types a given type can be
+ * casted to. To make it a bit safer, this as() method allows casting pw_*
+ * types to known inherited types, generating a compile-time error for
+ * unexpected/invalid casts.
+ */
+template<typename To, typename From>
+To as(From) noexcept = delete;
+
+/* pw_proxy
+ * - pw_registry
+ * - pw_node
+ * - pw_metadata
+ */
+template<>
+pw_proxy* as(pw_registry *reg) noexcept { return reinterpret_cast<pw_proxy*>(reg); }
+template<>
+pw_proxy* as(pw_node *node) noexcept { return reinterpret_cast<pw_proxy*>(node); }
+template<>
+pw_proxy* as(pw_metadata *mdata) noexcept { return reinterpret_cast<pw_proxy*>(mdata); }
+
+
+struct PwContextDeleter {
+    void operator()(pw_context *context) const { pw_context_destroy(context); }
+};
+using PwContextPtr = std::unique_ptr<pw_context,PwContextDeleter>;
+
+struct PwCoreDeleter {
+    void operator()(pw_core *core) const { pw_core_disconnect(core); }
+};
+using PwCorePtr = std::unique_ptr<pw_core,PwCoreDeleter>;
+
+struct PwRegistryDeleter {
+    void operator()(pw_registry *reg) const { pw_proxy_destroy(as<pw_proxy*>(reg)); }
+};
+using PwRegistryPtr = std::unique_ptr<pw_registry,PwRegistryDeleter>;
+
+struct PwNodeDeleter {
+    void operator()(pw_node *node) const { pw_proxy_destroy(as<pw_proxy*>(node)); }
+};
+using PwNodePtr = std::unique_ptr<pw_node,PwNodeDeleter>;
+
+struct PwMetadataDeleter {
+    void operator()(pw_metadata *mdata) const { pw_proxy_destroy(as<pw_proxy*>(mdata)); }
+};
+using PwMetadataPtr = std::unique_ptr<pw_metadata,PwMetadataDeleter>;
+
+struct PwStreamDeleter {
+    void operator()(pw_stream *stream) const { pw_stream_destroy(stream); }
+};
+using PwStreamPtr = std::unique_ptr<pw_stream,PwStreamDeleter>;
+
+/* Enums for bitflags... again... *sigh* */
+constexpr pw_stream_flags operator|(pw_stream_flags lhs, pw_stream_flags rhs) noexcept
+{ return static_cast<pw_stream_flags>(lhs | al::to_underlying(rhs)); }
+
+constexpr pw_stream_flags& operator|=(pw_stream_flags &lhs, pw_stream_flags rhs) noexcept
+{ lhs = lhs | rhs; return lhs; }
+
+class ThreadMainloop {
+    pw_thread_loop *mLoop{};
+
+public:
+    ThreadMainloop() = default;
+    ThreadMainloop(const ThreadMainloop&) = delete;
+    ThreadMainloop(ThreadMainloop&& rhs) noexcept : mLoop{rhs.mLoop} { rhs.mLoop = nullptr; }
+    explicit ThreadMainloop(pw_thread_loop *loop) noexcept : mLoop{loop} { }
+    ~ThreadMainloop() { if(mLoop) pw_thread_loop_destroy(mLoop); }
+
+    ThreadMainloop& operator=(const ThreadMainloop&) = delete;
+    ThreadMainloop& operator=(ThreadMainloop&& rhs) noexcept
+    { std::swap(mLoop, rhs.mLoop); return *this; }
+    ThreadMainloop& operator=(std::nullptr_t) noexcept
+    {
+        if(mLoop)
+            pw_thread_loop_destroy(mLoop);
+        mLoop = nullptr;
+        return *this;
+    }
+
+    explicit operator bool() const noexcept { return mLoop != nullptr; }
+
+    auto start() const { return pw_thread_loop_start(mLoop); }
+    auto stop() const { return pw_thread_loop_stop(mLoop); }
+
+    auto getLoop() const { return pw_thread_loop_get_loop(mLoop); }
+
+    auto lock() const { return pw_thread_loop_lock(mLoop); }
+    auto unlock() const { return pw_thread_loop_unlock(mLoop); }
+
+    auto signal(bool wait) const { return pw_thread_loop_signal(mLoop, wait); }
+
+    auto newContext(pw_properties *props=nullptr, size_t user_data_size=0)
+    { return PwContextPtr{pw_context_new(getLoop(), props, user_data_size)}; }
+
+    static auto Create(const char *name, spa_dict *props=nullptr)
+    { return ThreadMainloop{pw_thread_loop_new(name, props)}; }
+
+    friend struct MainloopUniqueLock;
+};
+struct MainloopUniqueLock : public std::unique_lock<ThreadMainloop> {
+    using std::unique_lock<ThreadMainloop>::unique_lock;
+    MainloopUniqueLock& operator=(MainloopUniqueLock&&) = default;
+
+    auto wait() const -> void
+    { pw_thread_loop_wait(mutex()->mLoop); }
+
+    template<typename Predicate>
+    auto wait(Predicate done_waiting) const -> void
+    { while(!done_waiting()) wait(); }
+};
+using MainloopLockGuard = std::lock_guard<ThreadMainloop>;
+
+
+/* There's quite a mess here, but the purpose is to track active devices and
+ * their default formats, so playback devices can be configured to match. The
+ * device list is updated asynchronously, so it will have the latest list of
+ * devices provided by the server.
+ */
+
+struct NodeProxy;
+struct MetadataProxy;
+
+/* The global thread watching for global events. This particular class responds
+ * to objects being added to or removed from the registry.
+ */
+struct EventManager {
+    ThreadMainloop mLoop{};
+    PwContextPtr mContext{};
+    PwCorePtr mCore{};
+    PwRegistryPtr mRegistry{};
+    spa_hook mRegistryListener{};
+    spa_hook mCoreListener{};
+
+    /* A list of proxy objects watching for events about changes to objects in
+     * the registry.
+     */
+    std::vector<NodeProxy*> mNodeList;
+    MetadataProxy *mDefaultMetadata{nullptr};
+
+    /* Initialization handling. When init() is called, mInitSeq is set to a
+     * SequenceID that marks the end of populating the registry. As objects of
+     * interest are found, events to parse them are generated and mInitSeq is
+     * updated with a newer ID. When mInitSeq stops being updated and the event
+     * corresponding to it is reached, mInitDone will be set to true.
+     */
+    std::atomic<bool> mInitDone{false};
+    std::atomic<bool> mHasAudio{false};
+    int mInitSeq{};
+
+    bool init();
+    ~EventManager();
+
+    void kill();
+
+    auto lock() const { return mLoop.lock(); }
+    auto unlock() const { return mLoop.unlock(); }
+
+    /**
+     * Waits for initialization to finish. The event manager must *NOT* be
+     * locked when calling this.
+     */
+    void waitForInit()
+    {
+        if(!mInitDone.load(std::memory_order_acquire)) UNLIKELY
+        {
+            MainloopUniqueLock plock{mLoop};
+            plock.wait([this](){ return mInitDone.load(std::memory_order_acquire); });
+        }
+    }
+
+    /**
+     * Waits for audio support to be detected, or initialization to finish,
+     * whichever is first. Returns true if audio support was detected. The
+     * event manager must *NOT* be locked when calling this.
+     */
+    bool waitForAudio()
+    {
+        MainloopUniqueLock plock{mLoop};
+        bool has_audio{};
+        plock.wait([this,&has_audio]()
+        {
+            has_audio = mHasAudio.load(std::memory_order_acquire);
+            return has_audio || mInitDone.load(std::memory_order_acquire);
+        });
+        return has_audio;
+    }
+
+    void syncInit()
+    {
+        /* If initialization isn't done, update the sequence ID so it won't
+         * complete until after currently scheduled events.
+         */
+        if(!mInitDone.load(std::memory_order_relaxed))
+            mInitSeq = ppw_core_sync(mCore.get(), PW_ID_CORE, mInitSeq);
+    }
+
+    void addCallback(uint32_t id, uint32_t permissions, const char *type, uint32_t version,
+        const spa_dict *props);
+    static void addCallbackC(void *object, uint32_t id, uint32_t permissions, const char *type,
+        uint32_t version, const spa_dict *props)
+    { static_cast<EventManager*>(object)->addCallback(id, permissions, type, version, props); }
+
+    void removeCallback(uint32_t id);
+    static void removeCallbackC(void *object, uint32_t id)
+    { static_cast<EventManager*>(object)->removeCallback(id); }
+
+    static constexpr pw_registry_events CreateRegistryEvents()
+    {
+        pw_registry_events ret{};
+        ret.version = PW_VERSION_REGISTRY_EVENTS;
+        ret.global = &EventManager::addCallbackC;
+        ret.global_remove = &EventManager::removeCallbackC;
+        return ret;
+    }
+
+    void coreCallback(uint32_t id, int seq);
+    static void coreCallbackC(void *object, uint32_t id, int seq)
+    { static_cast<EventManager*>(object)->coreCallback(id, seq); }
+
+    static constexpr pw_core_events CreateCoreEvents()
+    {
+        pw_core_events ret{};
+        ret.version = PW_VERSION_CORE_EVENTS;
+        ret.done = &EventManager::coreCallbackC;
+        return ret;
+    }
+};
+using EventWatcherUniqueLock = std::unique_lock<EventManager>;
+using EventWatcherLockGuard = std::lock_guard<EventManager>;
+
+EventManager gEventHandler;
+
+/* Enumerated devices. This is updated asynchronously as the app runs, and the
+ * gEventHandler thread loop must be locked when accessing the list.
+ */
+enum class NodeType : unsigned char {
+    Sink, Source, Duplex
+};
+constexpr auto InvalidChannelConfig = DevFmtChannels(255);
+struct DeviceNode {
+    uint32_t mId{};
+
+    uint64_t mSerial{};
+    std::string mName;
+    std::string mDevName;
+
+    NodeType mType{};
+    bool mIsHeadphones{};
+    bool mIs51Rear{};
+
+    uint mSampleRate{};
+    DevFmtChannels mChannels{InvalidChannelConfig};
+
+    static std::vector<DeviceNode> sList;
+    static DeviceNode &Add(uint32_t id);
+    static DeviceNode *Find(uint32_t id);
+    static void Remove(uint32_t id);
+    static std::vector<DeviceNode> &GetList() noexcept { return sList; }
+
+    void parseSampleRate(const spa_pod *value) noexcept;
+    void parsePositions(const spa_pod *value) noexcept;
+    void parseChannelCount(const spa_pod *value) noexcept;
+};
+std::vector<DeviceNode> DeviceNode::sList;
+std::string DefaultSinkDevice;
+std::string DefaultSourceDevice;
+
+const char *AsString(NodeType type) noexcept
+{
+    switch(type)
+    {
+    case NodeType::Sink: return "sink";
+    case NodeType::Source: return "source";
+    case NodeType::Duplex: return "duplex";
+    }
+    return "<unknown>";
+}
+
+DeviceNode &DeviceNode::Add(uint32_t id)
+{
+    auto match_id = [id](DeviceNode &n) noexcept -> bool
+    { return n.mId == id; };
+
+    /* If the node is already in the list, return the existing entry. */
+    auto match = std::find_if(sList.begin(), sList.end(), match_id);
+    if(match != sList.end()) return *match;
+
+    sList.emplace_back();
+    auto &n = sList.back();
+    n.mId = id;
+    return n;
+}
+
+DeviceNode *DeviceNode::Find(uint32_t id)
+{
+    auto match_id = [id](DeviceNode &n) noexcept -> bool
+    { return n.mId == id; };
+
+    auto match = std::find_if(sList.begin(), sList.end(), match_id);
+    if(match != sList.end()) return al::to_address(match);
+
+    return nullptr;
+}
+
+void DeviceNode::Remove(uint32_t id)
+{
+    auto match_id = [id](DeviceNode &n) noexcept -> bool
+    {
+        if(n.mId != id)
+            return false;
+        TRACE("Removing device \"%s\"\n", n.mDevName.c_str());
+        return true;
+    };
+
+    auto end = std::remove_if(sList.begin(), sList.end(), match_id);
+    sList.erase(end, sList.end());
+}
+
+
+const spa_audio_channel MonoMap[]{
+    SPA_AUDIO_CHANNEL_MONO
+}, StereoMap[] {
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR
+}, QuadMap[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR
+}, X51Map[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE,
+    SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR
+}, X51RearMap[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE,
+    SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR
+}, X61Map[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE,
+    SPA_AUDIO_CHANNEL_RC, SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR
+}, X71Map[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE,
+    SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR
+}, X714Map[]{
+    SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE,
+    SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR,
+    SPA_AUDIO_CHANNEL_TFL, SPA_AUDIO_CHANNEL_TFR, SPA_AUDIO_CHANNEL_TRL, SPA_AUDIO_CHANNEL_TRR
+};
+
+/**
+ * Checks if every channel in 'map1' exists in 'map0' (that is, map0 is equal
+ * to or a superset of map1).
+ */
+template<size_t N>
+bool MatchChannelMap(const al::span<const uint32_t> map0, const spa_audio_channel (&map1)[N])
+{
+    if(map0.size() < N)
+        return false;
+    for(const spa_audio_channel chid : map1)
+    {
+        if(std::find(map0.begin(), map0.end(), chid) == map0.end())
+            return false;
+    }
+    return true;
+}
+
+void DeviceNode::parseSampleRate(const spa_pod *value) noexcept
+{
+    /* TODO: Can this be anything else? Long, Float, Double? */
+    uint32_t nvals{}, choiceType{};
+    value = spa_pod_get_values(value, &nvals, &choiceType);
+
+    const uint podType{get_pod_type(value)};
+    if(podType != SPA_TYPE_Int)
+    {
+        WARN("Unhandled sample rate POD type: %u\n", podType);
+        return;
+    }
+
+    if(choiceType == SPA_CHOICE_Range)
+    {
+        if(nvals != 3)
+        {
+            WARN("Unexpected SPA_CHOICE_Range count: %u\n", nvals);
+            return;
+        }
+        auto srates = get_pod_body<int32_t,3>(value);
+
+        /* [0] is the default, [1] is the min, and [2] is the max. */
+        TRACE("Device ID %" PRIu64 " sample rate: %d (range: %d -> %d)\n", mSerial, srates[0],
+            srates[1], srates[2]);
+        mSampleRate = static_cast<uint>(clampi(srates[0], MIN_OUTPUT_RATE, MAX_OUTPUT_RATE));
+        return;
+    }
+
+    if(choiceType == SPA_CHOICE_Enum)
+    {
+        if(nvals == 0)
+        {
+            WARN("Unexpected SPA_CHOICE_Enum count: %u\n", nvals);
+            return;
+        }
+        auto srates = get_pod_body<int32_t>(value, nvals);
+
+        /* [0] is the default, [1...size()-1] are available selections. */
+        std::string others{(srates.size() > 1) ? std::to_string(srates[1]) : std::string{}};
+        for(size_t i{2};i < srates.size();++i)
+        {
+            others += ", ";
+            others += std::to_string(srates[i]);
+        }
+        TRACE("Device ID %" PRIu64 " sample rate: %d (%s)\n", mSerial, srates[0], others.c_str());
+        /* Pick the first rate listed that's within the allowed range (default
+         * rate if possible).
+         */
+        for(const auto &rate : srates)
+        {
+            if(rate >= MIN_OUTPUT_RATE && rate <= MAX_OUTPUT_RATE)
+            {
+                mSampleRate = static_cast<uint>(rate);
+                break;
+            }
+        }
+        return;
+    }
+
+    if(choiceType == SPA_CHOICE_None)
+    {
+        if(nvals != 1)
+        {
+            WARN("Unexpected SPA_CHOICE_None count: %u\n", nvals);
+            return;
+        }
+        auto srates = get_pod_body<int32_t,1>(value);
+
+        TRACE("Device ID %" PRIu64 " sample rate: %d\n", mSerial, srates[0]);
+        mSampleRate = static_cast<uint>(clampi(srates[0], MIN_OUTPUT_RATE, MAX_OUTPUT_RATE));
+        return;
+    }
+
+    WARN("Unhandled sample rate choice type: %u\n", choiceType);
+}
+
+void DeviceNode::parsePositions(const spa_pod *value) noexcept
+{
+    const auto chanmap = get_array_span<SPA_TYPE_Id>(value);
+    if(chanmap.empty()) return;
+
+    mIs51Rear = false;
+
+    if(MatchChannelMap(chanmap, X714Map))
+        mChannels = DevFmtX714;
+    else if(MatchChannelMap(chanmap, X71Map))
+        mChannels = DevFmtX71;
+    else if(MatchChannelMap(chanmap, X61Map))
+        mChannels = DevFmtX61;
+    else if(MatchChannelMap(chanmap, X51Map))
+        mChannels = DevFmtX51;
+    else if(MatchChannelMap(chanmap, X51RearMap))
+    {
+        mChannels = DevFmtX51;
+        mIs51Rear = true;
+    }
+    else if(MatchChannelMap(chanmap, QuadMap))
+        mChannels = DevFmtQuad;
+    else if(MatchChannelMap(chanmap, StereoMap))
+        mChannels = DevFmtStereo;
+    else
+        mChannels = DevFmtMono;
+    TRACE("Device ID %" PRIu64 " got %zu position%s for %s%s\n", mSerial, chanmap.size(),
+        (chanmap.size()==1)?"":"s", DevFmtChannelsString(mChannels), mIs51Rear?"(rear)":"");
+}
+
+void DeviceNode::parseChannelCount(const spa_pod *value) noexcept
+{
+    /* As a fallback with just a channel count, just assume mono or stereo. */
+    const auto chancount = get_value<SPA_TYPE_Int>(value);
+    if(!chancount) return;
+
+    mIs51Rear = false;
+
+    if(*chancount >= 2)
+        mChannels = DevFmtStereo;
+    else if(*chancount >= 1)
+        mChannels = DevFmtMono;
+    TRACE("Device ID %" PRIu64 " got %d channel%s for %s\n", mSerial, *chancount,
+        (*chancount==1)?"":"s", DevFmtChannelsString(mChannels));
+}
+
+
+constexpr char MonitorPrefix[]{"Monitor of "};
+constexpr auto MonitorPrefixLen = al::size(MonitorPrefix) - 1;
+constexpr char AudioSinkClass[]{"Audio/Sink"};
+constexpr char AudioSourceClass[]{"Audio/Source"};
+constexpr char AudioSourceVirtualClass[]{"Audio/Source/Virtual"};
+constexpr char AudioDuplexClass[]{"Audio/Duplex"};
+constexpr char StreamClass[]{"Stream/"};
+
+/* A generic PipeWire node proxy object used to track changes to sink and
+ * source nodes.
+ */
+struct NodeProxy {
+    static constexpr pw_node_events CreateNodeEvents()
+    {
+        pw_node_events ret{};
+        ret.version = PW_VERSION_NODE_EVENTS;
+        ret.info = &NodeProxy::infoCallbackC;
+        ret.param = &NodeProxy::paramCallbackC;
+        return ret;
+    }
+
+    uint32_t mId{};
+
+    PwNodePtr mNode{};
+    spa_hook mListener{};
+
+    NodeProxy(uint32_t id, PwNodePtr node)
+      : mId{id}, mNode{std::move(node)}
+    {
+        static constexpr pw_node_events nodeEvents{CreateNodeEvents()};
+        ppw_node_add_listener(mNode.get(), &mListener, &nodeEvents, this);
+
+        /* Track changes to the enumerable formats (indicates the default
+         * format, which is what we're interested in).
+         */
+        uint32_t fmtids[]{SPA_PARAM_EnumFormat};
+        ppw_node_subscribe_params(mNode.get(), al::data(fmtids), al::size(fmtids));
+    }
+    ~NodeProxy()
+    { spa_hook_remove(&mListener); }
+
+
+    void infoCallback(const pw_node_info *info);
+    static void infoCallbackC(void *object, const pw_node_info *info)
+    { static_cast<NodeProxy*>(object)->infoCallback(info); }
+
+    void paramCallback(int seq, uint32_t id, uint32_t index, uint32_t next, const spa_pod *param);
+    static void paramCallbackC(void *object, int seq, uint32_t id, uint32_t index, uint32_t next,
+        const spa_pod *param)
+    { static_cast<NodeProxy*>(object)->paramCallback(seq, id, index, next, param); }
+};
+
+void NodeProxy::infoCallback(const pw_node_info *info)
+{
+    /* We only care about property changes here (media class, name/desc).
+     * Format changes will automatically invoke the param callback.
+     *
+     * TODO: Can the media class or name/desc change without being removed and
+     * readded?
+     */
+    if((info->change_mask&PW_NODE_CHANGE_MASK_PROPS))
+    {
+        /* Can this actually change? */
+        const char *media_class{spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS)};
+        if(!media_class) UNLIKELY return;
+
+        NodeType ntype{};
+        if(al::strcasecmp(media_class, AudioSinkClass) == 0)
+            ntype = NodeType::Sink;
+        else if(al::strcasecmp(media_class, AudioSourceClass) == 0
+            || al::strcasecmp(media_class, AudioSourceVirtualClass) == 0)
+            ntype = NodeType::Source;
+        else if(al::strcasecmp(media_class, AudioDuplexClass) == 0)
+            ntype = NodeType::Duplex;
+        else
+        {
+            TRACE("Dropping device node %u which became type \"%s\"\n", info->id, media_class);
+            DeviceNode::Remove(info->id);
+            return;
+        }
+
+        const char *devName{spa_dict_lookup(info->props, PW_KEY_NODE_NAME)};
+        const char *nodeName{spa_dict_lookup(info->props, PW_KEY_NODE_DESCRIPTION)};
+        if(!nodeName || !*nodeName) nodeName = spa_dict_lookup(info->props, PW_KEY_NODE_NICK);
+        if(!nodeName || !*nodeName) nodeName = devName;
+
+        uint64_t serial_id{info->id};
+#ifdef PW_KEY_OBJECT_SERIAL
+        if(const char *serial_str{spa_dict_lookup(info->props, PW_KEY_OBJECT_SERIAL)})
+        {
+            char *serial_end{};
+            serial_id = std::strtoull(serial_str, &serial_end, 0);
+            if(*serial_end != '\0' || errno == ERANGE)
+            {
+                ERR("Unexpected object serial: %s\n", serial_str);
+                serial_id = info->id;
+            }
+        }
+#endif
+
+        const char *form_factor{spa_dict_lookup(info->props, PW_KEY_DEVICE_FORM_FACTOR)};
+        TRACE("Got %s device \"%s\"%s%s%s\n", AsString(ntype), devName ? devName : "(nil)",
+            form_factor?" (":"", form_factor?form_factor:"", form_factor?")":"");
+        TRACE("  \"%s\" = ID %" PRIu64 "\n", nodeName ? nodeName : "(nil)", serial_id);
+
+        DeviceNode &node = DeviceNode::Add(info->id);
+        node.mSerial = serial_id;
+        if(nodeName && *nodeName) node.mName = nodeName;
+        else node.mName = "PipeWire node #"+std::to_string(info->id);
+        node.mDevName = devName ? devName : "";
+        node.mType = ntype;
+        node.mIsHeadphones = form_factor && (al::strcasecmp(form_factor, "headphones") == 0
+            || al::strcasecmp(form_factor, "headset") == 0);
+    }
+}
+
+void NodeProxy::paramCallback(int, uint32_t id, uint32_t, uint32_t, const spa_pod *param)
+{
+    if(id == SPA_PARAM_EnumFormat)
+    {
+        DeviceNode *node{DeviceNode::Find(mId)};
+        if(!node) UNLIKELY return;
+
+        if(const spa_pod_prop *prop{spa_pod_find_prop(param, nullptr, SPA_FORMAT_AUDIO_rate)})
+            node->parseSampleRate(&prop->value);
+
+        if(const spa_pod_prop *prop{spa_pod_find_prop(param, nullptr, SPA_FORMAT_AUDIO_position)})
+            node->parsePositions(&prop->value);
+        else if((prop=spa_pod_find_prop(param, nullptr, SPA_FORMAT_AUDIO_channels)) != nullptr)
+            node->parseChannelCount(&prop->value);
+    }
+}
+
+
+/* A metadata proxy object used to query the default sink and source. */
+struct MetadataProxy {
+    static constexpr pw_metadata_events CreateMetadataEvents()
+    {
+        pw_metadata_events ret{};
+        ret.version = PW_VERSION_METADATA_EVENTS;
+        ret.property = &MetadataProxy::propertyCallbackC;
+        return ret;
+    }
+
+    uint32_t mId{};
+
+    PwMetadataPtr mMetadata{};
+    spa_hook mListener{};
+
+    MetadataProxy(uint32_t id, PwMetadataPtr mdata)
+      : mId{id}, mMetadata{std::move(mdata)}
+    {
+        static constexpr pw_metadata_events metadataEvents{CreateMetadataEvents()};
+        ppw_metadata_add_listener(mMetadata.get(), &mListener, &metadataEvents, this);
+    }
+    ~MetadataProxy()
+    { spa_hook_remove(&mListener); }
+
+
+    int propertyCallback(uint32_t id, const char *key, const char *type, const char *value);
+    static int propertyCallbackC(void *object, uint32_t id, const char *key, const char *type,
+        const char *value)
+    { return static_cast<MetadataProxy*>(object)->propertyCallback(id, key, type, value); }
+};
+
+int MetadataProxy::propertyCallback(uint32_t id, const char *key, const char *type,
+    const char *value)
+{
+    if(id != PW_ID_CORE)
+        return 0;
+
+    bool isCapture{};
+    if(std::strcmp(key, "default.audio.sink") == 0)
+        isCapture = false;
+    else if(std::strcmp(key, "default.audio.source") == 0)
+        isCapture = true;
+    else
+        return 0;
+
+    if(!type)
+    {
+        TRACE("Default %s device cleared\n", isCapture ? "capture" : "playback");
+        if(!isCapture) DefaultSinkDevice.clear();
+        else DefaultSourceDevice.clear();
+        return 0;
+    }
+    if(std::strcmp(type, "Spa:String:JSON") != 0)
+    {
+        ERR("Unexpected %s property type: %s\n", key, type);
+        return 0;
+    }
+
+    spa_json it[2]{};
+    spa_json_init(&it[0], value, strlen(value));
+    if(spa_json_enter_object(&it[0], &it[1]) <= 0)
+        return 0;
+
+    auto get_json_string = [](spa_json *iter)
+    {
+        al::optional<std::string> str;
+
+        const char *val{};
+        int len{spa_json_next(iter, &val)};
+        if(len <= 0) return str;
+
+        str.emplace().resize(static_cast<uint>(len), '\0');
+        if(spa_json_parse_string(val, len, &str->front()) <= 0)
+            str.reset();
+        else while(!str->empty() && str->back() == '\0')
+            str->pop_back();
+        return str;
+    };
+    while(auto propKey = get_json_string(&it[1]))
+    {
+        if(*propKey == "name")
+        {
+            auto propValue = get_json_string(&it[1]);
+            if(!propValue) break;
+
+            TRACE("Got default %s device \"%s\"\n", isCapture ? "capture" : "playback",
+                propValue->c_str());
+            if(!isCapture)
+                DefaultSinkDevice = std::move(*propValue);
+            else
+                DefaultSourceDevice = std::move(*propValue);
+        }
+        else
+        {
+            const char *v{};
+            if(spa_json_next(&it[1], &v) <= 0)
+                break;
+        }
+    }
+    return 0;
+}
+
+
+bool EventManager::init()
+{
+    mLoop = ThreadMainloop::Create("PWEventThread");
+    if(!mLoop)
+    {
+        ERR("Failed to create PipeWire event thread loop (errno: %d)\n", errno);
+        return false;
+    }
+
+    mContext = mLoop.newContext(pw_properties_new(PW_KEY_CONFIG_NAME, "client-rt.conf", nullptr));
+    if(!mContext)
+    {
+        ERR("Failed to create PipeWire event context (errno: %d)\n", errno);
+        return false;
+    }
+
+    mCore = PwCorePtr{pw_context_connect(mContext.get(), nullptr, 0)};
+    if(!mCore)
+    {
+        ERR("Failed to connect PipeWire event context (errno: %d)\n", errno);
+        return false;
+    }
+
+    mRegistry = PwRegistryPtr{pw_core_get_registry(mCore.get(), PW_VERSION_REGISTRY, 0)};
+    if(!mRegistry)
+    {
+        ERR("Failed to get PipeWire event registry (errno: %d)\n", errno);
+        return false;
+    }
+
+    static constexpr pw_core_events coreEvents{CreateCoreEvents()};
+    static constexpr pw_registry_events registryEvents{CreateRegistryEvents()};
+
+    ppw_core_add_listener(mCore.get(), &mCoreListener, &coreEvents, this);
+    ppw_registry_add_listener(mRegistry.get(), &mRegistryListener, &registryEvents, this);
+
+    /* Set an initial sequence ID for initialization, to trigger after the
+     * registry is first populated.
+     */
+    mInitSeq = ppw_core_sync(mCore.get(), PW_ID_CORE, 0);
+
+    if(int res{mLoop.start()})
+    {
+        ERR("Failed to start PipeWire event thread loop (res: %d)\n", res);
+        return false;
+    }
+
+    return true;
+}
+
+EventManager::~EventManager()
+{
+    if(mLoop) mLoop.stop();
+
+    for(NodeProxy *node : mNodeList)
+        al::destroy_at(node);
+    if(mDefaultMetadata)
+        al::destroy_at(mDefaultMetadata);
+}
+
+void EventManager::kill()
+{
+    if(mLoop) mLoop.stop();
+
+    for(NodeProxy *node : mNodeList)
+        al::destroy_at(node);
+    mNodeList.clear();
+    if(mDefaultMetadata)
+        al::destroy_at(mDefaultMetadata);
+    mDefaultMetadata = nullptr;
+
+    mRegistry = nullptr;
+    mCore = nullptr;
+    mContext = nullptr;
+    mLoop = nullptr;
+}
+
+void EventManager::addCallback(uint32_t id, uint32_t, const char *type, uint32_t version,
+    const spa_dict *props)
+{
+    /* We're only interested in interface nodes. */
+    if(std::strcmp(type, PW_TYPE_INTERFACE_Node) == 0)
+    {
+        const char *media_class{spa_dict_lookup(props, PW_KEY_MEDIA_CLASS)};
+        if(!media_class) return;
+
+        /* Specifically, audio sinks and sources (and duplexes). */
+        const bool isGood{al::strcasecmp(media_class, AudioSinkClass) == 0
+            || al::strcasecmp(media_class, AudioSourceClass) == 0
+            || al::strcasecmp(media_class, AudioSourceVirtualClass) == 0
+            || al::strcasecmp(media_class, AudioDuplexClass) == 0};
+        if(!isGood)
+        {
+            if(std::strstr(media_class, "/Video") == nullptr
+                && std::strncmp(media_class, StreamClass, sizeof(StreamClass)-1) != 0)
+                TRACE("Ignoring node class %s\n", media_class);
+            return;
+        }
+
+        /* Create the proxy object. */
+        auto node = PwNodePtr{static_cast<pw_node*>(pw_registry_bind(mRegistry.get(), id, type,
+            version, sizeof(NodeProxy)))};
+        if(!node)
+        {
+            ERR("Failed to create node proxy object (errno: %d)\n", errno);
+            return;
+        }
+
+        /* Initialize the NodeProxy to hold the node object, add it to the
+         * active node list, and update the sync point.
+         */
+        auto *proxy = static_cast<NodeProxy*>(pw_proxy_get_user_data(as<pw_proxy*>(node.get())));
+        mNodeList.emplace_back(al::construct_at(proxy, id, std::move(node)));
+        syncInit();
+
+        /* Signal any waiters that we have found a source or sink for audio
+         * support.
+         */
+        if(!mHasAudio.exchange(true, std::memory_order_acq_rel))
+            mLoop.signal(false);
+    }
+    else if(std::strcmp(type, PW_TYPE_INTERFACE_Metadata) == 0)
+    {
+        const char *data_class{spa_dict_lookup(props, PW_KEY_METADATA_NAME)};
+        if(!data_class) return;
+
+        if(std::strcmp(data_class, "default") != 0)
+        {
+            TRACE("Ignoring metadata \"%s\"\n", data_class);
+            return;
+        }
+
+        if(mDefaultMetadata)
+        {
+            ERR("Duplicate default metadata\n");
+            return;
+        }
+
+        auto mdata = PwMetadataPtr{static_cast<pw_metadata*>(pw_registry_bind(mRegistry.get(), id,
+            type, version, sizeof(MetadataProxy)))};
+        if(!mdata)
+        {
+            ERR("Failed to create metadata proxy object (errno: %d)\n", errno);
+            return;
+        }
+
+        auto *proxy = static_cast<MetadataProxy*>(
+            pw_proxy_get_user_data(as<pw_proxy*>(mdata.get())));
+        mDefaultMetadata = al::construct_at(proxy, id, std::move(mdata));
+        syncInit();
+    }
+}
+
+void EventManager::removeCallback(uint32_t id)
+{
+    DeviceNode::Remove(id);
+
+    auto clear_node = [id](NodeProxy *node) noexcept
+    {
+        if(node->mId != id)
+            return false;
+        al::destroy_at(node);
+        return true;
+    };
+    auto node_end = std::remove_if(mNodeList.begin(), mNodeList.end(), clear_node);
+    mNodeList.erase(node_end, mNodeList.end());
+
+    if(mDefaultMetadata && mDefaultMetadata->mId == id)
+    {
+        al::destroy_at(mDefaultMetadata);
+        mDefaultMetadata = nullptr;
+    }
+}
+
+void EventManager::coreCallback(uint32_t id, int seq)
+{
+    if(id == PW_ID_CORE && seq == mInitSeq)
+    {
+        /* Initialization done. Remove this callback and signal anyone that may
+         * be waiting.
+         */
+        spa_hook_remove(&mCoreListener);
+
+        mInitDone.store(true);
+        mLoop.signal(false);
+    }
+}
+
+
+enum use_f32p_e : bool { UseDevType=false, ForceF32Planar=true };
+spa_audio_info_raw make_spa_info(DeviceBase *device, bool is51rear, use_f32p_e use_f32p)
+{
+    spa_audio_info_raw info{};
+    if(use_f32p)
+    {
+        device->FmtType = DevFmtFloat;
+        info.format = SPA_AUDIO_FORMAT_F32P;
+    }
+    else switch(device->FmtType)
+    {
+    case DevFmtByte: info.format = SPA_AUDIO_FORMAT_S8; break;
+    case DevFmtUByte: info.format = SPA_AUDIO_FORMAT_U8; break;
+    case DevFmtShort: info.format = SPA_AUDIO_FORMAT_S16; break;
+    case DevFmtUShort: info.format = SPA_AUDIO_FORMAT_U16; break;
+    case DevFmtInt: info.format = SPA_AUDIO_FORMAT_S32; break;
+    case DevFmtUInt: info.format = SPA_AUDIO_FORMAT_U32; break;
+    case DevFmtFloat: info.format = SPA_AUDIO_FORMAT_F32; break;
+    }
+
+    info.rate = device->Frequency;
+
+    al::span<const spa_audio_channel> map{};
+    switch(device->FmtChans)
+    {
+    case DevFmtMono: map = MonoMap; break;
+    case DevFmtStereo: map = StereoMap; break;
+    case DevFmtQuad: map = QuadMap; break;
+    case DevFmtX51:
+        if(is51rear) map = X51RearMap;
+        else map = X51Map;
+        break;
+    case DevFmtX61: map = X61Map; break;
+    case DevFmtX71: map = X71Map; break;
+    case DevFmtX714: map = X714Map; break;
+    case DevFmtX3D71: map = X71Map; break;
+    case DevFmtAmbi3D:
+        info.flags |= SPA_AUDIO_FLAG_UNPOSITIONED;
+        info.channels = device->channelsFromFmt();
+        break;
+    }
+    if(!map.empty())
+    {
+        info.channels = static_cast<uint32_t>(map.size());
+        std::copy(map.begin(), map.end(), info.position);
+    }
+
+    return info;
+}
+
+class PipeWirePlayback final : public BackendBase {
+    void stateChangedCallback(pw_stream_state old, pw_stream_state state, const char *error);
+    static void stateChangedCallbackC(void *data, pw_stream_state old, pw_stream_state state,
+        const char *error)
+    { static_cast<PipeWirePlayback*>(data)->stateChangedCallback(old, state, error); }
+
+    void ioChangedCallback(uint32_t id, void *area, uint32_t size);
+    static void ioChangedCallbackC(void *data, uint32_t id, void *area, uint32_t size)
+    { static_cast<PipeWirePlayback*>(data)->ioChangedCallback(id, area, size); }
+
+    void outputCallback();
+    static void outputCallbackC(void *data)
+    { static_cast<PipeWirePlayback*>(data)->outputCallback(); }
+
+    void open(const char *name) override;
+    bool reset() override;
+    void start() override;
+    void stop() override;
+    ClockLatency getClockLatency() override;
+
+    uint64_t mTargetId{PwIdAny};
+    nanoseconds mTimeBase{0};
+    ThreadMainloop mLoop;
+    PwContextPtr mContext;
+    PwCorePtr mCore;
+    PwStreamPtr mStream;
+    spa_hook mStreamListener{};
+    spa_io_rate_match *mRateMatch{};
+    std::unique_ptr<float*[]> mChannelPtrs;
+    uint mNumChannels{};
+
+    static constexpr pw_stream_events CreateEvents()
+    {
+        pw_stream_events ret{};
+        ret.version = PW_VERSION_STREAM_EVENTS;
+        ret.state_changed = &PipeWirePlayback::stateChangedCallbackC;
+        ret.io_changed = &PipeWirePlayback::ioChangedCallbackC;
+        ret.process = &PipeWirePlayback::outputCallbackC;
+        return ret;
+    }
+
+public:
+    PipeWirePlayback(DeviceBase *device) noexcept : BackendBase{device} { }
+    ~PipeWirePlayback()
+    {
+        /* Stop the mainloop so the stream can be properly destroyed. */
+        if(mLoop) mLoop.stop();
+    }
+
+    DEF_NEWDEL(PipeWirePlayback)
+};
+
+
+void PipeWirePlayback::stateChangedCallback(pw_stream_state, pw_stream_state, const char*)
+{ mLoop.signal(false); }
+
+void PipeWirePlayback::ioChangedCallback(uint32_t id, void *area, uint32_t size)
+{
+    switch(id)
+    {
+    case SPA_IO_RateMatch:
+        if(size >= sizeof(spa_io_rate_match))
+            mRateMatch = static_cast<spa_io_rate_match*>(area);
+        break;
+    }
+}
+
+void PipeWirePlayback::outputCallback()
+{
+    pw_buffer *pw_buf{pw_stream_dequeue_buffer(mStream.get())};
+    if(!pw_buf) UNLIKELY return;
+
+    const al::span<spa_data> datas{pw_buf->buffer->datas,
+        minu(mNumChannels, pw_buf->buffer->n_datas)};
+#if PW_CHECK_VERSION(0,3,49)
+    /* In 0.3.49, pw_buffer::requested specifies the number of samples needed
+     * by the resampler/graph for this audio update.
+     */
+    uint length{static_cast<uint>(pw_buf->requested)};
+#else
+    /* In 0.3.48 and earlier, spa_io_rate_match::size apparently has the number
+     * of samples per update.
+     */
+    uint length{mRateMatch ? mRateMatch->size : 0u};
+#endif
+    /* If no length is specified, use the device's update size as a fallback. */
+    if(!length) UNLIKELY length = mDevice->UpdateSize;
+
+    /* For planar formats, each datas[] seems to contain one channel, so store
+     * the pointers in an array. Limit the render length in case the available
+     * buffer length in any one channel is smaller than we wanted (shouldn't
+     * be, but just in case).
+     */
+    float **chanptr_end{mChannelPtrs.get()};
+    for(const auto &data : datas)
+    {
+        length = minu(length, data.maxsize/sizeof(float));
+        *chanptr_end = static_cast<float*>(data.data);
+        ++chanptr_end;
+    }
+
+    mDevice->renderSamples({mChannelPtrs.get(), chanptr_end}, length);
+
+    for(const auto &data : datas)
+    {
+        data.chunk->offset = 0;
+        data.chunk->stride = sizeof(float);
+        data.chunk->size   = length * sizeof(float);
+    }
+    pw_buf->size = length;
+    pw_stream_queue_buffer(mStream.get(), pw_buf);
+}
+
+
+void PipeWirePlayback::open(const char *name)
+{
+    static std::atomic<uint> OpenCount{0};
+
+    uint64_t targetid{PwIdAny};
+    std::string devname{};
+    gEventHandler.waitForInit();
+    if(!name)
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match = devlist.cend();
+        if(!DefaultSinkDevice.empty())
+        {
+            auto match_default = [](const DeviceNode &n) -> bool
+            { return n.mDevName == DefaultSinkDevice; };
+            match = std::find_if(devlist.cbegin(), devlist.cend(), match_default);
+        }
+        if(match == devlist.cend())
+        {
+            auto match_playback = [](const DeviceNode &n) -> bool
+            { return n.mType != NodeType::Source; };
+            match = std::find_if(devlist.cbegin(), devlist.cend(), match_playback);
+            if(match == devlist.cend())
+                throw al::backend_exception{al::backend_error::NoDevice,
+                    "No PipeWire playback device found"};
+        }
+
+        targetid = match->mSerial;
+        devname = match->mName;
+    }
+    else
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match_name = [name](const DeviceNode &n) -> bool
+        { return n.mType != NodeType::Source && n.mName == name; };
+        auto match = std::find_if(devlist.cbegin(), devlist.cend(), match_name);
+        if(match == devlist.cend())
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
+
+        targetid = match->mSerial;
+        devname = match->mName;
+    }
+
+    if(!mLoop)
+    {
+        const uint count{OpenCount.fetch_add(1, std::memory_order_relaxed)};
+        const std::string thread_name{"ALSoftP" + std::to_string(count)};
+        mLoop = ThreadMainloop::Create(thread_name.c_str());
+        if(!mLoop)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to create PipeWire mainloop (errno: %d)", errno};
+        if(int res{mLoop.start()})
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to start PipeWire mainloop (res: %d)", res};
+    }
+    MainloopUniqueLock mlock{mLoop};
+    if(!mContext)
+    {
+        pw_properties *cprops{pw_properties_new(PW_KEY_CONFIG_NAME, "client-rt.conf", nullptr)};
+        mContext = mLoop.newContext(cprops);
+        if(!mContext)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to create PipeWire event context (errno: %d)\n", errno};
+    }
+    if(!mCore)
+    {
+        mCore = PwCorePtr{pw_context_connect(mContext.get(), nullptr, 0)};
+        if(!mCore)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to connect PipeWire event context (errno: %d)\n", errno};
+    }
+    mlock.unlock();
+
+    /* TODO: Ensure the target ID is still valid/usable and accepts streams. */
+
+    mTargetId = targetid;
+    if(!devname.empty())
+        mDevice->DeviceName = std::move(devname);
+    else
+        mDevice->DeviceName = pwireDevice;
+}
+
+bool PipeWirePlayback::reset()
+{
+    if(mStream)
+    {
+        MainloopLockGuard _{mLoop};
+        mStream = nullptr;
+    }
+    mStreamListener = {};
+    mRateMatch = nullptr;
+    mTimeBase = GetDeviceClockTime(mDevice);
+
+    /* If connecting to a specific device, update various device parameters to
+     * match its format.
+     */
+    bool is51rear{false};
+    mDevice->Flags.reset(DirectEar);
+    if(mTargetId != PwIdAny)
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match_id = [targetid=mTargetId](const DeviceNode &n) -> bool
+        { return targetid == n.mSerial; };
+        auto match = std::find_if(devlist.cbegin(), devlist.cend(), match_id);
+        if(match != devlist.cend())
+        {
+            if(!mDevice->Flags.test(FrequencyRequest) && match->mSampleRate > 0)
+            {
+                /* Scale the update size if the sample rate changes. */
+                const double scale{static_cast<double>(match->mSampleRate) / mDevice->Frequency};
+                const double numbufs{static_cast<double>(mDevice->BufferSize)/mDevice->UpdateSize};
+                mDevice->Frequency = match->mSampleRate;
+                mDevice->UpdateSize = static_cast<uint>(clampd(mDevice->UpdateSize*scale + 0.5,
+                    64.0, 8192.0));
+                mDevice->BufferSize = static_cast<uint>(numbufs*mDevice->UpdateSize + 0.5);
+            }
+            if(!mDevice->Flags.test(ChannelsRequest) && match->mChannels != InvalidChannelConfig)
+                mDevice->FmtChans = match->mChannels;
+            if(match->mChannels == DevFmtStereo && match->mIsHeadphones)
+                mDevice->Flags.set(DirectEar);
+            is51rear = match->mIs51Rear;
+        }
+    }
+    /* Force planar 32-bit float output for playback. This is what PipeWire
+     * handles internally, and it's easier for us too.
+     */
+    spa_audio_info_raw info{make_spa_info(mDevice, is51rear, ForceF32Planar)};
+
+    /* TODO: How to tell what an appropriate size is? Examples just use this
+     * magic value.
+     */
+    constexpr uint32_t pod_buffer_size{1024};
+    auto pod_buffer = std::make_unique<al::byte[]>(pod_buffer_size);
+    spa_pod_builder b{make_pod_builder(pod_buffer.get(), pod_buffer_size)};
+
+    const spa_pod *params{spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &info)};
+    if(!params)
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to set PipeWire audio format parameters"};
+
+    /* TODO: Which properties are actually needed here? Any others that could
+     * be useful?
+     */
+    auto&& binary = GetProcBinary();
+    const char *appname{binary.fname.length() ? binary.fname.c_str() : "OpenAL Soft"};
+    pw_properties *props{pw_properties_new(PW_KEY_NODE_NAME, appname,
+        PW_KEY_NODE_DESCRIPTION, appname,
+        PW_KEY_MEDIA_TYPE, "Audio",
+        PW_KEY_MEDIA_CATEGORY, "Playback",
+        PW_KEY_MEDIA_ROLE, "Game",
+        PW_KEY_NODE_ALWAYS_PROCESS, "true",
+        nullptr)};
+    if(!props)
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to create PipeWire stream properties (errno: %d)", errno};
+
+    pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u", mDevice->UpdateSize,
+        mDevice->Frequency);
+    pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", mDevice->Frequency);
+#ifdef PW_KEY_TARGET_OBJECT
+    pw_properties_setf(props, PW_KEY_TARGET_OBJECT, "%" PRIu64, mTargetId);
+#else
+    pw_properties_setf(props, PW_KEY_NODE_TARGET, "%" PRIu64, mTargetId);
+#endif
+
+    MainloopUniqueLock plock{mLoop};
+    /* The stream takes overship of 'props', even in the case of failure. */
+    mStream = PwStreamPtr{pw_stream_new(mCore.get(), "Playback Stream", props)};
+    if(!mStream)
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Failed to create PipeWire stream (errno: %d)", errno};
+    static constexpr pw_stream_events streamEvents{CreateEvents()};
+    pw_stream_add_listener(mStream.get(), &mStreamListener, &streamEvents, this);
+
+    pw_stream_flags flags{PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE
+        | PW_STREAM_FLAG_MAP_BUFFERS};
+    if(GetConfigValueBool(mDevice->DeviceName.c_str(), "pipewire", "rt-mix", true))
+        flags |= PW_STREAM_FLAG_RT_PROCESS;
+    if(int res{pw_stream_connect(mStream.get(), PW_DIRECTION_OUTPUT, PwIdAny, flags, &params, 1)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Error connecting PipeWire stream (res: %d)", res};
+
+    /* Wait for the stream to become paused (ready to start streaming). */
+    plock.wait([stream=mStream.get()]()
+    {
+        const char *error{};
+        pw_stream_state state{pw_stream_get_state(stream, &error)};
+        if(state == PW_STREAM_STATE_ERROR)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Error connecting PipeWire stream: \"%s\"", error};
+        return state == PW_STREAM_STATE_PAUSED;
+    });
+
+    /* TODO: Update mDevice->UpdateSize with the stream's quantum, and
+     * mDevice->BufferSize with the total known buffering delay from the head
+     * of this playback stream to the tail of the device output.
+     *
+     * This info is apparently not available until after the stream starts.
+     */
+    plock.unlock();
+
+    mNumChannels = mDevice->channelsFromFmt();
+    mChannelPtrs = std::make_unique<float*[]>(mNumChannels);
+
+    setDefaultWFXChannelOrder();
+
+    return true;
+}
+
+void PipeWirePlayback::start()
+{
+    MainloopUniqueLock plock{mLoop};
+    if(int res{pw_stream_set_active(mStream.get(), true)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start PipeWire stream (res: %d)", res};
+
+    /* Wait for the stream to start playing (would be nice to not, but we need
+     * the actual update size which is only available after starting).
+     */
+    plock.wait([stream=mStream.get()]()
+    {
+        const char *error{};
+        pw_stream_state state{pw_stream_get_state(stream, &error)};
+        if(state == PW_STREAM_STATE_ERROR)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "PipeWire stream error: %s", error ? error : "(unknown)"};
+        return state == PW_STREAM_STATE_STREAMING;
+    });
+
+    /* HACK: Try to work out the update size and total buffering size. There's
+     * no actual query for this, so we have to work it out from the stream time
+     * info, and assume it stays accurate with future updates. The stream time
+     * info may also not be available right away, so we have to wait until it
+     * is (up to about 2 seconds).
+     */
+    int wait_count{100};
+    do {
+        pw_time ptime{};
+        if(int res{pw_stream_get_time_n(mStream.get(), &ptime, sizeof(ptime))})
+        {
+            ERR("Failed to get PipeWire stream time (res: %d)\n", res);
+            break;
+        }
+
+        /* The rate match size is the update size for each buffer. */
+        const uint updatesize{mRateMatch ? mRateMatch->size : 0u};
+#if PW_CHECK_VERSION(0,3,50)
+        /* Assume ptime.avail_buffers+ptime.queued_buffers is the target buffer
+         * queue size.
+         */
+        if(ptime.rate.denom > 0 && (ptime.avail_buffers || ptime.queued_buffers) && updatesize > 0)
+        {
+            const uint totalbuffers{ptime.avail_buffers + ptime.queued_buffers};
+
+            /* Ensure the delay is in sample frames. */
+            const uint64_t delay{static_cast<uint64_t>(ptime.delay) * mDevice->Frequency *
+                ptime.rate.num / ptime.rate.denom};
+
+            mDevice->UpdateSize = updatesize;
+            mDevice->BufferSize = static_cast<uint>(ptime.buffered + delay +
+                totalbuffers*updatesize);
+            break;
+        }
+#else
+        /* Prior to 0.3.50, we can only measure the delay with the update size,
+         * assuming one buffer and no resample buffering.
+         */
+        if(ptime.rate.denom > 0 && updatesize > 0)
+        {
+            /* Ensure the delay is in sample frames. */
+            const uint64_t delay{static_cast<uint64_t>(ptime.delay) * mDevice->Frequency *
+                ptime.rate.num / ptime.rate.denom};
+
+            mDevice->UpdateSize = updatesize;
+            mDevice->BufferSize = static_cast<uint>(delay + updatesize);
+            break;
+        }
+#endif
+        if(!--wait_count)
+            break;
+
+        plock.unlock();
+        std::this_thread::sleep_for(milliseconds{20});
+        plock.lock();
+    } while(pw_stream_get_state(mStream.get(), nullptr) == PW_STREAM_STATE_STREAMING);
+}
+
+void PipeWirePlayback::stop()
+{
+    MainloopUniqueLock plock{mLoop};
+    if(int res{pw_stream_set_active(mStream.get(), false)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to stop PipeWire stream (res: %d)", res};
+
+    /* Wait for the stream to stop playing. */
+    plock.wait([stream=mStream.get()]()
+    { return pw_stream_get_state(stream, nullptr) != PW_STREAM_STATE_STREAMING; });
+}
+
+ClockLatency PipeWirePlayback::getClockLatency()
+{
+    /* Given a real-time low-latency output, this is rather complicated to get
+     * accurate timing. So, here we go.
+     */
+
+    /* First, get the stream time info (tick delay, ticks played, and the
+     * CLOCK_MONOTONIC time closest to when that last tick was played).
+     */
+    pw_time ptime{};
+    if(mStream)
+    {
+        MainloopLockGuard _{mLoop};
+        if(int res{pw_stream_get_time_n(mStream.get(), &ptime, sizeof(ptime))})
+            ERR("Failed to get PipeWire stream time (res: %d)\n", res);
+    }
+
+    /* Now get the mixer time and the CLOCK_MONOTONIC time atomically (i.e. the
+     * monotonic clock closest to 'now', and the last mixer time at 'now').
+     */
+    nanoseconds mixtime{};
+    timespec tspec{};
+    uint refcount;
+    do {
+        refcount = mDevice->waitForMix();
+        mixtime = GetDeviceClockTime(mDevice);
+        clock_gettime(CLOCK_MONOTONIC, &tspec);
+        std::atomic_thread_fence(std::memory_order_acquire);
+    } while(refcount != ReadRef(mDevice->MixCount));
+
+    /* Convert the monotonic clock, stream ticks, and stream delay to
+     * nanoseconds.
+     */
+    nanoseconds monoclock{seconds{tspec.tv_sec} + nanoseconds{tspec.tv_nsec}};
+    nanoseconds curtic{}, delay{};
+    if(ptime.rate.denom < 1) UNLIKELY
+    {
+        /* If there's no stream rate, the stream hasn't had a chance to get
+         * going and return time info yet. Just use dummy values.
+         */
+        ptime.now = monoclock.count();
+        curtic = mixtime;
+        delay = nanoseconds{seconds{mDevice->BufferSize}} / mDevice->Frequency;
+    }
+    else
+    {
+        /* The stream gets recreated with each reset, so include the time that
+         * had already passed with previous streams.
+         */
+        curtic = mTimeBase;
+        /* More safely scale the ticks to avoid overflowing the pre-division
+         * temporary as it gets larger.
+         */
+        curtic += seconds{ptime.ticks / ptime.rate.denom} * ptime.rate.num;
+        curtic += nanoseconds{seconds{ptime.ticks%ptime.rate.denom} * ptime.rate.num} /
+            ptime.rate.denom;
+
+        /* The delay should be small enough to not worry about overflow. */
+        delay = nanoseconds{seconds{ptime.delay} * ptime.rate.num} / ptime.rate.denom;
+    }
+
+    /* If the mixer time is ahead of the stream time, there's that much more
+     * delay relative to the stream delay.
+     */
+    if(mixtime > curtic)
+        delay += mixtime - curtic;
+    /* Reduce the delay according to how much time has passed since the known
+     * stream time. This isn't 100% accurate since the system monotonic clock
+     * doesn't tick at the exact same rate as the audio device, but it should
+     * be good enough with ptime.now being constantly updated every few
+     * milliseconds with ptime.ticks.
+     */
+    delay -= monoclock - nanoseconds{ptime.now};
+
+    /* Return the mixer time and delay. Clamp the delay to no less than 0,
+     * incase timer drift got that severe.
+     */
+    ClockLatency ret{};
+    ret.ClockTime = mixtime;
+    ret.Latency = std::max(delay, nanoseconds{});
+
+    return ret;
+}
+
+
+class PipeWireCapture final : public BackendBase {
+    void stateChangedCallback(pw_stream_state old, pw_stream_state state, const char *error);
+    static void stateChangedCallbackC(void *data, pw_stream_state old, pw_stream_state state,
+        const char *error)
+    { static_cast<PipeWireCapture*>(data)->stateChangedCallback(old, state, error); }
+
+    void inputCallback();
+    static void inputCallbackC(void *data)
+    { static_cast<PipeWireCapture*>(data)->inputCallback(); }
+
+    void open(const char *name) override;
+    void start() override;
+    void stop() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
+
+    uint64_t mTargetId{PwIdAny};
+    ThreadMainloop mLoop;
+    PwContextPtr mContext;
+    PwCorePtr mCore;
+    PwStreamPtr mStream;
+    spa_hook mStreamListener{};
+
+    RingBufferPtr mRing{};
+
+    static constexpr pw_stream_events CreateEvents()
+    {
+        pw_stream_events ret{};
+        ret.version = PW_VERSION_STREAM_EVENTS;
+        ret.state_changed = &PipeWireCapture::stateChangedCallbackC;
+        ret.process = &PipeWireCapture::inputCallbackC;
+        return ret;
+    }
+
+public:
+    PipeWireCapture(DeviceBase *device) noexcept : BackendBase{device} { }
+    ~PipeWireCapture() { if(mLoop) mLoop.stop(); }
+
+    DEF_NEWDEL(PipeWireCapture)
+};
+
+
+void PipeWireCapture::stateChangedCallback(pw_stream_state, pw_stream_state, const char*)
+{ mLoop.signal(false); }
+
+void PipeWireCapture::inputCallback()
+{
+    pw_buffer *pw_buf{pw_stream_dequeue_buffer(mStream.get())};
+    if(!pw_buf) UNLIKELY return;
+
+    spa_data *bufdata{pw_buf->buffer->datas};
+    const uint offset{minu(bufdata->chunk->offset, bufdata->maxsize)};
+    const uint size{minu(bufdata->chunk->size, bufdata->maxsize - offset)};
+
+    mRing->write(static_cast<char*>(bufdata->data) + offset, size / mRing->getElemSize());
+
+    pw_stream_queue_buffer(mStream.get(), pw_buf);
+}
+
+
+void PipeWireCapture::open(const char *name)
+{
+    static std::atomic<uint> OpenCount{0};
+
+    uint64_t targetid{PwIdAny};
+    std::string devname{};
+    gEventHandler.waitForInit();
+    if(!name)
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match = devlist.cend();
+        if(!DefaultSourceDevice.empty())
+        {
+            auto match_default = [](const DeviceNode &n) -> bool
+            { return n.mDevName == DefaultSourceDevice; };
+            match = std::find_if(devlist.cbegin(), devlist.cend(), match_default);
+        }
+        if(match == devlist.cend())
+        {
+            auto match_capture = [](const DeviceNode &n) -> bool
+            { return n.mType != NodeType::Sink; };
+            match = std::find_if(devlist.cbegin(), devlist.cend(), match_capture);
+        }
+        if(match == devlist.cend())
+        {
+            match = devlist.cbegin();
+            if(match == devlist.cend())
+                throw al::backend_exception{al::backend_error::NoDevice,
+                    "No PipeWire capture device found"};
+        }
+
+        targetid = match->mSerial;
+        if(match->mType != NodeType::Sink) devname = match->mName;
+        else devname = MonitorPrefix+match->mName;
+    }
+    else
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match_name = [name](const DeviceNode &n) -> bool
+        { return n.mType != NodeType::Sink && n.mName == name; };
+        auto match = std::find_if(devlist.cbegin(), devlist.cend(), match_name);
+        if(match == devlist.cend() && std::strncmp(name, MonitorPrefix, MonitorPrefixLen) == 0)
+        {
+            const char *sinkname{name + MonitorPrefixLen};
+            auto match_sinkname = [sinkname](const DeviceNode &n) -> bool
+            { return n.mType == NodeType::Sink && n.mName == sinkname; };
+            match = std::find_if(devlist.cbegin(), devlist.cend(), match_sinkname);
+        }
+        if(match == devlist.cend())
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
+
+        targetid = match->mSerial;
+        devname = name;
+    }
+
+    if(!mLoop)
+    {
+        const uint count{OpenCount.fetch_add(1, std::memory_order_relaxed)};
+        const std::string thread_name{"ALSoftC" + std::to_string(count)};
+        mLoop = ThreadMainloop::Create(thread_name.c_str());
+        if(!mLoop)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to create PipeWire mainloop (errno: %d)", errno};
+        if(int res{mLoop.start()})
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to start PipeWire mainloop (res: %d)", res};
+    }
+    MainloopUniqueLock mlock{mLoop};
+    if(!mContext)
+    {
+        pw_properties *cprops{pw_properties_new(PW_KEY_CONFIG_NAME, "client-rt.conf", nullptr)};
+        mContext = mLoop.newContext(cprops);
+        if(!mContext)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to create PipeWire event context (errno: %d)\n", errno};
+    }
+    if(!mCore)
+    {
+        mCore = PwCorePtr{pw_context_connect(mContext.get(), nullptr, 0)};
+        if(!mCore)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to connect PipeWire event context (errno: %d)\n", errno};
+    }
+    mlock.unlock();
+
+    /* TODO: Ensure the target ID is still valid/usable and accepts streams. */
+
+    mTargetId = targetid;
+    if(!devname.empty())
+        mDevice->DeviceName = std::move(devname);
+    else
+        mDevice->DeviceName = pwireInput;
+
+
+    bool is51rear{false};
+    if(mTargetId != PwIdAny)
+    {
+        EventWatcherLockGuard _{gEventHandler};
+        auto&& devlist = DeviceNode::GetList();
+
+        auto match_id = [targetid=mTargetId](const DeviceNode &n) -> bool
+        { return targetid == n.mSerial; };
+        auto match = std::find_if(devlist.cbegin(), devlist.cend(), match_id);
+        if(match != devlist.cend())
+            is51rear = match->mIs51Rear;
+    }
+    spa_audio_info_raw info{make_spa_info(mDevice, is51rear, UseDevType)};
+
+    constexpr uint32_t pod_buffer_size{1024};
+    auto pod_buffer = std::make_unique<al::byte[]>(pod_buffer_size);
+    spa_pod_builder b{make_pod_builder(pod_buffer.get(), pod_buffer_size)};
+
+    const spa_pod *params[]{spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &info)};
+    if(!params[0])
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to set PipeWire audio format parameters"};
+
+    auto&& binary = GetProcBinary();
+    const char *appname{binary.fname.length() ? binary.fname.c_str() : "OpenAL Soft"};
+    pw_properties *props{pw_properties_new(
+        PW_KEY_NODE_NAME, appname,
+        PW_KEY_NODE_DESCRIPTION, appname,
+        PW_KEY_MEDIA_TYPE, "Audio",
+        PW_KEY_MEDIA_CATEGORY, "Capture",
+        PW_KEY_MEDIA_ROLE, "Game",
+        PW_KEY_NODE_ALWAYS_PROCESS, "true",
+        nullptr)};
+    if(!props)
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to create PipeWire stream properties (errno: %d)", errno};
+
+    /* We don't actually care what the latency/update size is, as long as it's
+     * reasonable. Unfortunately, when unspecified PipeWire seems to default to
+     * around 40ms, which isn't great. So request 20ms instead.
+     */
+    pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%u", (mDevice->Frequency+25) / 50,
+        mDevice->Frequency);
+    pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", mDevice->Frequency);
+#ifdef PW_KEY_TARGET_OBJECT
+    pw_properties_setf(props, PW_KEY_TARGET_OBJECT, "%" PRIu64, mTargetId);
+#else
+    pw_properties_setf(props, PW_KEY_NODE_TARGET, "%" PRIu64, mTargetId);
+#endif
+
+    MainloopUniqueLock plock{mLoop};
+    mStream = PwStreamPtr{pw_stream_new(mCore.get(), "Capture Stream", props)};
+    if(!mStream)
+        throw al::backend_exception{al::backend_error::NoDevice,
+            "Failed to create PipeWire stream (errno: %d)", errno};
+    static constexpr pw_stream_events streamEvents{CreateEvents()};
+    pw_stream_add_listener(mStream.get(), &mStreamListener, &streamEvents, this);
+
+    constexpr pw_stream_flags Flags{PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE
+        | PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS};
+    if(int res{pw_stream_connect(mStream.get(), PW_DIRECTION_INPUT, PwIdAny, Flags, params, 1)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Error connecting PipeWire stream (res: %d)", res};
+
+    /* Wait for the stream to become paused (ready to start streaming). */
+    plock.wait([stream=mStream.get()]()
+    {
+        const char *error{};
+        pw_stream_state state{pw_stream_get_state(stream, &error)};
+        if(state == PW_STREAM_STATE_ERROR)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Error connecting PipeWire stream: \"%s\"", error};
+        return state == PW_STREAM_STATE_PAUSED;
+    });
+    plock.unlock();
+
+    setDefaultWFXChannelOrder();
+
+    /* Ensure at least a 100ms capture buffer. */
+    mRing = RingBuffer::Create(maxu(mDevice->Frequency/10, mDevice->BufferSize),
+        mDevice->frameSizeFromFmt(), false);
+}
+
+
+void PipeWireCapture::start()
+{
+    MainloopUniqueLock plock{mLoop};
+    if(int res{pw_stream_set_active(mStream.get(), true)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start PipeWire stream (res: %d)", res};
+
+    plock.wait([stream=mStream.get()]()
+    {
+        const char *error{};
+        pw_stream_state state{pw_stream_get_state(stream, &error)};
+        if(state == PW_STREAM_STATE_ERROR)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "PipeWire stream error: %s", error ? error : "(unknown)"};
+        return state == PW_STREAM_STATE_STREAMING;
+    });
+}
+
+void PipeWireCapture::stop()
+{
+    MainloopUniqueLock plock{mLoop};
+    if(int res{pw_stream_set_active(mStream.get(), false)})
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to stop PipeWire stream (res: %d)", res};
+
+    plock.wait([stream=mStream.get()]()
+    { return pw_stream_get_state(stream, nullptr) != PW_STREAM_STATE_STREAMING; });
+}
+
+uint PipeWireCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
+
+void PipeWireCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
+
+} // namespace
+
+
+bool PipeWireBackendFactory::init()
+{
+    if(!pwire_load())
+        return false;
+
+    const char *version{pw_get_library_version()};
+    if(!check_version(version))
+    {
+        WARN("PipeWire version \"%s\" too old (%s or newer required)\n", version,
+            pw_get_headers_version());
+        return false;
+    }
+    TRACE("Found PipeWire version \"%s\" (%s or newer)\n", version, pw_get_headers_version());
+
+    pw_init(0, nullptr);
+    if(!gEventHandler.init())
+        return false;
+
+    if(!GetConfigValueBool(nullptr, "pipewire", "assume-audio", false)
+        && !gEventHandler.waitForAudio())
+    {
+        gEventHandler.kill();
+        /* TODO: Temporary warning, until PipeWire gets a proper way to report
+         * audio support.
+         */
+        WARN("No audio support detected in PipeWire. See the PipeWire options in alsoftrc.sample if this is wrong.\n");
+        return false;
+    }
+    return true;
+}
+
+bool PipeWireBackendFactory::querySupport(BackendType type)
+{ return type == BackendType::Playback || type == BackendType::Capture; }
+
+std::string PipeWireBackendFactory::probe(BackendType type)
+{
+    std::string outnames;
+
+    gEventHandler.waitForInit();
+    EventWatcherLockGuard _{gEventHandler};
+    auto&& devlist = DeviceNode::GetList();
+
+    auto match_defsink = [](const DeviceNode &n) -> bool
+    { return n.mDevName == DefaultSinkDevice; };
+    auto match_defsource = [](const DeviceNode &n) -> bool
+    { return n.mDevName == DefaultSourceDevice; };
+
+    auto sort_devnode = [](DeviceNode &lhs, DeviceNode &rhs) noexcept -> bool
+    { return lhs.mId < rhs.mId; };
+    std::sort(devlist.begin(), devlist.end(), sort_devnode);
+
+    auto defmatch = devlist.cbegin();
+    switch(type)
+    {
+    case BackendType::Playback:
+        defmatch = std::find_if(defmatch, devlist.cend(), match_defsink);
+        if(defmatch != devlist.cend())
+        {
+            /* Includes null char. */
+            outnames.append(defmatch->mName.c_str(), defmatch->mName.length()+1);
+        }
+        for(auto iter = devlist.cbegin();iter != devlist.cend();++iter)
+        {
+            if(iter != defmatch && iter->mType != NodeType::Source)
+                outnames.append(iter->mName.c_str(), iter->mName.length()+1);
+        }
+        break;
+    case BackendType::Capture:
+        defmatch = std::find_if(defmatch, devlist.cend(), match_defsource);
+        if(defmatch != devlist.cend())
+        {
+            if(defmatch->mType == NodeType::Sink)
+                outnames.append(MonitorPrefix);
+            outnames.append(defmatch->mName.c_str(), defmatch->mName.length()+1);
+        }
+        for(auto iter = devlist.cbegin();iter != devlist.cend();++iter)
+        {
+            if(iter != defmatch)
+            {
+                if(iter->mType == NodeType::Sink)
+                    outnames.append(MonitorPrefix);
+                outnames.append(iter->mName.c_str(), iter->mName.length()+1);
+            }
+        }
+        break;
+    }
+
+    return outnames;
+}
+
+BackendPtr PipeWireBackendFactory::createBackend(DeviceBase *device, BackendType type)
+{
+    if(type == BackendType::Playback)
+        return BackendPtr{new PipeWirePlayback{device}};
+    if(type == BackendType::Capture)
+        return BackendPtr{new PipeWireCapture{device}};
+    return nullptr;
+}
+
+BackendFactory &PipeWireBackendFactory::getFactory()
+{
+    static PipeWireBackendFactory factory{};
+    return factory;
+}
diff --git a/alc/backends/pipewire.h b/alc/backends/pipewire.h
new file mode 100644
index 00000000..5f930239
--- /dev/null
+++ b/alc/backends/pipewire.h
@@ -0,0 +1,23 @@
+#ifndef BACKENDS_PIPEWIRE_H
+#define BACKENDS_PIPEWIRE_H
+
+#include <string>
+
+#include "base.h"
+
+struct DeviceBase;
+
+struct PipeWireBackendFactory final : public BackendFactory {
+public:
+    bool init() override;
+
+    bool querySupport(BackendType type) override;
+
+    std::string probe(BackendType type) override;
+
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
+
+    static BackendFactory &getFactory();
+};
+
+#endif /* BACKENDS_PIPEWIRE_H */
diff --git a/alc/backends/portaudio.cpp b/alc/backends/portaudio.cpp
index 1e3d0ce8..9c94587d 100644
--- a/alc/backends/portaudio.cpp
+++ b/alc/backends/portaudio.cpp
@@ -20,16 +20,16 @@
 
 #include "config.h"
 
-#include "backends/portaudio.h"
+#include "portaudio.h"
 
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
-#include "alconfig.h"
+#include "alc/alconfig.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/logging.h"
 #include "dynload.h"
 #include "ringbuffer.h"
 
@@ -38,7 +38,7 @@
 
 namespace {
 
-constexpr ALCchar pa_device[] = "PortAudio Default";
+constexpr char pa_device[] = "PortAudio Default";
 
 
 #ifdef HAVE_DYNLOAD
@@ -72,7 +72,7 @@ MAKE_FUNC(Pa_GetStreamInfo);
 
 
 struct PortPlayback final : public BackendBase {
-    PortPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    PortPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~PortPlayback() override;
 
     int writeCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer,
@@ -85,14 +85,14 @@ struct PortPlayback final : public BackendBase {
             framesPerBuffer, timeInfo, statusFlags);
     }
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     PaStream *mStream{nullptr};
     PaStreamParameters mParams{};
-    ALuint mUpdateSize{0u};
+    uint mUpdateSize{0u};
 
     DEF_NEWDEL(PortPlayback)
 };
@@ -109,73 +109,79 @@ PortPlayback::~PortPlayback()
 int PortPlayback::writeCallback(const void*, void *outputBuffer, unsigned long framesPerBuffer,
     const PaStreamCallbackTimeInfo*, const PaStreamCallbackFlags) noexcept
 {
-    std::lock_guard<PortPlayback> _{*this};
-    aluMixData(mDevice, outputBuffer, static_cast<ALuint>(framesPerBuffer));
+    mDevice->renderSamples(outputBuffer, static_cast<uint>(framesPerBuffer),
+        static_cast<uint>(mParams.channelCount));
     return 0;
 }
 
 
-void PortPlayback::open(const ALCchar *name)
+void PortPlayback::open(const char *name)
 {
     if(!name)
         name = pa_device;
     else if(strcmp(name, pa_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
-
-    mUpdateSize = mDevice->UpdateSize;
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
+    PaStreamParameters params{};
     auto devidopt = ConfigValueInt(nullptr, "port", "device");
-    if(devidopt && *devidopt >= 0) mParams.device = *devidopt;
-    else mParams.device = Pa_GetDefaultOutputDevice();
-    mParams.suggestedLatency = mDevice->BufferSize / static_cast<double>(mDevice->Frequency);
-    mParams.hostApiSpecificStreamInfo = nullptr;
+    if(devidopt && *devidopt >= 0) params.device = *devidopt;
+    else params.device = Pa_GetDefaultOutputDevice();
+    params.suggestedLatency = mDevice->BufferSize / static_cast<double>(mDevice->Frequency);
+    params.hostApiSpecificStreamInfo = nullptr;
 
-    mParams.channelCount = ((mDevice->FmtChans == DevFmtMono) ? 1 : 2);
+    params.channelCount = ((mDevice->FmtChans == DevFmtMono) ? 1 : 2);
 
     switch(mDevice->FmtType)
     {
     case DevFmtByte:
-        mParams.sampleFormat = paInt8;
+        params.sampleFormat = paInt8;
         break;
     case DevFmtUByte:
-        mParams.sampleFormat = paUInt8;
+        params.sampleFormat = paUInt8;
         break;
     case DevFmtUShort:
         /* fall-through */
     case DevFmtShort:
-        mParams.sampleFormat = paInt16;
+        params.sampleFormat = paInt16;
         break;
     case DevFmtUInt:
         /* fall-through */
     case DevFmtInt:
-        mParams.sampleFormat = paInt32;
+        params.sampleFormat = paInt32;
         break;
     case DevFmtFloat:
-        mParams.sampleFormat = paFloat32;
+        params.sampleFormat = paFloat32;
         break;
     }
 
 retry_open:
-    PaError err{Pa_OpenStream(&mStream, nullptr, &mParams, mDevice->Frequency, mDevice->UpdateSize,
+    PaStream *stream{};
+    PaError err{Pa_OpenStream(&stream, nullptr, &params, mDevice->Frequency, mDevice->UpdateSize,
         paNoFlag, &PortPlayback::writeCallbackC, this)};
     if(err != paNoError)
     {
-        if(mParams.sampleFormat == paFloat32)
+        if(params.sampleFormat == paFloat32)
         {
-            mParams.sampleFormat = paInt16;
+            params.sampleFormat = paInt16;
             goto retry_open;
         }
-        throw al::backend_exception{ALC_INVALID_VALUE, "Failed to open stream: %s",
+        throw al::backend_exception{al::backend_error::NoDevice, "Failed to open stream: %s",
             Pa_GetErrorText(err)};
     }
 
+    Pa_CloseStream(mStream);
+    mStream = stream;
+    mParams = params;
+    mUpdateSize = mDevice->UpdateSize;
+
     mDevice->DeviceName = name;
 }
 
 bool PortPlayback::reset()
 {
     const PaStreamInfo *streamInfo{Pa_GetStreamInfo(mStream)};
-    mDevice->Frequency = static_cast<ALuint>(streamInfo->sampleRate);
+    mDevice->Frequency = static_cast<uint>(streamInfo->sampleRate);
     mDevice->UpdateSize = mUpdateSize;
 
     if(mParams.sampleFormat == paInt8)
@@ -194,7 +200,7 @@ bool PortPlayback::reset()
         return false;
     }
 
-    if(mParams.channelCount == 2)
+    if(mParams.channelCount >= 2)
         mDevice->FmtChans = DevFmtStereo;
     else if(mParams.channelCount == 1)
         mDevice->FmtChans = DevFmtMono;
@@ -203,20 +209,17 @@ bool PortPlayback::reset()
         ERR("Unexpected channel count: %u\n", mParams.channelCount);
         return false;
     }
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     return true;
 }
 
-bool PortPlayback::start()
+void PortPlayback::start()
 {
-    PaError err{Pa_StartStream(mStream)};
-    if(err != paNoError)
-    {
-        ERR("Pa_StartStream() returned an error: %s\n", Pa_GetErrorText(err));
-        return false;
-    }
-    return true;
+    const PaError err{Pa_StartStream(mStream)};
+    if(err == paNoError)
+        throw al::backend_exception{al::backend_error::DeviceError, "Failed to start playback: %s",
+            Pa_GetErrorText(err)};
 }
 
 void PortPlayback::stop()
@@ -228,7 +231,7 @@ void PortPlayback::stop()
 
 
 struct PortCapture final : public BackendBase {
-    PortCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    PortCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~PortCapture() override;
 
     int readCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer,
@@ -241,11 +244,11 @@ struct PortCapture final : public BackendBase {
             framesPerBuffer, timeInfo, statusFlags);
     }
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
     PaStream *mStream{nullptr};
     PaStreamParameters mParams;
@@ -272,18 +275,19 @@ int PortCapture::readCallback(const void *inputBuffer, void*, unsigned long fram
 }
 
 
-void PortCapture::open(const ALCchar *name)
+void PortCapture::open(const char *name)
 {
     if(!name)
         name = pa_device;
     else if(strcmp(name, pa_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
-    ALuint samples{mDevice->BufferSize};
+    uint samples{mDevice->BufferSize};
     samples = maxu(samples, 100 * mDevice->Frequency / 1000);
-    ALuint frame_size{mDevice->frameSizeFromFmt()};
+    uint frame_size{mDevice->frameSizeFromFmt()};
 
-    mRing = CreateRingBuffer(samples, frame_size, false);
+    mRing = RingBuffer::Create(samples, frame_size, false);
 
     auto devidopt = ConfigValueInt(nullptr, "port", "capture");
     if(devidopt && *devidopt >= 0) mParams.device = *devidopt;
@@ -310,7 +314,7 @@ void PortCapture::open(const ALCchar *name)
         break;
     case DevFmtUInt:
     case DevFmtUShort:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s samples not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s samples not supported",
             DevFmtTypeString(mDevice->FmtType)};
     }
     mParams.channelCount = static_cast<int>(mDevice->channelsFromFmt());
@@ -318,22 +322,19 @@ void PortCapture::open(const ALCchar *name)
     PaError err{Pa_OpenStream(&mStream, &mParams, nullptr, mDevice->Frequency,
         paFramesPerBufferUnspecified, paNoFlag, &PortCapture::readCallbackC, this)};
     if(err != paNoError)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Failed to open stream: %s",
+        throw al::backend_exception{al::backend_error::NoDevice, "Failed to open stream: %s",
             Pa_GetErrorText(err)};
 
     mDevice->DeviceName = name;
 }
 
 
-bool PortCapture::start()
+void PortCapture::start()
 {
-    PaError err{Pa_StartStream(mStream)};
+    const PaError err{Pa_StartStream(mStream)};
     if(err != paNoError)
-    {
-        ERR("Error starting stream: %s\n", Pa_GetErrorText(err));
-        return false;
-    }
-    return true;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start recording: %s", Pa_GetErrorText(err)};
 }
 
 void PortCapture::stop()
@@ -344,14 +345,11 @@ void PortCapture::stop()
 }
 
 
-ALCuint PortCapture::availableSamples()
-{ return static_cast<ALCuint>(mRing->readSpace()); }
+uint PortCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
 
-ALCenum PortCapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+void PortCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
 } // namespace
 
@@ -419,19 +417,21 @@ bool PortBackendFactory::init()
 bool PortBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void PortBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string PortBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-        case DevProbe::Capture:
-            /* Includes null char. */
-            outnames->append(pa_device, sizeof(pa_device));
-            break;
+    case BackendType::Playback:
+    case BackendType::Capture:
+        /* Includes null char. */
+        outnames.append(pa_device, sizeof(pa_device));
+        break;
     }
+    return outnames;
 }
 
-BackendPtr PortBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr PortBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new PortPlayback{device}};
diff --git a/alc/backends/portaudio.h b/alc/backends/portaudio.h
index 082e9020..c35ccff2 100644
--- a/alc/backends/portaudio.h
+++ b/alc/backends/portaudio.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_PORTAUDIO_H
 #define BACKENDS_PORTAUDIO_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct PortBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/pulseaudio.cpp b/alc/backends/pulseaudio.cpp
index 4e46460b..4b0e316f 100644
--- a/alc/backends/pulseaudio.cpp
+++ b/alc/backends/pulseaudio.cpp
@@ -21,41 +21,45 @@
 
 #include "config.h"
 
-#include "backends/pulseaudio.h"
-
-#include <poll.h>
-#include <cstring>
+#include "pulseaudio.h"
 
+#include <algorithm>
 #include <array>
-#include <string>
-#include <vector>
 #include <atomic>
-#include <thread>
-#include <algorithm>
-#include <functional>
-#include <condition_variable>
-
-#include "alcmain.h"
-#include "alu.h"
-#include "alconfig.h"
-#include "alexcpt.h"
-#include "compat.h"
+#include <bitset>
+#include <chrono>
+#include <cstring>
+#include <limits>
+#include <mutex>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string>
+#include <sys/types.h>
+#include <utility>
+
+#include "albyte.h"
+#include "alc/alconfig.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/logging.h"
 #include "dynload.h"
+#include "opthelpers.h"
 #include "strutils.h"
+#include "vector.h"
 
 #include <pulse/pulseaudio.h>
 
 
 namespace {
 
+using uint = unsigned int;
+
 #ifdef HAVE_DYNLOAD
 #define PULSE_FUNCS(MAGIC)                                                    \
-    MAGIC(pa_mainloop_new);                                                   \
-    MAGIC(pa_mainloop_free);                                                  \
-    MAGIC(pa_mainloop_set_poll_func);                                         \
-    MAGIC(pa_mainloop_run);                                                   \
-    MAGIC(pa_mainloop_quit);                                                  \
-    MAGIC(pa_mainloop_get_api);                                               \
     MAGIC(pa_context_new);                                                    \
     MAGIC(pa_context_unref);                                                  \
     MAGIC(pa_context_get_state);                                              \
@@ -96,11 +100,21 @@ namespace {
     MAGIC(pa_stream_disconnect);                                              \
     MAGIC(pa_stream_set_buffer_attr_callback);                                \
     MAGIC(pa_stream_begin_write);                                             \
+    MAGIC(pa_threaded_mainloop_free);                                         \
+    MAGIC(pa_threaded_mainloop_get_api);                                      \
+    MAGIC(pa_threaded_mainloop_lock);                                         \
+    MAGIC(pa_threaded_mainloop_new);                                          \
+    MAGIC(pa_threaded_mainloop_signal);                                       \
+    MAGIC(pa_threaded_mainloop_start);                                        \
+    MAGIC(pa_threaded_mainloop_stop);                                         \
+    MAGIC(pa_threaded_mainloop_unlock);                                       \
+    MAGIC(pa_threaded_mainloop_wait);                                         \
     MAGIC(pa_channel_map_init_auto);                                          \
     MAGIC(pa_channel_map_parse);                                              \
     MAGIC(pa_channel_map_snprint);                                            \
     MAGIC(pa_channel_map_equal);                                              \
     MAGIC(pa_channel_map_superset);                                           \
+    MAGIC(pa_channel_position_to_string);                                     \
     MAGIC(pa_operation_get_state);                                            \
     MAGIC(pa_operation_unref);                                                \
     MAGIC(pa_sample_spec_valid);                                              \
@@ -117,12 +131,6 @@ PULSE_FUNCS(MAKE_FUNC)
 #undef MAKE_FUNC
 
 #ifndef IN_IDE_PARSER
-#define pa_mainloop_new ppa_mainloop_new
-#define pa_mainloop_free ppa_mainloop_free
-#define pa_mainloop_set_poll_func ppa_mainloop_set_poll_func
-#define pa_mainloop_run ppa_mainloop_run
-#define pa_mainloop_quit ppa_mainloop_quit
-#define pa_mainloop_get_api ppa_mainloop_get_api
 #define pa_context_new ppa_context_new
 #define pa_context_unref ppa_context_unref
 #define pa_context_get_state ppa_context_get_state
@@ -158,12 +166,22 @@ PULSE_FUNCS(MAKE_FUNC)
 #define pa_stream_get_device_name ppa_stream_get_device_name
 #define pa_stream_get_latency ppa_stream_get_latency
 #define pa_stream_set_buffer_attr_callback ppa_stream_set_buffer_attr_callback
-#define pa_stream_begin_write ppa_stream_begin_write*/
+#define pa_stream_begin_write ppa_stream_begin_write
+#define pa_threaded_mainloop_free ppa_threaded_mainloop_free
+#define pa_threaded_mainloop_get_api ppa_threaded_mainloop_get_api
+#define pa_threaded_mainloop_lock ppa_threaded_mainloop_lock
+#define pa_threaded_mainloop_new ppa_threaded_mainloop_new
+#define pa_threaded_mainloop_signal ppa_threaded_mainloop_signal
+#define pa_threaded_mainloop_start ppa_threaded_mainloop_start
+#define pa_threaded_mainloop_stop ppa_threaded_mainloop_stop
+#define pa_threaded_mainloop_unlock ppa_threaded_mainloop_unlock
+#define pa_threaded_mainloop_wait ppa_threaded_mainloop_wait
 #define pa_channel_map_init_auto ppa_channel_map_init_auto
 #define pa_channel_map_parse ppa_channel_map_parse
 #define pa_channel_map_snprint ppa_channel_map_snprint
 #define pa_channel_map_equal ppa_channel_map_equal
 #define pa_channel_map_superset ppa_channel_map_superset
+#define pa_channel_position_to_string ppa_channel_position_to_string
 #define pa_operation_get_state ppa_operation_get_state
 #define pa_operation_unref ppa_operation_unref
 #define pa_sample_spec_valid ppa_sample_spec_valid
@@ -216,211 +234,221 @@ constexpr pa_channel_map MonoChanMap{
         PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
         PA_CHANNEL_POSITION_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_RIGHT
     }
-};
-
-size_t ChannelFromPulse(pa_channel_position_t chan)
-{
-    switch(chan)
-    {
-    case PA_CHANNEL_POSITION_INVALID: break;
-    case PA_CHANNEL_POSITION_MONO: return FrontCenter;
-    case PA_CHANNEL_POSITION_FRONT_LEFT: return FrontLeft;
-    case PA_CHANNEL_POSITION_FRONT_RIGHT: return FrontRight;
-    case PA_CHANNEL_POSITION_FRONT_CENTER: return FrontCenter;
-    case PA_CHANNEL_POSITION_REAR_CENTER: return BackCenter;
-    case PA_CHANNEL_POSITION_REAR_LEFT: return BackLeft;
-    case PA_CHANNEL_POSITION_REAR_RIGHT: return BackRight;
-    case PA_CHANNEL_POSITION_LFE: return LFE;
-    case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER: break;
-    case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER: break;
-    case PA_CHANNEL_POSITION_SIDE_LEFT: return SideLeft;
-    case PA_CHANNEL_POSITION_SIDE_RIGHT: return SideRight;
-    case PA_CHANNEL_POSITION_AUX0: return Aux0;
-    case PA_CHANNEL_POSITION_AUX1: return Aux1;
-    case PA_CHANNEL_POSITION_AUX2: return Aux2;
-    case PA_CHANNEL_POSITION_AUX3: return Aux3;
-    case PA_CHANNEL_POSITION_AUX4: return Aux4;
-    case PA_CHANNEL_POSITION_AUX5: return Aux5;
-    case PA_CHANNEL_POSITION_AUX6: return Aux6;
-    case PA_CHANNEL_POSITION_AUX7: return Aux7;
-    case PA_CHANNEL_POSITION_AUX8: return Aux8;
-    case PA_CHANNEL_POSITION_AUX9: return Aux9;
-    case PA_CHANNEL_POSITION_AUX10: return Aux10;
-    case PA_CHANNEL_POSITION_AUX11: return Aux11;
-    case PA_CHANNEL_POSITION_AUX12: return Aux12;
-    case PA_CHANNEL_POSITION_AUX13: return Aux13;
-    case PA_CHANNEL_POSITION_AUX14: return Aux14;
-    case PA_CHANNEL_POSITION_AUX15: return Aux15;
-    case PA_CHANNEL_POSITION_AUX16: break;
-    case PA_CHANNEL_POSITION_AUX17: break;
-    case PA_CHANNEL_POSITION_AUX18: break;
-    case PA_CHANNEL_POSITION_AUX19: break;
-    case PA_CHANNEL_POSITION_AUX20: break;
-    case PA_CHANNEL_POSITION_AUX21: break;
-    case PA_CHANNEL_POSITION_AUX22: break;
-    case PA_CHANNEL_POSITION_AUX23: break;
-    case PA_CHANNEL_POSITION_AUX24: break;
-    case PA_CHANNEL_POSITION_AUX25: break;
-    case PA_CHANNEL_POSITION_AUX26: break;
-    case PA_CHANNEL_POSITION_AUX27: break;
-    case PA_CHANNEL_POSITION_AUX28: break;
-    case PA_CHANNEL_POSITION_AUX29: break;
-    case PA_CHANNEL_POSITION_AUX30: break;
-    case PA_CHANNEL_POSITION_AUX31: break;
-    case PA_CHANNEL_POSITION_TOP_CENTER: break;
-    case PA_CHANNEL_POSITION_TOP_FRONT_LEFT: return UpperFrontLeft;
-    case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT: return UpperFrontRight;
-    case PA_CHANNEL_POSITION_TOP_FRONT_CENTER: break;
-    case PA_CHANNEL_POSITION_TOP_REAR_LEFT: return UpperBackLeft;
-    case PA_CHANNEL_POSITION_TOP_REAR_RIGHT: return UpperBackRight;
-    case PA_CHANNEL_POSITION_TOP_REAR_CENTER: break;
-    case PA_CHANNEL_POSITION_MAX: break;
+}, X714ChanMap{
+    12, {
+        PA_CHANNEL_POSITION_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_RIGHT,
+        PA_CHANNEL_POSITION_FRONT_CENTER, PA_CHANNEL_POSITION_LFE,
+        PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT,
+        PA_CHANNEL_POSITION_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_RIGHT,
+        PA_CHANNEL_POSITION_TOP_FRONT_LEFT, PA_CHANNEL_POSITION_TOP_FRONT_RIGHT,
+        PA_CHANNEL_POSITION_TOP_REAR_LEFT, PA_CHANNEL_POSITION_TOP_REAR_RIGHT
     }
-    throw al::backend_exception{ALC_INVALID_VALUE, "Unexpected channel enum %d", chan};
-}
-
-void SetChannelOrderFromMap(ALCdevice *device, const pa_channel_map &chanmap)
-{
-    device->RealOut.ChannelIndex.fill(INVALID_CHANNEL_INDEX);
-    for(ALuint i{0};i < chanmap.channels;++i)
-        device->RealOut.ChannelIndex[ChannelFromPulse(chanmap.map[i])] = i;
-}
+};
 
 
 /* *grumble* Don't use enums for bitflags. */
-constexpr inline pa_stream_flags_t operator|(pa_stream_flags_t lhs, pa_stream_flags_t rhs)
-{ return pa_stream_flags_t(int(lhs) | int(rhs)); }
-inline pa_stream_flags_t& operator|=(pa_stream_flags_t &lhs, pa_stream_flags_t rhs)
+constexpr pa_stream_flags_t operator|(pa_stream_flags_t lhs, pa_stream_flags_t rhs)
+{ return pa_stream_flags_t(lhs | al::to_underlying(rhs)); }
+constexpr pa_stream_flags_t& operator|=(pa_stream_flags_t &lhs, pa_stream_flags_t rhs)
 {
     lhs = lhs | rhs;
     return lhs;
 }
-inline pa_stream_flags_t& operator&=(pa_stream_flags_t &lhs, int rhs)
+constexpr pa_stream_flags_t operator~(pa_stream_flags_t flag)
+{ return pa_stream_flags_t(~al::to_underlying(flag)); }
+constexpr pa_stream_flags_t& operator&=(pa_stream_flags_t &lhs, pa_stream_flags_t rhs)
 {
-    lhs = pa_stream_flags_t(int(lhs) & rhs);
+    lhs = pa_stream_flags_t(al::to_underlying(lhs) & rhs);
     return lhs;
 }
 
-inline pa_context_flags_t& operator|=(pa_context_flags_t &lhs, pa_context_flags_t rhs)
+constexpr pa_context_flags_t operator|(pa_context_flags_t lhs, pa_context_flags_t rhs)
+{ return pa_context_flags_t(lhs | al::to_underlying(rhs)); }
+constexpr pa_context_flags_t& operator|=(pa_context_flags_t &lhs, pa_context_flags_t rhs)
 {
-    lhs = pa_context_flags_t(int(lhs) | int(rhs));
+    lhs = lhs | rhs;
     return lhs;
 }
 
 
-/* Global flags and properties */
-pa_context_flags_t pulse_ctx_flags;
+struct DevMap {
+    std::string name;
+    std::string device_name;
+};
 
-int pulse_poll_func(struct pollfd *ufds, unsigned long nfds, int timeout, void *userdata) noexcept
+bool checkName(const al::span<const DevMap> list, const std::string &name)
 {
-    auto plock = static_cast<std::unique_lock<std::mutex>*>(userdata);
-    plock->unlock();
-    int r{poll(ufds, nfds, timeout)};
-    plock->lock();
-    return r;
+    auto match_name = [&name](const DevMap &entry) -> bool { return entry.name == name; };
+    return std::find_if(list.cbegin(), list.cend(), match_name) != list.cend();
 }
 
+al::vector<DevMap> PlaybackDevices;
+al::vector<DevMap> CaptureDevices;
+
+
+/* Global flags and properties */
+pa_context_flags_t pulse_ctx_flags;
+
 class PulseMainloop {
-    std::thread mThread;
-    std::mutex mMutex;
-    std::condition_variable mCondVar;
-    pa_mainloop *mMainloop{nullptr};
+    pa_threaded_mainloop *mLoop{};
 
 public:
-    ~PulseMainloop()
+    PulseMainloop() = default;
+    PulseMainloop(const PulseMainloop&) = delete;
+    PulseMainloop(PulseMainloop&& rhs) noexcept : mLoop{rhs.mLoop} { rhs.mLoop = nullptr; }
+    explicit PulseMainloop(pa_threaded_mainloop *loop) noexcept : mLoop{loop} { }
+    ~PulseMainloop() { if(mLoop) pa_threaded_mainloop_free(mLoop); }
+
+    PulseMainloop& operator=(const PulseMainloop&) = delete;
+    PulseMainloop& operator=(PulseMainloop&& rhs) noexcept
+    { std::swap(mLoop, rhs.mLoop); return *this; }
+    PulseMainloop& operator=(std::nullptr_t) noexcept
     {
-        if(mThread.joinable())
-        {
-            pa_mainloop_quit(mMainloop, 0);
-            mThread.join();
-        }
+        if(mLoop)
+            pa_threaded_mainloop_free(mLoop);
+        mLoop = nullptr;
+        return *this;
     }
 
-    int mainloop_thread()
-    {
-        SetRTPriority();
+    explicit operator bool() const noexcept { return mLoop != nullptr; }
 
-        std::unique_lock<std::mutex> plock{mMutex};
-        mMainloop = pa_mainloop_new();
+    auto start() const { return pa_threaded_mainloop_start(mLoop); }
+    auto stop() const { return pa_threaded_mainloop_stop(mLoop); }
 
-        pa_mainloop_set_poll_func(mMainloop, pulse_poll_func, &plock);
-        mCondVar.notify_all();
+    auto getApi() const { return pa_threaded_mainloop_get_api(mLoop); }
 
-        int ret{};
-        pa_mainloop_run(mMainloop, &ret);
+    auto lock() const { return pa_threaded_mainloop_lock(mLoop); }
+    auto unlock() const { return pa_threaded_mainloop_unlock(mLoop); }
 
-        pa_mainloop_free(mMainloop);
-        mMainloop = nullptr;
+    auto signal(bool wait=false) const { return pa_threaded_mainloop_signal(mLoop, wait); }
 
-        return ret;
-    }
+    static auto Create() { return PulseMainloop{pa_threaded_mainloop_new()}; }
 
-    void doLock() { mMutex.lock(); }
-    void doUnlock() { mMutex.unlock(); }
-    std::unique_lock<std::mutex> getLock() { return std::unique_lock<std::mutex>{mMutex}; }
-    std::condition_variable &getCondVar() noexcept { return mCondVar; }
 
-    void contextStateCallback(pa_context *context) noexcept
+    void streamSuccessCallback(pa_stream*, int) noexcept { signal(); }
+    static void streamSuccessCallbackC(pa_stream *stream, int success, void *pdata) noexcept
+    { static_cast<PulseMainloop*>(pdata)->streamSuccessCallback(stream, success); }
+
+    void close(pa_context *context, pa_stream *stream=nullptr);
+
+
+    void deviceSinkCallback(pa_context*, const pa_sink_info *info, int eol) noexcept
     {
-        pa_context_state_t state{pa_context_get_state(context)};
-        if(state == PA_CONTEXT_READY || !PA_CONTEXT_IS_GOOD(state))
-            mCondVar.notify_all();
+        if(eol)
+        {
+            signal();
+            return;
+        }
+
+        /* Skip this device is if it's already in the list. */
+        auto match_devname = [info](const DevMap &entry) -> bool
+        { return entry.device_name == info->name; };
+        if(std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(), match_devname) != PlaybackDevices.cend())
+            return;
+
+        /* Make sure the display name (description) is unique. Append a number
+         * counter as needed.
+         */
+        int count{1};
+        std::string newname{info->description};
+        while(checkName(PlaybackDevices, newname))
+        {
+            newname = info->description;
+            newname += " #";
+            newname += std::to_string(++count);
+        }
+        PlaybackDevices.emplace_back(DevMap{std::move(newname), info->name});
+        DevMap &newentry = PlaybackDevices.back();
+
+        TRACE("Got device \"%s\", \"%s\"\n", newentry.name.c_str(), newentry.device_name.c_str());
     }
-    static void contextStateCallbackC(pa_context *context, void *pdata) noexcept
-    { static_cast<PulseMainloop*>(pdata)->contextStateCallback(context); }
 
-    void streamStateCallback(pa_stream *stream) noexcept
+    void deviceSourceCallback(pa_context*, const pa_source_info *info, int eol) noexcept
     {
-        pa_stream_state_t state{pa_stream_get_state(stream)};
-        if(state == PA_STREAM_READY || !PA_STREAM_IS_GOOD(state))
-            mCondVar.notify_all();
+        if(eol)
+        {
+            signal();
+            return;
+        }
+
+        /* Skip this device is if it's already in the list. */
+        auto match_devname = [info](const DevMap &entry) -> bool
+        { return entry.device_name == info->name; };
+        if(std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(), match_devname) != CaptureDevices.cend())
+            return;
+
+        /* Make sure the display name (description) is unique. Append a number
+         * counter as needed.
+         */
+        int count{1};
+        std::string newname{info->description};
+        while(checkName(CaptureDevices, newname))
+        {
+            newname = info->description;
+            newname += " #";
+            newname += std::to_string(++count);
+        }
+        CaptureDevices.emplace_back(DevMap{std::move(newname), info->name});
+        DevMap &newentry = CaptureDevices.back();
+
+        TRACE("Got device \"%s\", \"%s\"\n", newentry.name.c_str(), newentry.device_name.c_str());
     }
-    static void streamStateCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulseMainloop*>(pdata)->streamStateCallback(stream); }
 
-    void streamSuccessCallback(pa_stream*, int) noexcept
-    { mCondVar.notify_all(); }
-    static void streamSuccessCallbackC(pa_stream *stream, int success, void *pdata) noexcept
-    { static_cast<PulseMainloop*>(pdata)->streamSuccessCallback(stream, success); }
+    void probePlaybackDevices();
+    void probeCaptureDevices();
+
+    friend struct MainloopUniqueLock;
+};
+struct MainloopUniqueLock : public std::unique_lock<PulseMainloop> {
+    using std::unique_lock<PulseMainloop>::unique_lock;
+    MainloopUniqueLock& operator=(MainloopUniqueLock&&) = default;
+
+    auto wait() const -> void
+    { pa_threaded_mainloop_wait(mutex()->mLoop); }
 
-    void waitForOperation(pa_operation *op, std::unique_lock<std::mutex> &plock)
+    template<typename Predicate>
+    auto wait(Predicate done_waiting) const -> void
+    { while(!done_waiting()) wait(); }
+
+    void waitForOperation(pa_operation *op)
     {
         if(op)
         {
-            while(pa_operation_get_state(op) == PA_OPERATION_RUNNING)
-                mCondVar.wait(plock);
+            wait([op]{ return pa_operation_get_state(op) != PA_OPERATION_RUNNING; });
             pa_operation_unref(op);
         }
     }
 
-    pa_context *connectContext(std::unique_lock<std::mutex> &plock);
 
-    pa_stream *connectStream(const char *device_name, std::unique_lock<std::mutex> &plock,
-        pa_context *context, pa_stream_flags_t flags, pa_buffer_attr *attr, pa_sample_spec *spec,
-        pa_channel_map *chanmap, BackendType type);
+    void contextStateCallback(pa_context *context) noexcept
+    {
+        pa_context_state_t state{pa_context_get_state(context)};
+        if(state == PA_CONTEXT_READY || !PA_CONTEXT_IS_GOOD(state))
+            mutex()->signal();
+    }
 
-    void close(pa_context *context, pa_stream *stream);
+    void streamStateCallback(pa_stream *stream) noexcept
+    {
+        pa_stream_state_t state{pa_stream_get_state(stream)};
+        if(state == PA_STREAM_READY || !PA_STREAM_IS_GOOD(state))
+            mutex()->signal();
+    }
+
+    pa_context *connectContext();
+    pa_stream *connectStream(const char *device_name, pa_context *context, pa_stream_flags_t flags,
+        pa_buffer_attr *attr, pa_sample_spec *spec, pa_channel_map *chanmap, BackendType type);
 };
+using MainloopLockGuard = std::lock_guard<PulseMainloop>;
 
 
-pa_context *PulseMainloop::connectContext(std::unique_lock<std::mutex> &plock)
+pa_context *MainloopUniqueLock::connectContext()
 {
-    const char *name{"OpenAL Soft"};
+    pa_context *context{pa_context_new(mutex()->getApi(), nullptr)};
+    if(!context) throw al::backend_exception{al::backend_error::OutOfMemory,
+        "pa_context_new() failed"};
 
-    const PathNamePair &binname = GetProcBinary();
-    if(!binname.fname.empty())
-        name = binname.fname.c_str();
-
-    if(!mMainloop)
-    {
-        mThread = std::thread{std::mem_fn(&PulseMainloop::mainloop_thread), this};
-        while(!mMainloop) mCondVar.wait(plock);
-    }
-
-    pa_context *context{pa_context_new(pa_mainloop_get_api(mMainloop), name)};
-    if(!context) throw al::backend_exception{ALC_OUT_OF_MEMORY, "pa_context_new() failed"};
-
-    pa_context_set_state_callback(context, &contextStateCallbackC, this);
+    pa_context_set_state_callback(context, [](pa_context *ctx, void *pdata) noexcept
+    { return static_cast<MainloopUniqueLock*>(pdata)->contextStateCallback(ctx); }, this);
 
     int err;
     if((err=pa_context_connect(context, nullptr, pulse_ctx_flags, nullptr)) >= 0)
@@ -435,7 +463,7 @@ pa_context *PulseMainloop::connectContext(std::unique_lock<std::mutex> &plock)
                 break;
             }
 
-            mCondVar.wait(plock);
+            wait();
         }
     }
     pa_context_set_state_callback(context, nullptr, nullptr);
@@ -443,24 +471,25 @@ pa_context *PulseMainloop::connectContext(std::unique_lock<std::mutex> &plock)
     if(err < 0)
     {
         pa_context_unref(context);
-        throw al::backend_exception{ALC_INVALID_VALUE, "Context did not connect (%s)",
+        throw al::backend_exception{al::backend_error::DeviceError, "Context did not connect (%s)",
             pa_strerror(err)};
     }
 
     return context;
 }
 
-pa_stream *PulseMainloop::connectStream(const char *device_name,
-    std::unique_lock<std::mutex> &plock, pa_context *context, pa_stream_flags_t flags,
-    pa_buffer_attr *attr, pa_sample_spec *spec, pa_channel_map *chanmap, BackendType type)
+pa_stream *MainloopUniqueLock::connectStream(const char *device_name, pa_context *context,
+    pa_stream_flags_t flags, pa_buffer_attr *attr, pa_sample_spec *spec, pa_channel_map *chanmap,
+    BackendType type)
 {
     const char *stream_id{(type==BackendType::Playback) ? "Playback Stream" : "Capture Stream"};
     pa_stream *stream{pa_stream_new(context, stream_id, spec, chanmap)};
     if(!stream)
-        throw al::backend_exception{ALC_OUT_OF_MEMORY, "pa_stream_new() failed (%s)",
+        throw al::backend_exception{al::backend_error::OutOfMemory, "pa_stream_new() failed (%s)",
             pa_strerror(pa_context_errno(context))};
 
-    pa_stream_set_state_callback(stream, &streamStateCallbackC, this);
+    pa_stream_set_state_callback(stream, [](pa_stream *strm, void *pdata) noexcept
+    { return static_cast<MainloopUniqueLock*>(pdata)->streamStateCallback(strm); }, this);
 
     int err{(type==BackendType::Playback) ?
         pa_stream_connect_playback(stream, device_name, attr, flags, nullptr, nullptr) :
@@ -468,8 +497,8 @@ pa_stream *PulseMainloop::connectStream(const char *device_name,
     if(err < 0)
     {
         pa_stream_unref(stream);
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s did not connect (%s)", stream_id,
-            pa_strerror(err)};
+        throw al::backend_exception{al::backend_error::DeviceError, "%s did not connect (%s)",
+            stream_id, pa_strerror(err)};
     }
 
     pa_stream_state_t state;
@@ -479,11 +508,11 @@ pa_stream *PulseMainloop::connectStream(const char *device_name,
         {
             err = pa_context_errno(context);
             pa_stream_unref(stream);
-            throw al::backend_exception{ALC_INVALID_VALUE, "%s did not get ready (%s)", stream_id,
-                pa_strerror(err)};
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "%s did not get ready (%s)", stream_id, pa_strerror(err)};
         }
 
-        mCondVar.wait(plock);
+        wait();
     }
     pa_stream_set_state_callback(stream, nullptr, nullptr);
 
@@ -492,7 +521,7 @@ pa_stream *PulseMainloop::connectStream(const char *device_name,
 
 void PulseMainloop::close(pa_context *context, pa_stream *stream)
 {
-    std::lock_guard<std::mutex> _{mMutex};
+    MainloopUniqueLock _{*this};
     if(stream)
     {
         pa_stream_set_state_callback(stream, nullptr, nullptr);
@@ -508,88 +537,22 @@ void PulseMainloop::close(pa_context *context, pa_stream *stream)
 }
 
 
-/* Used for initial connection test and enumeration. */
-PulseMainloop gGlobalMainloop;
-
-
-struct DevMap {
-    std::string name;
-    std::string device_name;
-};
-
-bool checkName(const al::vector<DevMap> &list, const std::string &name)
-{
-    auto match_name = [&name](const DevMap &entry) -> bool { return entry.name == name; };
-    return std::find_if(list.cbegin(), list.cend(), match_name) != list.cend();
-}
-
-al::vector<DevMap> PlaybackDevices;
-al::vector<DevMap> CaptureDevices;
-
-
-void device_sink_callback(pa_context*, const pa_sink_info *info, int eol, void *pdata) noexcept
-{
-    if(eol)
-    {
-        static_cast<PulseMainloop*>(pdata)->getCondVar().notify_all();
-        return;
-    }
-
-    /* Skip this device is if it's already in the list. */
-    if(std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-        [info](const DevMap &entry) -> bool
-        { return entry.device_name == info->name; }
-    ) != PlaybackDevices.cend())
-        return;
-
-    /* Make sure the display name (description) is unique. Append a number
-     * counter as needed.
-     */
-    int count{1};
-    std::string newname{info->description};
-    while(checkName(PlaybackDevices, newname))
-    {
-        newname = info->description;
-        newname += " #";
-        newname += std::to_string(++count);
-    }
-    PlaybackDevices.emplace_back(DevMap{std::move(newname), info->name});
-    DevMap &newentry = PlaybackDevices.back();
-
-    TRACE("Got device \"%s\", \"%s\"\n", newentry.name.c_str(), newentry.device_name.c_str());
-}
-
-void probePlaybackDevices(PulseMainloop &mainloop)
+void PulseMainloop::probePlaybackDevices()
 {
     pa_context *context{};
-    pa_stream *stream{};
 
     PlaybackDevices.clear();
     try {
-        auto plock = mainloop.getLock();
+        MainloopUniqueLock plock{*this};
+        auto sink_callback = [](pa_context *ctx, const pa_sink_info *info, int eol, void *pdata) noexcept
+        { return static_cast<PulseMainloop*>(pdata)->deviceSinkCallback(ctx, info, eol); };
 
-        context = mainloop.connectContext(plock);
-
-        constexpr pa_stream_flags_t flags{PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
-            PA_STREAM_FIX_CHANNELS | PA_STREAM_DONT_MOVE | PA_STREAM_START_CORKED};
-
-        pa_sample_spec spec{};
-        spec.format = PA_SAMPLE_S16NE;
-        spec.rate = 44100;
-        spec.channels = 2;
-
-        stream = mainloop.connectStream(nullptr, plock, context, flags, nullptr, &spec, nullptr,
-            BackendType::Playback);
-        pa_operation *op{pa_context_get_sink_info_by_name(context,
-            pa_stream_get_device_name(stream), device_sink_callback, &mainloop)};
-        mainloop.waitForOperation(op, plock);
-
-        pa_stream_disconnect(stream);
-        pa_stream_unref(stream);
-        stream = nullptr;
+        context = plock.connectContext();
+        pa_operation *op{pa_context_get_sink_info_by_name(context, nullptr, sink_callback, this)};
+        plock.waitForOperation(op);
 
-        op = pa_context_get_sink_info_list(context, device_sink_callback, &mainloop);
-        mainloop.waitForOperation(op, plock);
+        op = pa_context_get_sink_info_list(context, sink_callback, this);
+        plock.waitForOperation(op);
 
         pa_context_disconnect(context);
         pa_context_unref(context);
@@ -597,74 +560,26 @@ void probePlaybackDevices(PulseMainloop &mainloop)
     }
     catch(std::exception &e) {
         ERR("Error enumerating devices: %s\n", e.what());
-        if(context) mainloop.close(context, stream);
+        if(context) close(context);
     }
 }
 
-
-void device_source_callback(pa_context*, const pa_source_info *info, int eol, void *pdata) noexcept
-{
-    if(eol)
-    {
-        static_cast<PulseMainloop*>(pdata)->getCondVar().notify_all();
-        return;
-    }
-
-    /* Skip this device is if it's already in the list. */
-    if(std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-        [info](const DevMap &entry) -> bool
-        { return entry.device_name == info->name; }
-    ) != CaptureDevices.cend())
-        return;
-
-    /* Make sure the display name (description) is unique. Append a number
-     * counter as needed.
-     */
-    int count{1};
-    std::string newname{info->description};
-    while(checkName(CaptureDevices, newname))
-    {
-        newname = info->description;
-        newname += " #";
-        newname += std::to_string(++count);
-    }
-    CaptureDevices.emplace_back(DevMap{std::move(newname), info->name});
-    DevMap &newentry = CaptureDevices.back();
-
-    TRACE("Got device \"%s\", \"%s\"\n", newentry.name.c_str(), newentry.device_name.c_str());
-}
-
-void probeCaptureDevices(PulseMainloop &mainloop)
+void PulseMainloop::probeCaptureDevices()
 {
     pa_context *context{};
-    pa_stream *stream{};
 
     CaptureDevices.clear();
     try {
-        auto plock = mainloop.getLock();
-
-        context = mainloop.connectContext(plock);
-
-        constexpr pa_stream_flags_t flags{PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
-            PA_STREAM_FIX_CHANNELS | PA_STREAM_DONT_MOVE | PA_STREAM_START_CORKED};
-
-        pa_sample_spec spec{};
-        spec.format = PA_SAMPLE_S16NE;
-        spec.rate = 44100;
-        spec.channels = 1;
-
-        stream = mainloop.connectStream(nullptr, plock, context, flags, nullptr, &spec, nullptr,
-            BackendType::Capture);
-        pa_operation *op{pa_context_get_source_info_by_name(context,
-            pa_stream_get_device_name(stream), device_source_callback, &mainloop)};
-        mainloop.waitForOperation(op, plock);
+        MainloopUniqueLock plock{*this};
+        auto src_callback = [](pa_context *ctx, const pa_source_info *info, int eol, void *pdata) noexcept
+        { return static_cast<PulseMainloop*>(pdata)->deviceSourceCallback(ctx, info, eol); };
 
-        pa_stream_disconnect(stream);
-        pa_stream_unref(stream);
-        stream = nullptr;
+        context = plock.connectContext();
+        pa_operation *op{pa_context_get_source_info_by_name(context, nullptr, src_callback, this)};
+        plock.waitForOperation(op);
 
-        op = pa_context_get_source_info_list(context, device_source_callback, &mainloop);
-        mainloop.waitForOperation(op, plock);
+        op = pa_context_get_source_info_list(context, src_callback, this);
+        plock.waitForOperation(op);
 
         pa_context_disconnect(context);
         pa_context_unref(context);
@@ -672,58 +587,44 @@ void probeCaptureDevices(PulseMainloop &mainloop)
     }
     catch(std::exception &e) {
         ERR("Error enumerating devices: %s\n", e.what());
-        if(context) mainloop.close(context, stream);
+        if(context) close(context);
     }
 }
 
 
+/* Used for initial connection test and enumeration. */
+PulseMainloop gGlobalMainloop;
+
+
 struct PulsePlayback final : public BackendBase {
-    PulsePlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    PulsePlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~PulsePlayback() override;
 
     void bufferAttrCallback(pa_stream *stream) noexcept;
-    static void bufferAttrCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->bufferAttrCallback(stream); }
-
     void streamStateCallback(pa_stream *stream) noexcept;
-    static void streamStateCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->streamStateCallback(stream); }
-
     void streamWriteCallback(pa_stream *stream, size_t nbytes) noexcept;
-    static void streamWriteCallbackC(pa_stream *stream, size_t nbytes, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->streamWriteCallback(stream, nbytes); }
-
     void sinkInfoCallback(pa_context *context, const pa_sink_info *info, int eol) noexcept;
-    static void sinkInfoCallbackC(pa_context *context, const pa_sink_info *info, int eol, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->sinkInfoCallback(context, info, eol); }
-
     void sinkNameCallback(pa_context *context, const pa_sink_info *info, int eol) noexcept;
-    static void sinkNameCallbackC(pa_context *context, const pa_sink_info *info, int eol, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->sinkNameCallback(context, info, eol); }
-
     void streamMovedCallback(pa_stream *stream) noexcept;
-    static void streamMovedCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulsePlayback*>(pdata)->streamMovedCallback(stream); }
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
     ClockLatency getClockLatency() override;
-    void lock() override { mMainloop.doLock(); }
-    void unlock() override { mMainloop.doUnlock(); }
 
     PulseMainloop mMainloop;
 
-    std::string mDeviceName;
+    al::optional<std::string> mDeviceName{al::nullopt};
 
+    bool mIs51Rear{false};
     pa_buffer_attr mAttr;
     pa_sample_spec mSpec;
 
     pa_stream *mStream{nullptr};
     pa_context *mContext{nullptr};
 
-    ALuint mFrameSize{0u};
+    uint mFrameSize{0u};
 
     DEF_NEWDEL(PulsePlayback)
 };
@@ -755,19 +656,33 @@ void PulsePlayback::streamStateCallback(pa_stream *stream) noexcept
     if(pa_stream_get_state(stream) == PA_STREAM_FAILED)
     {
         ERR("Received stream failure!\n");
-        aluHandleDisconnect(mDevice, "Playback stream failure");
+        mDevice->handleDisconnect("Playback stream failure");
     }
-    mMainloop.getCondVar().notify_all();
+    mMainloop.signal();
 }
 
 void PulsePlayback::streamWriteCallback(pa_stream *stream, size_t nbytes) noexcept
 {
-    void *buf{pa_xmalloc(nbytes)};
-    aluMixData(mDevice, buf, static_cast<ALuint>(nbytes/mFrameSize));
+    do {
+        pa_free_cb_t free_func{nullptr};
+        auto buflen = static_cast<size_t>(-1);
+        void *buf{};
+        if(pa_stream_begin_write(stream, &buf, &buflen) || !buf) UNLIKELY
+        {
+            buflen = nbytes;
+            buf = pa_xmalloc(buflen);
+            free_func = pa_xfree;
+        }
+        else
+            buflen = minz(buflen, nbytes);
+        nbytes -= buflen;
+
+        mDevice->renderSamples(buf, static_cast<uint>(buflen/mFrameSize), mSpec.channels);
 
-    int ret{pa_stream_write(stream, buf, nbytes, pa_xfree, 0, PA_SEEK_RELATIVE)};
-    if UNLIKELY(ret != PA_OK)
-        ERR("Failed to write to stream: %d, %s\n", ret, pa_strerror(ret));
+        int ret{pa_stream_write(stream, buf, buflen, free_func, 0, PA_SEEK_RELATIVE)};
+        if(ret != PA_OK) UNLIKELY
+            ERR("Failed to write to stream: %d, %s\n", ret, pa_strerror(ret));
+    } while(nbytes > 0);
 }
 
 void PulsePlayback::sinkInfoCallback(pa_context*, const pa_sink_info *info, int eol) noexcept
@@ -775,20 +690,22 @@ void PulsePlayback::sinkInfoCallback(pa_context*, const pa_sink_info *info, int
     struct ChannelMap {
         DevFmtChannels fmt;
         pa_channel_map map;
+        bool is_51rear;
     };
-    static constexpr std::array<ChannelMap,7> chanmaps{{
-        { DevFmtX71, X71ChanMap },
-        { DevFmtX61, X61ChanMap },
-        { DevFmtX51, X51ChanMap },
-        { DevFmtX51Rear, X51RearChanMap },
-        { DevFmtQuad, QuadChanMap },
-        { DevFmtStereo, StereoChanMap },
-        { DevFmtMono, MonoChanMap }
+    static constexpr std::array<ChannelMap,8> chanmaps{{
+        { DevFmtX714, X714ChanMap, false },
+        { DevFmtX71, X71ChanMap, false },
+        { DevFmtX61, X61ChanMap, false },
+        { DevFmtX51, X51ChanMap, false },
+        { DevFmtX51, X51RearChanMap, true },
+        { DevFmtQuad, QuadChanMap, false },
+        { DevFmtStereo, StereoChanMap, false },
+        { DevFmtMono, MonoChanMap, false }
     }};
 
     if(eol)
     {
-        mMainloop.getCondVar().notify_all();
+        mMainloop.signal();
         return;
     }
 
@@ -798,11 +715,13 @@ void PulsePlayback::sinkInfoCallback(pa_context*, const pa_sink_info *info, int
     );
     if(chaniter != chanmaps.cend())
     {
-        if(!mDevice->Flags.get<ChannelsRequest>())
+        if(!mDevice->Flags.test(ChannelsRequest))
             mDevice->FmtChans = chaniter->fmt;
+        mIs51Rear = chaniter->is_51rear;
     }
     else
     {
+        mIs51Rear = false;
         char chanmap_str[PA_CHANNEL_MAP_SNPRINT_MAX]{};
         pa_channel_map_snprint(chanmap_str, sizeof(chanmap_str), &info->channel_map);
         WARN("Failed to find format for channel map:\n    %s\n", chanmap_str);
@@ -810,15 +729,15 @@ void PulsePlayback::sinkInfoCallback(pa_context*, const pa_sink_info *info, int
 
     if(info->active_port)
         TRACE("Active port: %s (%s)\n", info->active_port->name, info->active_port->description);
-    mDevice->IsHeadphones = (mDevice->FmtChans == DevFmtStereo &&
-        info->active_port && strcmp(info->active_port->name, "analog-output-headphones") == 0);
+    mDevice->Flags.set(DirectEar, (info->active_port
+        && strcmp(info->active_port->name, "analog-output-headphones") == 0));
 }
 
 void PulsePlayback::sinkNameCallback(pa_context*, const pa_sink_info *info, int eol) noexcept
 {
     if(eol)
     {
-        mMainloop.getCondVar().notify_all();
+        mMainloop.signal();
         return;
     }
     mDevice->DeviceName = info->description;
@@ -827,37 +746,37 @@ void PulsePlayback::sinkNameCallback(pa_context*, const pa_sink_info *info, int
 void PulsePlayback::streamMovedCallback(pa_stream *stream) noexcept
 {
     mDeviceName = pa_stream_get_device_name(stream);
-    TRACE("Stream moved to %s\n", mDeviceName.c_str());
+    TRACE("Stream moved to %s\n", mDeviceName->c_str());
 }
 
 
-void PulsePlayback::open(const ALCchar *name)
+void PulsePlayback::open(const char *name)
 {
+    mMainloop = PulseMainloop::Create();
+    mMainloop.start();
+
     const char *pulse_name{nullptr};
     const char *dev_name{nullptr};
-
     if(name)
     {
         if(PlaybackDevices.empty())
-            probePlaybackDevices(mMainloop);
+            mMainloop.probePlaybackDevices();
 
         auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == PlaybackDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
         pulse_name = iter->device_name.c_str();
         dev_name = iter->name.c_str();
     }
 
-    auto plock = mMainloop.getLock();
-
-    mContext = mMainloop.connectContext(plock);
+    MainloopUniqueLock plock{mMainloop};
+    mContext = plock.connectContext();
 
     pa_stream_flags_t flags{PA_STREAM_START_CORKED | PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
         PA_STREAM_FIX_CHANNELS};
-    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", 1))
+    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", true))
         flags |= PA_STREAM_DONT_MOVE;
 
     pa_sample_spec spec{};
@@ -871,18 +790,22 @@ void PulsePlayback::open(const ALCchar *name)
         if(defname) pulse_name = defname->c_str();
     }
     TRACE("Connecting to \"%s\"\n", pulse_name ? pulse_name : "(default)");
-    mStream = mMainloop.connectStream(pulse_name, plock, mContext, flags, nullptr, &spec, nullptr,
+    mStream = plock.connectStream(pulse_name, mContext, flags, nullptr, &spec, nullptr,
         BackendType::Playback);
 
-    pa_stream_set_moved_callback(mStream, &PulsePlayback::streamMovedCallbackC, this);
-    mFrameSize = static_cast<ALuint>(pa_frame_size(pa_stream_get_sample_spec(mStream)));
+    pa_stream_set_moved_callback(mStream, [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulsePlayback*>(pdata)->streamMovedCallback(stream); }, this);
+    mFrameSize = static_cast<uint>(pa_frame_size(pa_stream_get_sample_spec(mStream)));
 
-    mDeviceName = pa_stream_get_device_name(mStream);
+    if(pulse_name) mDeviceName.emplace(pulse_name);
+    else mDeviceName.reset();
     if(!dev_name)
     {
-        pa_operation *op{pa_context_get_sink_info_by_name(mContext, mDeviceName.c_str(),
-            &PulsePlayback::sinkNameCallbackC, this)};
-        mMainloop.waitForOperation(op, plock);
+        auto name_callback = [](pa_context *context, const pa_sink_info *info, int eol, void *pdata) noexcept
+        { return static_cast<PulsePlayback*>(pdata)->sinkNameCallback(context, info, eol); };
+        pa_operation *op{pa_context_get_sink_info_by_name(mContext,
+            pa_stream_get_device_name(mStream), name_callback, this)};
+        plock.waitForOperation(op);
     }
     else
         mDevice->DeviceName = dev_name;
@@ -890,7 +813,8 @@ void PulsePlayback::open(const ALCchar *name)
 
 bool PulsePlayback::reset()
 {
-    auto plock = mMainloop.getLock();
+    MainloopUniqueLock plock{mMainloop};
+    const auto deviceName = mDeviceName ? mDeviceName->c_str() : nullptr;
 
     if(mStream)
     {
@@ -903,15 +827,16 @@ bool PulsePlayback::reset()
         mStream = nullptr;
     }
 
-    pa_operation *op{pa_context_get_sink_info_by_name(mContext, mDeviceName.c_str(),
-        &PulsePlayback::sinkInfoCallbackC, this)};
-    mMainloop.waitForOperation(op, plock);
+    auto info_callback = [](pa_context *context, const pa_sink_info *info, int eol, void *pdata) noexcept
+    { return static_cast<PulsePlayback*>(pdata)->sinkInfoCallback(context, info, eol); };
+    pa_operation *op{pa_context_get_sink_info_by_name(mContext, deviceName, info_callback, this)};
+    plock.waitForOperation(op);
 
     pa_stream_flags_t flags{PA_STREAM_START_CORKED | PA_STREAM_INTERPOLATE_TIMING |
         PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_EARLY_REQUESTS};
-    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", 1))
+    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", true))
         flags |= PA_STREAM_DONT_MOVE;
-    if(GetConfigValueBool(mDevice->DeviceName.c_str(), "pulse", "adjust-latency", 0))
+    if(GetConfigValueBool(mDevice->DeviceName.c_str(), "pulse", "adjust-latency", false))
     {
         /* ADJUST_LATENCY can't be specified with EARLY_REQUESTS, for some
          * reason. So if the user wants to adjust the overall device latency,
@@ -920,8 +845,8 @@ bool PulsePlayback::reset()
         flags &= ~PA_STREAM_EARLY_REQUESTS;
         flags |= PA_STREAM_ADJUST_LATENCY;
     }
-    if(GetConfigValueBool(mDevice->DeviceName.c_str(), "pulse", "fix-rate", 0) ||
-       !mDevice->Flags.get<FrequencyRequest>())
+    if(GetConfigValueBool(mDevice->DeviceName.c_str(), "pulse", "fix-rate", false)
+        || !mDevice->Flags.test(FrequencyRequest))
         flags |= PA_STREAM_FIX_RATE;
 
     pa_channel_map chanmap{};
@@ -940,19 +865,20 @@ bool PulsePlayback::reset()
         chanmap = QuadChanMap;
         break;
     case DevFmtX51:
-        chanmap = X51ChanMap;
-        break;
-    case DevFmtX51Rear:
-        chanmap = X51RearChanMap;
+        chanmap = (mIs51Rear ? X51RearChanMap : X51ChanMap);
         break;
     case DevFmtX61:
         chanmap = X61ChanMap;
         break;
     case DevFmtX71:
+    case DevFmtX3D71:
         chanmap = X71ChanMap;
         break;
+    case DevFmtX714:
+        chanmap = X714ChanMap;
+        break;
     }
-    SetChannelOrderFromMap(mDevice, chanmap);
+    setDefaultWFXChannelOrder();
 
     switch(mDevice->FmtType)
     {
@@ -981,23 +907,25 @@ bool PulsePlayback::reset()
     mSpec.rate = mDevice->Frequency;
     mSpec.channels = static_cast<uint8_t>(mDevice->channelsFromFmt());
     if(pa_sample_spec_valid(&mSpec) == 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Invalid sample spec"};
+        throw al::backend_exception{al::backend_error::DeviceError, "Invalid sample spec"};
 
-    const ALuint frame_size{static_cast<ALuint>(pa_frame_size(&mSpec))};
+    const auto frame_size = static_cast<uint>(pa_frame_size(&mSpec));
     mAttr.maxlength = ~0u;
     mAttr.tlength = mDevice->BufferSize * frame_size;
     mAttr.prebuf = 0u;
     mAttr.minreq = mDevice->UpdateSize * frame_size;
     mAttr.fragsize = ~0u;
 
-    mStream = mMainloop.connectStream(mDeviceName.c_str(), plock, mContext, flags, &mAttr, &mSpec,
-        &chanmap, BackendType::Playback);
+    mStream = plock.connectStream(deviceName, mContext, flags, &mAttr, &mSpec, &chanmap,
+        BackendType::Playback);
 
-    pa_stream_set_state_callback(mStream, &PulsePlayback::streamStateCallbackC, this);
-    pa_stream_set_moved_callback(mStream, &PulsePlayback::streamMovedCallbackC, this);
+    pa_stream_set_state_callback(mStream, [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulsePlayback*>(pdata)->streamStateCallback(stream); }, this);
+    pa_stream_set_moved_callback(mStream, [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulsePlayback*>(pdata)->streamMovedCallback(stream); }, this);
 
     mSpec = *(pa_stream_get_sample_spec(mStream));
-    mFrameSize = static_cast<ALuint>(pa_frame_size(&mSpec));
+    mFrameSize = static_cast<uint>(pa_frame_size(&mSpec));
 
     if(mDevice->Frequency != mSpec.rate)
     {
@@ -1005,10 +933,10 @@ bool PulsePlayback::reset()
          * accordingly.
          */
         const auto scale = static_cast<double>(mSpec.rate) / mDevice->Frequency;
-        const ALuint perlen{static_cast<ALuint>(clampd(scale*mDevice->UpdateSize + 0.5, 64.0,
-            8192.0))};
-        const ALuint buflen{static_cast<ALuint>(clampd(scale*mDevice->BufferSize + 0.5, perlen*2,
-            std::numeric_limits<int>::max()/mFrameSize))};
+        const auto perlen = static_cast<uint>(clampd(scale*mDevice->UpdateSize + 0.5, 64.0,
+            8192.0));
+        const auto buflen = static_cast<uint>(clampd(scale*mDevice->BufferSize + 0.5, perlen*2,
+            std::numeric_limits<int>::max()/mFrameSize));
 
         mAttr.maxlength = ~0u;
         mAttr.tlength = buflen * mFrameSize;
@@ -1017,12 +945,14 @@ bool PulsePlayback::reset()
 
         op = pa_stream_set_buffer_attr(mStream, &mAttr, &PulseMainloop::streamSuccessCallbackC,
             &mMainloop);
-        mMainloop.waitForOperation(op, plock);
+        plock.waitForOperation(op);
 
         mDevice->Frequency = mSpec.rate;
     }
 
-    pa_stream_set_buffer_attr_callback(mStream, &PulsePlayback::bufferAttrCallbackC, this);
+    auto attr_callback = [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulsePlayback*>(pdata)->bufferAttrCallback(stream); };
+    pa_stream_set_buffer_attr_callback(mStream, attr_callback, this);
     bufferAttrCallback(mStream);
 
     mDevice->BufferSize = mAttr.tlength / mFrameSize;
@@ -1031,25 +961,35 @@ bool PulsePlayback::reset()
     return true;
 }
 
-bool PulsePlayback::start()
+void PulsePlayback::start()
 {
-    auto plock = mMainloop.getLock();
+    MainloopUniqueLock plock{mMainloop};
+
+    /* Write some samples to fill the buffer before we start feeding it newly
+     * mixed samples.
+     */
+    if(size_t todo{pa_stream_writable_size(mStream)})
+    {
+        void *buf{pa_xmalloc(todo)};
+        mDevice->renderSamples(buf, static_cast<uint>(todo/mFrameSize), mSpec.channels);
+        pa_stream_write(mStream, buf, todo, pa_xfree, 0, PA_SEEK_RELATIVE);
+    }
 
-    pa_stream_set_write_callback(mStream, &PulsePlayback::streamWriteCallbackC, this);
+    pa_stream_set_write_callback(mStream, [](pa_stream *stream, size_t nbytes, void *pdata)noexcept
+    { return static_cast<PulsePlayback*>(pdata)->streamWriteCallback(stream, nbytes); }, this);
     pa_operation *op{pa_stream_cork(mStream, 0, &PulseMainloop::streamSuccessCallbackC,
         &mMainloop)};
-    mMainloop.waitForOperation(op, plock);
 
-    return true;
+    plock.waitForOperation(op);
 }
 
 void PulsePlayback::stop()
 {
-    auto plock = mMainloop.getLock();
+    MainloopUniqueLock plock{mMainloop};
 
     pa_operation *op{pa_stream_cork(mStream, 1, &PulseMainloop::streamSuccessCallbackC,
         &mMainloop)};
-    mMainloop.waitForOperation(op, plock);
+    plock.waitForOperation(op);
     pa_stream_set_write_callback(mStream, nullptr, nullptr);
 }
 
@@ -1061,23 +1001,23 @@ ClockLatency PulsePlayback::getClockLatency()
     int neg, err;
 
     {
-        auto _ = mMainloop.getLock();
+        MainloopUniqueLock plock{mMainloop};
         ret.ClockTime = GetDeviceClockTime(mDevice);
         err = pa_stream_get_latency(mStream, &latency, &neg);
     }
 
-    if UNLIKELY(err != 0)
+    if(err != 0) UNLIKELY
     {
-        /* FIXME: if err = -PA_ERR_NODATA, it means we were called too soon
-         * after starting the stream and no timing info has been received from
-         * the server yet. Should we wait, possibly stalling the app, or give a
-         * dummy value? Either way, it shouldn't be 0. */
+        /* If err = -PA_ERR_NODATA, it means we were called too soon after
+         * starting the stream and no timing info has been received from the
+         * server yet. Give a generic value since nothing better is available.
+         */
         if(err != -PA_ERR_NODATA)
             ERR("Failed to get stream latency: 0x%x\n", err);
-        latency = 0;
+        latency = mDevice->BufferSize - mDevice->UpdateSize;
         neg = 0;
     }
-    else if UNLIKELY(neg)
+    else if(neg) UNLIKELY
         latency = 0;
     ret.Latency = std::chrono::microseconds{latency};
 
@@ -1086,39 +1026,30 @@ ClockLatency PulsePlayback::getClockLatency()
 
 
 struct PulseCapture final : public BackendBase {
-    PulseCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    PulseCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~PulseCapture() override;
 
     void streamStateCallback(pa_stream *stream) noexcept;
-    static void streamStateCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulseCapture*>(pdata)->streamStateCallback(stream); }
-
     void sourceNameCallback(pa_context *context, const pa_source_info *info, int eol) noexcept;
-    static void sourceNameCallbackC(pa_context *context, const pa_source_info *info, int eol, void *pdata) noexcept
-    { static_cast<PulseCapture*>(pdata)->sourceNameCallback(context, info, eol); }
-
     void streamMovedCallback(pa_stream *stream) noexcept;
-    static void streamMovedCallbackC(pa_stream *stream, void *pdata) noexcept
-    { static_cast<PulseCapture*>(pdata)->streamMovedCallback(stream); }
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
     ClockLatency getClockLatency() override;
-    void lock() override { mMainloop.doLock(); }
-    void unlock() override { mMainloop.doUnlock(); }
 
     PulseMainloop mMainloop;
 
-    std::string mDeviceName;
-
-    ALCuint mLastReadable{0u};
-    al::byte mSilentVal{};
+    al::optional<std::string> mDeviceName{al::nullopt};
 
     al::span<const al::byte> mCapBuffer;
-    ssize_t mCapLen{0};
+    size_t mHoleLength{0};
+    size_t mPacketLength{0};
+
+    uint mLastReadable{0u};
+    al::byte mSilentVal{};
 
     pa_buffer_attr mAttr{};
     pa_sample_spec mSpec{};
@@ -1145,16 +1076,16 @@ void PulseCapture::streamStateCallback(pa_stream *stream) noexcept
     if(pa_stream_get_state(stream) == PA_STREAM_FAILED)
     {
         ERR("Received stream failure!\n");
-        aluHandleDisconnect(mDevice, "Capture stream failure");
+        mDevice->handleDisconnect("Capture stream failure");
     }
-    mMainloop.getCondVar().notify_all();
+    mMainloop.signal();
 }
 
 void PulseCapture::sourceNameCallback(pa_context*, const pa_source_info *info, int eol) noexcept
 {
     if(eol)
     {
-        mMainloop.getCondVar().notify_all();
+        mMainloop.signal();
         return;
     }
     mDevice->DeviceName = info->description;
@@ -1163,31 +1094,35 @@ void PulseCapture::sourceNameCallback(pa_context*, const pa_source_info *info, i
 void PulseCapture::streamMovedCallback(pa_stream *stream) noexcept
 {
     mDeviceName = pa_stream_get_device_name(stream);
-    TRACE("Stream moved to %s\n", mDeviceName.c_str());
+    TRACE("Stream moved to %s\n", mDeviceName->c_str());
 }
 
 
-void PulseCapture::open(const ALCchar *name)
+void PulseCapture::open(const char *name)
 {
+    if(!mMainloop)
+    {
+        mMainloop = PulseMainloop::Create();
+        mMainloop.start();
+    }
+
     const char *pulse_name{nullptr};
     if(name)
     {
         if(CaptureDevices.empty())
-            probeCaptureDevices(mMainloop);
+            mMainloop.probeCaptureDevices();
 
         auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-            [name](const DevMap &entry) -> bool
-            { return entry.name == name; }
-        );
+            [name](const DevMap &entry) -> bool { return entry.name == name; });
         if(iter == CaptureDevices.cend())
-            throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+            throw al::backend_exception{al::backend_error::NoDevice,
+                "Device name \"%s\" not found", name};
         pulse_name = iter->device_name.c_str();
         mDevice->DeviceName = iter->name;
     }
 
-    auto plock = mMainloop.getLock();
-
-    mContext = mMainloop.connectContext(plock);
+    MainloopUniqueLock plock{mMainloop};
+    mContext = plock.connectContext();
 
     pa_channel_map chanmap{};
     switch(mDevice->FmtChans)
@@ -1204,20 +1139,21 @@ void PulseCapture::open(const ALCchar *name)
     case DevFmtX51:
         chanmap = X51ChanMap;
         break;
-    case DevFmtX51Rear:
-        chanmap = X51RearChanMap;
-        break;
     case DevFmtX61:
         chanmap = X61ChanMap;
         break;
     case DevFmtX71:
         chanmap = X71ChanMap;
         break;
+    case DevFmtX714:
+        chanmap = X714ChanMap;
+        break;
+    case DevFmtX3D71:
     case DevFmtAmbi3D:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s capture not supported",
             DevFmtChannelsString(mDevice->FmtChans)};
     }
-    SetChannelOrderFromMap(mDevice, chanmap);
+    setDefaultWFXChannelOrder();
 
     switch(mDevice->FmtType)
     {
@@ -1237,16 +1173,16 @@ void PulseCapture::open(const ALCchar *name)
     case DevFmtByte:
     case DevFmtUShort:
     case DevFmtUInt:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture samples not supported",
-            DevFmtTypeString(mDevice->FmtType)};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
     }
     mSpec.rate = mDevice->Frequency;
     mSpec.channels = static_cast<uint8_t>(mDevice->channelsFromFmt());
     if(pa_sample_spec_valid(&mSpec) == 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Invalid sample format"};
+        throw al::backend_exception{al::backend_error::DeviceError, "Invalid sample format"};
 
-    const ALuint frame_size{static_cast<ALuint>(pa_frame_size(&mSpec))};
-    const ALuint samples{maxu(mDevice->BufferSize, 100 * mDevice->Frequency / 1000)};
+    const auto frame_size = static_cast<uint>(pa_frame_size(&mSpec));
+    const uint samples{maxu(mDevice->BufferSize, 100 * mDevice->Frequency / 1000)};
     mAttr.minreq = ~0u;
     mAttr.prebuf = ~0u;
     mAttr.maxlength = samples * frame_size;
@@ -1254,127 +1190,143 @@ void PulseCapture::open(const ALCchar *name)
     mAttr.fragsize = minu(samples, 50*mDevice->Frequency/1000) * frame_size;
 
     pa_stream_flags_t flags{PA_STREAM_START_CORKED | PA_STREAM_ADJUST_LATENCY};
-    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", 1))
+    if(!GetConfigValueBool(nullptr, "pulse", "allow-moves", true))
         flags |= PA_STREAM_DONT_MOVE;
 
     TRACE("Connecting to \"%s\"\n", pulse_name ? pulse_name : "(default)");
-    mStream = mMainloop.connectStream(pulse_name, plock, mContext, flags, &mAttr, &mSpec, &chanmap,
+    mStream = plock.connectStream(pulse_name, mContext, flags, &mAttr, &mSpec, &chanmap,
         BackendType::Capture);
 
-    pa_stream_set_moved_callback(mStream, &PulseCapture::streamMovedCallbackC, this);
-    pa_stream_set_state_callback(mStream, &PulseCapture::streamStateCallbackC, this);
+    pa_stream_set_moved_callback(mStream, [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulseCapture*>(pdata)->streamMovedCallback(stream); }, this);
+    pa_stream_set_state_callback(mStream, [](pa_stream *stream, void *pdata) noexcept
+    { return static_cast<PulseCapture*>(pdata)->streamStateCallback(stream); }, this);
 
-    mDeviceName = pa_stream_get_device_name(mStream);
+    if(pulse_name) mDeviceName.emplace(pulse_name);
+    else mDeviceName.reset();
     if(mDevice->DeviceName.empty())
     {
-        pa_operation *op{pa_context_get_source_info_by_name(mContext, mDeviceName.c_str(),
-            &PulseCapture::sourceNameCallbackC, this)};
-        mMainloop.waitForOperation(op, plock);
+        auto name_callback = [](pa_context *context, const pa_source_info *info, int eol, void *pdata) noexcept
+        { return static_cast<PulseCapture*>(pdata)->sourceNameCallback(context, info, eol); };
+        pa_operation *op{pa_context_get_source_info_by_name(mContext,
+            pa_stream_get_device_name(mStream), name_callback, this)};
+        plock.waitForOperation(op);
     }
 }
 
-bool PulseCapture::start()
+void PulseCapture::start()
 {
-    auto plock = mMainloop.getLock();
+    MainloopUniqueLock plock{mMainloop};
     pa_operation *op{pa_stream_cork(mStream, 0, &PulseMainloop::streamSuccessCallbackC,
         &mMainloop)};
-    mMainloop.waitForOperation(op, plock);
-    return true;
+    plock.waitForOperation(op);
 }
 
 void PulseCapture::stop()
 {
-    auto plock = mMainloop.getLock();
+    MainloopUniqueLock plock{mMainloop};
     pa_operation *op{pa_stream_cork(mStream, 1, &PulseMainloop::streamSuccessCallbackC,
         &mMainloop)};
-    mMainloop.waitForOperation(op, plock);
+    plock.waitForOperation(op);
 }
 
-ALCenum PulseCapture::captureSamples(al::byte *buffer, ALCuint samples)
+void PulseCapture::captureSamples(al::byte *buffer, uint samples)
 {
     al::span<al::byte> dstbuf{buffer, samples * pa_frame_size(&mSpec)};
 
     /* Capture is done in fragment-sized chunks, so we loop until we get all
-     * that's available */
-    mLastReadable -= static_cast<ALCuint>(dstbuf.size());
+     * that's available.
+     */
+    mLastReadable -= static_cast<uint>(dstbuf.size());
     while(!dstbuf.empty())
     {
+        if(mHoleLength > 0) UNLIKELY
+        {
+            const size_t rem{minz(dstbuf.size(), mHoleLength)};
+            std::fill_n(dstbuf.begin(), rem, mSilentVal);
+            dstbuf = dstbuf.subspan(rem);
+            mHoleLength -= rem;
+
+            continue;
+        }
         if(!mCapBuffer.empty())
         {
             const size_t rem{minz(dstbuf.size(), mCapBuffer.size())};
-            if UNLIKELY(mCapLen < 0)
-                std::fill_n(dstbuf.begin(), rem, mSilentVal);
-            else
-                std::copy_n(mCapBuffer.begin(), rem, dstbuf.begin());
+            std::copy_n(mCapBuffer.begin(), rem, dstbuf.begin());
             dstbuf = dstbuf.subspan(rem);
             mCapBuffer = mCapBuffer.subspan(rem);
 
             continue;
         }
 
-        if UNLIKELY(!mDevice->Connected.load(std::memory_order_acquire))
+        if(!mDevice->Connected.load(std::memory_order_acquire)) UNLIKELY
             break;
 
-        auto plock = mMainloop.getLock();
-        if(mCapLen != 0)
+        MainloopUniqueLock plock{mMainloop};
+        if(mPacketLength > 0)
         {
             pa_stream_drop(mStream);
-            mCapBuffer = {};
-            mCapLen = 0;
+            mPacketLength = 0;
         }
+
         const pa_stream_state_t state{pa_stream_get_state(mStream)};
-        if UNLIKELY(!PA_STREAM_IS_GOOD(state))
+        if(!PA_STREAM_IS_GOOD(state)) UNLIKELY
         {
-            aluHandleDisconnect(mDevice, "Bad capture state: %u", state);
+            mDevice->handleDisconnect("Bad capture state: %u", state);
             break;
         }
+
         const void *capbuf;
         size_t caplen;
-        if UNLIKELY(pa_stream_peek(mStream, &capbuf, &caplen) < 0)
+        if(pa_stream_peek(mStream, &capbuf, &caplen) < 0) UNLIKELY
         {
-            aluHandleDisconnect(mDevice, "Failed retrieving capture samples: %s",
+            mDevice->handleDisconnect("Failed retrieving capture samples: %s",
                 pa_strerror(pa_context_errno(mContext)));
             break;
         }
         plock.unlock();
 
         if(caplen == 0) break;
-        if UNLIKELY(!capbuf)
-            mCapLen = -static_cast<ssize_t>(caplen);
+        if(!capbuf) UNLIKELY
+            mHoleLength = caplen;
         else
-            mCapLen = static_cast<ssize_t>(caplen);
-        mCapBuffer = {static_cast<const al::byte*>(capbuf), caplen};
+            mCapBuffer = {static_cast<const al::byte*>(capbuf), caplen};
+        mPacketLength = caplen;
     }
     if(!dstbuf.empty())
         std::fill(dstbuf.begin(), dstbuf.end(), mSilentVal);
-
-    return ALC_NO_ERROR;
 }
 
-ALCuint PulseCapture::availableSamples()
+uint PulseCapture::availableSamples()
 {
-    size_t readable{mCapBuffer.size()};
+    size_t readable{maxz(mCapBuffer.size(), mHoleLength)};
 
     if(mDevice->Connected.load(std::memory_order_acquire))
     {
-        auto _ = mMainloop.getLock();
+        MainloopUniqueLock plock{mMainloop};
         size_t got{pa_stream_readable_size(mStream)};
-        if UNLIKELY(static_cast<ssize_t>(got) < 0)
+        if(static_cast<ssize_t>(got) < 0) UNLIKELY
         {
             const char *err{pa_strerror(static_cast<int>(got))};
             ERR("pa_stream_readable_size() failed: %s\n", err);
-            aluHandleDisconnect(mDevice, "Failed getting readable size: %s", err);
+            mDevice->handleDisconnect("Failed getting readable size: %s", err);
         }
         else
         {
-            const auto caplen = static_cast<size_t>(std::abs(mCapLen));
-            if(got > caplen) readable += got - caplen;
+            /* "readable" is the number of bytes from the last packet that have
+             * not yet been read by the caller. So add the stream's readable
+             * size excluding the last packet (the stream size includes the
+             * last packet until it's dropped).
+             */
+            if(got > mPacketLength)
+                readable += got - mPacketLength;
         }
     }
 
-    readable = std::min<size_t>(readable, std::numeric_limits<ALCuint>::max());
-    mLastReadable = std::max(mLastReadable, static_cast<ALCuint>(readable));
-    return mLastReadable / static_cast<ALCuint>(pa_frame_size(&mSpec));
+    /* Avoid uint overflow, and avoid decreasing the readable count. */
+    readable = std::min<size_t>(readable, std::numeric_limits<uint>::max());
+    mLastReadable = std::max(mLastReadable, static_cast<uint>(readable));
+    return mLastReadable / static_cast<uint>(pa_frame_size(&mSpec));
 }
 
 
@@ -1385,18 +1337,18 @@ ClockLatency PulseCapture::getClockLatency()
     int neg, err;
 
     {
-        auto _ = mMainloop.getLock();
+        MainloopUniqueLock plock{mMainloop};
         ret.ClockTime = GetDeviceClockTime(mDevice);
         err = pa_stream_get_latency(mStream, &latency, &neg);
     }
 
-    if UNLIKELY(err != 0)
+    if(err != 0) UNLIKELY
     {
         ERR("Failed to get stream latency: 0x%x\n", err);
         latency = 0;
         neg = 0;
     }
-    else if UNLIKELY(neg)
+    else if(neg) UNLIKELY
         latency = 0;
     ret.Latency = std::chrono::microseconds{latency};
 
@@ -1449,12 +1401,18 @@ bool PulseBackendFactory::init()
 #endif /* HAVE_DYNLOAD */
 
     pulse_ctx_flags = PA_CONTEXT_NOFLAGS;
-    if(!GetConfigValueBool(nullptr, "pulse", "spawn-server", 1))
+    if(!GetConfigValueBool(nullptr, "pulse", "spawn-server", false))
         pulse_ctx_flags |= PA_CONTEXT_NOAUTOSPAWN;
 
     try {
-        auto plock = gGlobalMainloop.getLock();
-        pa_context *context{gGlobalMainloop.connectContext(plock)};
+        if(!gGlobalMainloop)
+        {
+            gGlobalMainloop = PulseMainloop::Create();
+            gGlobalMainloop.start();
+        }
+
+        MainloopUniqueLock plock{gGlobalMainloop};
+        pa_context *context{plock.connectContext()};
         pa_context_disconnect(context);
         pa_context_unref(context);
         return true;
@@ -1467,31 +1425,35 @@ bool PulseBackendFactory::init()
 bool PulseBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback || type == BackendType::Capture; }
 
-void PulseBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string PulseBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const DevMap &entry) -> void
+    std::string outnames;
+
+    auto add_device = [&outnames](const DevMap &entry) -> void
     {
         /* +1 to also append the null char (to ensure a null-separated list and
          * double-null terminated list).
          */
-        outnames->append(entry.name.c_str(), entry.name.length()+1);
+        outnames.append(entry.name.c_str(), entry.name.length()+1);
     };
 
     switch(type)
     {
-    case DevProbe::Playback:
-        probePlaybackDevices(gGlobalMainloop);
+    case BackendType::Playback:
+        gGlobalMainloop.probePlaybackDevices();
         std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
         break;
 
-    case DevProbe::Capture:
-        probeCaptureDevices(gGlobalMainloop);
+    case BackendType::Capture:
+        gGlobalMainloop.probeCaptureDevices();
         std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
         break;
     }
+
+    return outnames;
 }
 
-BackendPtr PulseBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr PulseBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new PulsePlayback{device}};
diff --git a/alc/backends/pulseaudio.h b/alc/backends/pulseaudio.h
index 40f3e305..6690fe8a 100644
--- a/alc/backends/pulseaudio.h
+++ b/alc/backends/pulseaudio.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_PULSEAUDIO_H
 #define BACKENDS_PULSEAUDIO_H
 
-#include "backends/base.h"
+#include "base.h"
 
 class PulseBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/qsa.cpp b/alc/backends/qsa.cpp
deleted file mode 100644
index 5ed65798..00000000
--- a/alc/backends/qsa.cpp
+++ /dev/null
@@ -1,963 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2011-2013 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 "backends/qsa.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <sched.h>
-#include <errno.h>
-#include <memory.h>
-#include <poll.h>
-
-#include <thread>
-#include <memory>
-#include <algorithm>
-
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
-#include "threads.h"
-
-#include <sys/asoundlib.h>
-#include <sys/neutrino.h>
-
-
-namespace {
-
-struct qsa_data {
-    snd_pcm_t* pcmHandle{nullptr};
-    int audio_fd{-1};
-
-    snd_pcm_channel_setup_t  csetup{};
-    snd_pcm_channel_params_t cparams{};
-
-    ALvoid* buffer{nullptr};
-    ALsizei size{0};
-
-    std::atomic<ALenum> mKillNow{AL_TRUE};
-    std::thread mThread;
-};
-
-struct DevMap {
-    ALCchar* name;
-    int card;
-    int dev;
-};
-
-al::vector<DevMap> DeviceNameMap;
-al::vector<DevMap> CaptureNameMap;
-
-constexpr ALCchar qsaDevice[] = "QSA Default";
-
-constexpr struct {
-    int32_t format;
-} formatlist[] = {
-    {SND_PCM_SFMT_FLOAT_LE},
-    {SND_PCM_SFMT_S32_LE},
-    {SND_PCM_SFMT_U32_LE},
-    {SND_PCM_SFMT_S16_LE},
-    {SND_PCM_SFMT_U16_LE},
-    {SND_PCM_SFMT_S8},
-    {SND_PCM_SFMT_U8},
-    {0},
-};
-
-constexpr struct {
-    int32_t rate;
-} ratelist[] = {
-    {192000},
-    {176400},
-    {96000},
-    {88200},
-    {48000},
-    {44100},
-    {32000},
-    {24000},
-    {22050},
-    {16000},
-    {12000},
-    {11025},
-    {8000},
-    {0},
-};
-
-constexpr struct {
-    int32_t channels;
-} channellist[] = {
-    {8},
-    {7},
-    {6},
-    {4},
-    {2},
-    {1},
-    {0},
-};
-
-void deviceList(int type, al::vector<DevMap> *devmap)
-{
-    snd_ctl_t* handle;
-    snd_pcm_info_t pcminfo;
-    int max_cards, card, err, dev;
-    DevMap entry;
-    char name[1024];
-    snd_ctl_hw_info info;
-
-    max_cards = snd_cards();
-    if(max_cards < 0)
-        return;
-
-    std::for_each(devmap->begin(), devmap->end(),
-        [](const DevMap &entry) -> void
-        { free(entry.name); }
-    );
-    devmap->clear();
-
-    entry.name = strdup(qsaDevice);
-    entry.card = 0;
-    entry.dev = 0;
-    devmap->push_back(entry);
-
-    for(card = 0;card < max_cards;card++)
-    {
-        if((err=snd_ctl_open(&handle, card)) < 0)
-            continue;
-
-        if((err=snd_ctl_hw_info(handle, &info)) < 0)
-        {
-            snd_ctl_close(handle);
-            continue;
-        }
-
-        for(dev = 0;dev < (int)info.pcmdevs;dev++)
-        {
-            if((err=snd_ctl_pcm_info(handle, dev, &pcminfo)) < 0)
-                continue;
-
-            if((type==SND_PCM_CHANNEL_PLAYBACK && (pcminfo.flags&SND_PCM_INFO_PLAYBACK)) ||
-               (type==SND_PCM_CHANNEL_CAPTURE && (pcminfo.flags&SND_PCM_INFO_CAPTURE)))
-            {
-                snprintf(name, sizeof(name), "%s [%s] (hw:%d,%d)", info.name, pcminfo.name, card, dev);
-                entry.name = strdup(name);
-                entry.card = card;
-                entry.dev = dev;
-
-                devmap->push_back(entry);
-                TRACE("Got device \"%s\", card %d, dev %d\n", name, card, dev);
-            }
-        }
-        snd_ctl_close(handle);
-    }
-}
-
-
-/* Wrappers to use an old-style backend with the new interface. */
-struct PlaybackWrapper final : public BackendBase {
-    PlaybackWrapper(ALCdevice *device) noexcept : BackendBase{device} { }
-    ~PlaybackWrapper() override;
-
-    void open(const ALCchar *name) override;
-    bool reset() override;
-    bool start() override;
-    void stop() override;
-
-    std::unique_ptr<qsa_data> mExtraData;
-
-    DEF_NEWDEL(PlaybackWrapper)
-};
-
-
-FORCE_ALIGN static int qsa_proc_playback(void *ptr)
-{
-    PlaybackWrapper *self = static_cast<PlaybackWrapper*>(ptr);
-    ALCdevice *device = self->mDevice;
-    qsa_data *data = self->mExtraData.get();
-    snd_pcm_channel_status_t status;
-    sched_param param;
-    char* write_ptr;
-    ALint len;
-    int sret;
-
-    SetRTPriority();
-    althrd_setname(MIXER_THREAD_NAME);
-
-    /* Increase default 10 priority to 11 to avoid jerky sound */
-    SchedGet(0, 0, &param);
-    param.sched_priority=param.sched_curpriority+1;
-    SchedSet(0, 0, SCHED_NOCHANGE, &param);
-
-    const ALint frame_size = device->frameSizeFromFmt();
-
-    std::unique_lock<PlaybackWrapper> dlock{*self};
-    while(!data->mKillNow.load(std::memory_order_acquire))
-    {
-        pollfd pollitem{};
-        pollitem.fd = data->audio_fd;
-        pollitem.events = POLLOUT;
-
-        /* Select also works like time slice to OS */
-        dlock.unlock();
-        sret = poll(&pollitem, 1, 2000);
-        dlock.lock();
-        if(sret == -1)
-        {
-            if(errno == EINTR || errno == EAGAIN)
-                continue;
-            ERR("poll error: %s\n", strerror(errno));
-            aluHandleDisconnect(device, "Failed waiting for playback buffer: %s", strerror(errno));
-            break;
-        }
-        if(sret == 0)
-        {
-            ERR("poll timeout\n");
-            continue;
-        }
-
-        len = data->size;
-        write_ptr = static_cast<char*>(data->buffer);
-        aluMixData(device, write_ptr, len/frame_size);
-        while(len>0 && !data->mKillNow.load(std::memory_order_acquire))
-        {
-            int wrote = snd_pcm_plugin_write(data->pcmHandle, write_ptr, len);
-            if(wrote <= 0)
-            {
-                if(errno==EAGAIN || errno==EWOULDBLOCK)
-                    continue;
-
-                memset(&status, 0, sizeof(status));
-                status.channel = SND_PCM_CHANNEL_PLAYBACK;
-
-                snd_pcm_plugin_status(data->pcmHandle, &status);
-
-                /* we need to reinitialize the sound channel if we've underrun the buffer */
-                if(status.status == SND_PCM_STATUS_UNDERRUN ||
-                   status.status == SND_PCM_STATUS_READY)
-                {
-                    if(snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK) < 0)
-                    {
-                        aluHandleDisconnect(device, "Playback recovery failed");
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                write_ptr += wrote;
-                len -= wrote;
-            }
-        }
-    }
-
-    return 0;
-}
-
-/************/
-/* Playback */
-/************/
-
-static ALCenum qsa_open_playback(PlaybackWrapper *self, const ALCchar* deviceName)
-{
-    ALCdevice *device = self->mDevice;
-    int card, dev;
-    int status;
-
-    std::unique_ptr<qsa_data> data{new qsa_data{}};
-    data->mKillNow.store(AL_TRUE, std::memory_order_relaxed);
-
-    if(!deviceName)
-        deviceName = qsaDevice;
-
-    if(strcmp(deviceName, qsaDevice) == 0)
-        status = snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_PLAYBACK);
-    else
-    {
-        if(DeviceNameMap.empty())
-            deviceList(SND_PCM_CHANNEL_PLAYBACK, &DeviceNameMap);
-
-        auto iter = std::find_if(DeviceNameMap.begin(), DeviceNameMap.end(),
-            [deviceName](const DevMap &entry) -> bool
-            { return entry.name && strcmp(deviceName, entry.name) == 0; }
-        );
-        if(iter == DeviceNameMap.cend())
-            return ALC_INVALID_DEVICE;
-
-        status = snd_pcm_open(&data->pcmHandle, iter->card, iter->dev, SND_PCM_OPEN_PLAYBACK);
-    }
-
-    if(status < 0)
-        return ALC_INVALID_DEVICE;
-
-    data->audio_fd = snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK);
-    if(data->audio_fd < 0)
-    {
-        snd_pcm_close(data->pcmHandle);
-        return ALC_INVALID_DEVICE;
-    }
-
-    device->DeviceName = deviceName;
-    self->mExtraData = std::move(data);
-
-    return ALC_NO_ERROR;
-}
-
-static void qsa_close_playback(PlaybackWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-
-    if (data->buffer!=NULL)
-    {
-        free(data->buffer);
-        data->buffer=NULL;
-    }
-
-    snd_pcm_close(data->pcmHandle);
-
-    self->mExtraData = nullptr;
-}
-
-static ALCboolean qsa_reset_playback(PlaybackWrapper *self)
-{
-    ALCdevice *device = self->mDevice;
-    qsa_data *data = self->mExtraData.get();
-    int32_t format=-1;
-
-    switch(device->FmtType)
-    {
-        case DevFmtByte:
-             format=SND_PCM_SFMT_S8;
-             break;
-        case DevFmtUByte:
-             format=SND_PCM_SFMT_U8;
-             break;
-        case DevFmtShort:
-             format=SND_PCM_SFMT_S16_LE;
-             break;
-        case DevFmtUShort:
-             format=SND_PCM_SFMT_U16_LE;
-             break;
-        case DevFmtInt:
-             format=SND_PCM_SFMT_S32_LE;
-             break;
-        case DevFmtUInt:
-             format=SND_PCM_SFMT_U32_LE;
-             break;
-        case DevFmtFloat:
-             format=SND_PCM_SFMT_FLOAT_LE;
-             break;
-    }
-
-    /* we actually don't want to block on writes */
-    snd_pcm_nonblock_mode(data->pcmHandle, 1);
-    /* Disable mmap to control data transfer to the audio device */
-    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
-    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_BUFFER_PARTIAL_BLOCKS);
-
-    // configure a sound channel
-    memset(&data->cparams, 0, sizeof(data->cparams));
-    data->cparams.channel=SND_PCM_CHANNEL_PLAYBACK;
-    data->cparams.mode=SND_PCM_MODE_BLOCK;
-    data->cparams.start_mode=SND_PCM_START_FULL;
-    data->cparams.stop_mode=SND_PCM_STOP_STOP;
-
-    data->cparams.buf.block.frag_size=device->UpdateSize * device->frameSizeFromFmt();
-    data->cparams.buf.block.frags_max=device->BufferSize / device->UpdateSize;
-    data->cparams.buf.block.frags_min=data->cparams.buf.block.frags_max;
-
-    data->cparams.format.interleave=1;
-    data->cparams.format.rate=device->Frequency;
-    data->cparams.format.voices=device->channelsFromFmt();
-    data->cparams.format.format=format;
-
-    if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
-    {
-        int original_rate=data->cparams.format.rate;
-        int original_voices=data->cparams.format.voices;
-        int original_format=data->cparams.format.format;
-        int it;
-        int jt;
-
-        for (it=0; it<1; it++)
-        {
-            /* Check for second pass */
-            if (it==1)
-            {
-                original_rate=ratelist[0].rate;
-                original_voices=channellist[0].channels;
-                original_format=formatlist[0].format;
-            }
-
-            do {
-                /* At first downgrade sample format */
-                jt=0;
-                do {
-                    if (formatlist[jt].format==data->cparams.format.format)
-                    {
-                        data->cparams.format.format=formatlist[jt+1].format;
-                        break;
-                    }
-                    if (formatlist[jt].format==0)
-                    {
-                        data->cparams.format.format=0;
-                        break;
-                    }
-                    jt++;
-                } while(1);
-
-                if (data->cparams.format.format==0)
-                {
-                    data->cparams.format.format=original_format;
-
-                    /* At secod downgrade sample rate */
-                    jt=0;
-                    do {
-                        if (ratelist[jt].rate==data->cparams.format.rate)
-                        {
-                            data->cparams.format.rate=ratelist[jt+1].rate;
-                            break;
-                        }
-                        if (ratelist[jt].rate==0)
-                        {
-                            data->cparams.format.rate=0;
-                            break;
-                        }
-                        jt++;
-                    } while(1);
-
-                    if (data->cparams.format.rate==0)
-                    {
-                        data->cparams.format.rate=original_rate;
-                        data->cparams.format.format=original_format;
-
-                        /* At third downgrade channels number */
-                        jt=0;
-                        do {
-                            if(channellist[jt].channels==data->cparams.format.voices)
-                            {
-                                data->cparams.format.voices=channellist[jt+1].channels;
-                                break;
-                            }
-                            if (channellist[jt].channels==0)
-                            {
-                                data->cparams.format.voices=0;
-                                break;
-                            }
-                           jt++;
-                        } while(1);
-                    }
-
-                    if (data->cparams.format.voices==0)
-                    {
-                        break;
-                    }
-                }
-
-                data->cparams.buf.block.frag_size=device->UpdateSize*
-                    data->cparams.format.voices*
-                    snd_pcm_format_width(data->cparams.format.format)/8;
-                data->cparams.buf.block.frags_max=device->NumUpdates;
-                data->cparams.buf.block.frags_min=device->NumUpdates;
-                if ((snd_pcm_plugin_params(data->pcmHandle, &data->cparams))<0)
-                {
-                    continue;
-                }
-                else
-                {
-                    break;
-                }
-            } while(1);
-
-            if (data->cparams.format.voices!=0)
-            {
-                break;
-            }
-        }
-
-        if (data->cparams.format.voices==0)
-        {
-            return ALC_FALSE;
-        }
-    }
-
-    if ((snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK))<0)
-    {
-        return ALC_FALSE;
-    }
-
-    memset(&data->csetup, 0, sizeof(data->csetup));
-    data->csetup.channel=SND_PCM_CHANNEL_PLAYBACK;
-    if (snd_pcm_plugin_setup(data->pcmHandle, &data->csetup)<0)
-    {
-        return ALC_FALSE;
-    }
-
-    /* now fill back to the our AL device */
-    device->Frequency=data->cparams.format.rate;
-
-    switch (data->cparams.format.voices)
-    {
-        case 1:
-             device->FmtChans=DevFmtMono;
-             break;
-        case 2:
-             device->FmtChans=DevFmtStereo;
-             break;
-        case 4:
-             device->FmtChans=DevFmtQuad;
-             break;
-        case 6:
-             device->FmtChans=DevFmtX51;
-             break;
-        case 7:
-             device->FmtChans=DevFmtX61;
-             break;
-        case 8:
-             device->FmtChans=DevFmtX71;
-             break;
-        default:
-             device->FmtChans=DevFmtMono;
-             break;
-    }
-
-    switch (data->cparams.format.format)
-    {
-        case SND_PCM_SFMT_S8:
-             device->FmtType=DevFmtByte;
-             break;
-        case SND_PCM_SFMT_U8:
-             device->FmtType=DevFmtUByte;
-             break;
-        case SND_PCM_SFMT_S16_LE:
-             device->FmtType=DevFmtShort;
-             break;
-        case SND_PCM_SFMT_U16_LE:
-             device->FmtType=DevFmtUShort;
-             break;
-        case SND_PCM_SFMT_S32_LE:
-             device->FmtType=DevFmtInt;
-             break;
-        case SND_PCM_SFMT_U32_LE:
-             device->FmtType=DevFmtUInt;
-             break;
-        case SND_PCM_SFMT_FLOAT_LE:
-             device->FmtType=DevFmtFloat;
-             break;
-        default:
-             device->FmtType=DevFmtShort;
-             break;
-    }
-
-    SetDefaultChannelOrder(device);
-
-    device->UpdateSize=data->csetup.buf.block.frag_size / device->frameSizeFromFmt();
-    device->NumUpdates=data->csetup.buf.block.frags;
-
-    data->size=data->csetup.buf.block.frag_size;
-    data->buffer=malloc(data->size);
-    if (!data->buffer)
-    {
-        return ALC_FALSE;
-    }
-
-    return ALC_TRUE;
-}
-
-static ALCboolean qsa_start_playback(PlaybackWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-
-    try {
-        data->mKillNow.store(AL_FALSE, std::memory_order_release);
-        data->mThread = std::thread(qsa_proc_playback, self);
-        return ALC_TRUE;
-    }
-    catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
-    }
-    catch(...) {
-    }
-    return ALC_FALSE;
-}
-
-static void qsa_stop_playback(PlaybackWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-
-    if(data->mKillNow.exchange(AL_TRUE, std::memory_order_acq_rel) || !data->mThread.joinable())
-        return;
-    data->mThread.join();
-}
-
-
-PlaybackWrapper::~PlaybackWrapper()
-{
-    if(mExtraData)
-        qsa_close_playback(this);
-}
-
-void PlaybackWrapper::open(const ALCchar *name)
-{
-    if(auto err = qsa_open_playback(this, name))
-        throw al::backend_exception{ALC_INVALID_VALUE, "%d", err};
-}
-
-bool PlaybackWrapper::reset()
-{
-    if(!qsa_reset_playback(this))
-        throw al::backend_exception{ALC_INVALID_VALUE, ""};
-    return true;
-}
-
-bool PlaybackWrapper::start()
-{ return qsa_start_playback(this); }
-
-void PlaybackWrapper::stop()
-{ qsa_stop_playback(this); }
-
-
-/***********/
-/* Capture */
-/***********/
-
-struct CaptureWrapper final : public BackendBase {
-    CaptureWrapper(ALCdevice *device) noexcept : BackendBase{device} { }
-    ~CaptureWrapper() override;
-
-    void open(const ALCchar *name) override;
-    bool start() override;
-    void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
-
-    std::unique_ptr<qsa_data> mExtraData;
-
-    DEF_NEWDEL(CaptureWrapper)
-};
-
-static ALCenum qsa_open_capture(CaptureWrapper *self, const ALCchar *deviceName)
-{
-    ALCdevice *device = self->mDevice;
-    int card, dev;
-    int format=-1;
-    int status;
-
-    std::unique_ptr<qsa_data> data{new qsa_data{}};
-
-    if(!deviceName)
-        deviceName = qsaDevice;
-
-    if(strcmp(deviceName, qsaDevice) == 0)
-        status = snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_CAPTURE);
-    else
-    {
-        if(CaptureNameMap.empty())
-            deviceList(SND_PCM_CHANNEL_CAPTURE, &CaptureNameMap);
-
-        auto iter = std::find_if(CaptureNameMap.cbegin(), CaptureNameMap.cend(),
-            [deviceName](const DevMap &entry) -> bool
-            { return entry.name && strcmp(deviceName, entry.name) == 0; }
-        );
-        if(iter == CaptureNameMap.cend())
-            return ALC_INVALID_DEVICE;
-
-        status = snd_pcm_open(&data->pcmHandle, iter->card, iter->dev, SND_PCM_OPEN_CAPTURE);
-    }
-
-    if(status < 0)
-        return ALC_INVALID_DEVICE;
-
-    data->audio_fd = snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE);
-    if(data->audio_fd < 0)
-    {
-        snd_pcm_close(data->pcmHandle);
-        return ALC_INVALID_DEVICE;
-    }
-
-    device->DeviceName = deviceName;
-
-    switch (device->FmtType)
-    {
-        case DevFmtByte:
-             format=SND_PCM_SFMT_S8;
-             break;
-        case DevFmtUByte:
-             format=SND_PCM_SFMT_U8;
-             break;
-        case DevFmtShort:
-             format=SND_PCM_SFMT_S16_LE;
-             break;
-        case DevFmtUShort:
-             format=SND_PCM_SFMT_U16_LE;
-             break;
-        case DevFmtInt:
-             format=SND_PCM_SFMT_S32_LE;
-             break;
-        case DevFmtUInt:
-             format=SND_PCM_SFMT_U32_LE;
-             break;
-        case DevFmtFloat:
-             format=SND_PCM_SFMT_FLOAT_LE;
-             break;
-    }
-
-    /* we actually don't want to block on reads */
-    snd_pcm_nonblock_mode(data->pcmHandle, 1);
-    /* Disable mmap to control data transfer to the audio device */
-    snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
-
-    /* configure a sound channel */
-    memset(&data->cparams, 0, sizeof(data->cparams));
-    data->cparams.mode=SND_PCM_MODE_BLOCK;
-    data->cparams.channel=SND_PCM_CHANNEL_CAPTURE;
-    data->cparams.start_mode=SND_PCM_START_GO;
-    data->cparams.stop_mode=SND_PCM_STOP_STOP;
-
-    data->cparams.buf.block.frag_size=device->UpdateSize * device->frameSizeFromFmt();
-    data->cparams.buf.block.frags_max=device->NumUpdates;
-    data->cparams.buf.block.frags_min=device->NumUpdates;
-
-    data->cparams.format.interleave=1;
-    data->cparams.format.rate=device->Frequency;
-    data->cparams.format.voices=device->channelsFromFmt();
-    data->cparams.format.format=format;
-
-    if(snd_pcm_plugin_params(data->pcmHandle, &data->cparams) < 0)
-    {
-        snd_pcm_close(data->pcmHandle);
-        return ALC_INVALID_VALUE;
-    }
-
-    self->mExtraData = std::move(data);
-
-    return ALC_NO_ERROR;
-}
-
-static void qsa_close_capture(CaptureWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-
-    if (data->pcmHandle!=nullptr)
-        snd_pcm_close(data->pcmHandle);
-    data->pcmHandle = nullptr;
-
-    self->mExtraData = nullptr;
-}
-
-static void qsa_start_capture(CaptureWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-    int rstatus;
-
-    if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
-    {
-        ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
-        return;
-    }
-
-    memset(&data->csetup, 0, sizeof(data->csetup));
-    data->csetup.channel=SND_PCM_CHANNEL_CAPTURE;
-    if ((rstatus=snd_pcm_plugin_setup(data->pcmHandle, &data->csetup))<0)
-    {
-        ERR("capture setup failed: %s\n", snd_strerror(rstatus));
-        return;
-    }
-
-    snd_pcm_capture_go(data->pcmHandle);
-}
-
-static void qsa_stop_capture(CaptureWrapper *self)
-{
-    qsa_data *data = self->mExtraData.get();
-    snd_pcm_capture_flush(data->pcmHandle);
-}
-
-static ALCuint qsa_available_samples(CaptureWrapper *self)
-{
-    ALCdevice *device = self->mDevice;
-    qsa_data *data = self->mExtraData.get();
-    snd_pcm_channel_status_t status;
-    ALint frame_size = device->frameSizeFromFmt();
-    ALint free_size;
-    int rstatus;
-
-    memset(&status, 0, sizeof (status));
-    status.channel=SND_PCM_CHANNEL_CAPTURE;
-    snd_pcm_plugin_status(data->pcmHandle, &status);
-    if ((status.status==SND_PCM_STATUS_OVERRUN) ||
-        (status.status==SND_PCM_STATUS_READY))
-    {
-        if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
-        {
-            ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
-            aluHandleDisconnect(device, "Failed capture recovery: %s", snd_strerror(rstatus));
-            return 0;
-        }
-
-        snd_pcm_capture_go(data->pcmHandle);
-        return 0;
-    }
-
-    free_size=data->csetup.buf.block.frag_size*data->csetup.buf.block.frags;
-    free_size-=status.free;
-
-    return free_size/frame_size;
-}
-
-static ALCenum qsa_capture_samples(CaptureWrapper *self, ALCvoid *buffer, ALCuint samples)
-{
-    ALCdevice *device = self->mDevice;
-    qsa_data *data = self->mExtraData.get();
-    char* read_ptr;
-    snd_pcm_channel_status_t status;
-    int selectret;
-    int bytes_read;
-    ALint frame_size=device->frameSizeFromFmt();
-    ALint len=samples*frame_size;
-    int rstatus;
-
-    read_ptr = static_cast<char*>(buffer);
-
-    while (len>0)
-    {
-        pollfd pollitem{};
-        pollitem.fd = data->audio_fd;
-        pollitem.events = POLLOUT;
-
-        /* Select also works like time slice to OS */
-        bytes_read=0;
-        selectret = poll(&pollitem, 1, 2000);
-        switch (selectret)
-        {
-            case -1:
-                 aluHandleDisconnect(device, "Failed to check capture samples");
-                 return ALC_INVALID_DEVICE;
-            case 0:
-                 break;
-            default:
-                 bytes_read=snd_pcm_plugin_read(data->pcmHandle, read_ptr, len);
-                 break;
-        }
-
-        if (bytes_read<=0)
-        {
-            if ((errno==EAGAIN) || (errno==EWOULDBLOCK))
-            {
-                continue;
-            }
-
-            memset(&status, 0, sizeof (status));
-            status.channel=SND_PCM_CHANNEL_CAPTURE;
-            snd_pcm_plugin_status(data->pcmHandle, &status);
-
-            /* we need to reinitialize the sound channel if we've overrun the buffer */
-            if ((status.status==SND_PCM_STATUS_OVERRUN) ||
-                (status.status==SND_PCM_STATUS_READY))
-            {
-                if ((rstatus=snd_pcm_plugin_prepare(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE))<0)
-                {
-                    ERR("capture prepare failed: %s\n", snd_strerror(rstatus));
-                    aluHandleDisconnect(device, "Failed capture recovery: %s",
-                                        snd_strerror(rstatus));
-                    return ALC_INVALID_DEVICE;
-                }
-                snd_pcm_capture_go(data->pcmHandle);
-            }
-        }
-        else
-        {
-            read_ptr+=bytes_read;
-            len-=bytes_read;
-        }
-    }
-
-    return ALC_NO_ERROR;
-}
-
-
-CaptureWrapper::~CaptureWrapper()
-{
-    if(mExtraData)
-        qsa_close_capture(this);
-}
-
-void CaptureWrapper::open(const ALCchar *name)
-{
-    if(auto err = qsa_open_capture(this, name))
-        throw al::backend_exception{ALC_INVALID_VALUE, "%d", err};
-}
-
-bool CaptureWrapper::start()
-{ qsa_start_capture(this); return true; }
-
-void CaptureWrapper::stop()
-{ qsa_stop_capture(this); }
-
-ALCenum CaptureWrapper::captureSamples(al::byte *buffer, ALCuint samples)
-{ return qsa_capture_samples(this, buffer, samples); }
-
-ALCuint CaptureWrapper::availableSamples()
-{ return qsa_available_samples(this); }
-
-} // namespace
-
-
-bool QSABackendFactory::init()
-{ return true; }
-
-bool QSABackendFactory::querySupport(BackendType type)
-{ return (type == BackendType::Playback || type == BackendType::Capture); }
-
-void QSABackendFactory::probe(DevProbe type, std::string *outnames)
-{
-    auto add_device = [outnames](const DevMap &entry) -> void
-    {
-        const char *n = entry.name;
-        if(n && n[0])
-            outnames->append(n, strlen(n)+1);
-    };
-
-    switch (type)
-    {
-        case DevProbe::Playback:
-            deviceList(SND_PCM_CHANNEL_PLAYBACK, &DeviceNameMap);
-            std::for_each(DeviceNameMap.cbegin(), DeviceNameMap.cend(), add_device);
-            break;
-        case DevProbe::Capture:
-            deviceList(SND_PCM_CHANNEL_CAPTURE, &CaptureNameMap);
-            std::for_each(CaptureNameMap.cbegin(), CaptureNameMap.cend(), add_device);
-            break;
-    }
-}
-
-BackendPtr QSABackendFactory::createBackend(ALCdevice *device, BackendType type)
-{
-    if(type == BackendType::Playback)
-        return BackendPtr{new PlaybackWrapper{device}};
-    if(type == BackendType::Capture)
-        return BackendPtr{new CaptureWrapper{device}};
-    return nullptr;
-}
-
-BackendFactory &QSABackendFactory::getFactory()
-{
-    static QSABackendFactory factory{};
-    return factory;
-}
diff --git a/alc/backends/qsa.h b/alc/backends/qsa.h
deleted file mode 100644
index da548bba..00000000
--- a/alc/backends/qsa.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef BACKENDS_QSA_H
-#define BACKENDS_QSA_H
-
-#include "backends/base.h"
-
-struct QSABackendFactory final : public BackendFactory {
-public:
-    bool init() override;
-
-    bool querySupport(BackendType type) override;
-
-    void probe(DevProbe type, std::string *outnames) override;
-
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
-
-    static BackendFactory &getFactory();
-};
-
-#endif /* BACKENDS_QSA_H */
diff --git a/alc/backends/sdl2.cpp b/alc/backends/sdl2.cpp
index 25b5d4d9..a4a5a9ac 100644
--- a/alc/backends/sdl2.cpp
+++ b/alc/backends/sdl2.cpp
@@ -20,22 +20,22 @@
 
 #include "config.h"
 
-#include "backends/sdl2.h"
+#include "sdl2.h"
 
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "alexcpt.h"
 #include "almalloc.h"
-#include "alu.h"
-#include "logging.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/logging.h"
 
-#include <SDL2/SDL.h>
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")
+#include "SDL.h"
+_Pragma("GCC diagnostic pop")
 
 
 namespace {
@@ -46,30 +46,28 @@ namespace {
 #define DEVNAME_PREFIX ""
 #endif
 
-constexpr ALCchar defaultDeviceName[] = DEVNAME_PREFIX "Default Device";
+constexpr char defaultDeviceName[] = DEVNAME_PREFIX "Default Device";
 
 struct Sdl2Backend final : public BackendBase {
-    Sdl2Backend(ALCdevice *device) noexcept : BackendBase{device} { }
+    Sdl2Backend(DeviceBase *device) noexcept : BackendBase{device} { }
     ~Sdl2Backend() override;
 
     void audioCallback(Uint8 *stream, int len) noexcept;
     static void audioCallbackC(void *ptr, Uint8 *stream, int len) noexcept
     { static_cast<Sdl2Backend*>(ptr)->audioCallback(stream, len); }
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
-    void lock() override;
-    void unlock() override;
 
     SDL_AudioDeviceID mDeviceID{0u};
-    ALuint mFrameSize{0};
+    uint mFrameSize{0};
 
-    ALuint mFrequency{0u};
+    uint mFrequency{0u};
     DevFmtChannels mFmtChans{};
     DevFmtType     mFmtType{};
-    ALuint mUpdateSize{0u};
+    uint mUpdateSize{0u};
 
     DEF_NEWDEL(Sdl2Backend)
 };
@@ -85,10 +83,10 @@ void Sdl2Backend::audioCallback(Uint8 *stream, int len) noexcept
 {
     const auto ulen = static_cast<unsigned int>(len);
     assert((ulen % mFrameSize) == 0);
-    aluMixData(mDevice, stream, ulen / mFrameSize);
+    mDevice->renderSamples(stream, ulen / mFrameSize, mDevice->channelsFromFmt());
 }
 
-void Sdl2Backend::open(const ALCchar *name)
+void Sdl2Backend::open(const char *name)
 {
     SDL_AudioSpec want{}, have{};
 
@@ -104,59 +102,64 @@ void Sdl2Backend::open(const ALCchar *name)
     case DevFmtFloat: want.format = AUDIO_F32; break;
     }
     want.channels = (mDevice->FmtChans == DevFmtMono) ? 1 : 2;
-    want.samples = static_cast<Uint16>(mDevice->UpdateSize);
+    want.samples = static_cast<Uint16>(minu(mDevice->UpdateSize, 8192));
     want.callback = &Sdl2Backend::audioCallbackC;
     want.userdata = this;
 
     /* Passing nullptr to SDL_OpenAudioDevice opens a default, which isn't
      * necessarily the first in the list.
      */
+    SDL_AudioDeviceID devid;
     if(!name || strcmp(name, defaultDeviceName) == 0)
-        mDeviceID = SDL_OpenAudioDevice(nullptr, SDL_FALSE, &want, &have,
-            SDL_AUDIO_ALLOW_ANY_CHANGE);
+        devid = SDL_OpenAudioDevice(nullptr, SDL_FALSE, &want, &have, SDL_AUDIO_ALLOW_ANY_CHANGE);
     else
     {
         const size_t prefix_len = strlen(DEVNAME_PREFIX);
         if(strncmp(name, DEVNAME_PREFIX, prefix_len) == 0)
-            mDeviceID = SDL_OpenAudioDevice(name+prefix_len, SDL_FALSE, &want, &have,
+            devid = SDL_OpenAudioDevice(name+prefix_len, SDL_FALSE, &want, &have,
                 SDL_AUDIO_ALLOW_ANY_CHANGE);
         else
-            mDeviceID = SDL_OpenAudioDevice(name, SDL_FALSE, &want, &have,
-                SDL_AUDIO_ALLOW_ANY_CHANGE);
+            devid = SDL_OpenAudioDevice(name, SDL_FALSE, &want, &have, SDL_AUDIO_ALLOW_ANY_CHANGE);
     }
-    if(mDeviceID == 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s", SDL_GetError()};
-
-    mDevice->Frequency = static_cast<ALuint>(have.freq);
-
-    if(have.channels == 1)
-        mDevice->FmtChans = DevFmtMono;
-    else if(have.channels == 2)
-        mDevice->FmtChans = DevFmtStereo;
+    if(!devid)
+        throw al::backend_exception{al::backend_error::NoDevice, "%s", SDL_GetError()};
+
+    DevFmtChannels devchans{};
+    if(have.channels >= 2)
+        devchans = DevFmtStereo;
+    else if(have.channels == 1)
+        devchans = DevFmtMono;
     else
-        throw al::backend_exception{ALC_INVALID_VALUE, "Unhandled SDL channel count: %d",
-            int{have.channels}};
+    {
+        SDL_CloseAudioDevice(devid);
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Unhandled SDL channel count: %d", int{have.channels}};
+    }
 
+    DevFmtType devtype{};
     switch(have.format)
     {
-    case AUDIO_U8:     mDevice->FmtType = DevFmtUByte;  break;
-    case AUDIO_S8:     mDevice->FmtType = DevFmtByte;   break;
-    case AUDIO_U16SYS: mDevice->FmtType = DevFmtUShort; break;
-    case AUDIO_S16SYS: mDevice->FmtType = DevFmtShort;  break;
-    case AUDIO_S32SYS: mDevice->FmtType = DevFmtInt;    break;
-    case AUDIO_F32SYS: mDevice->FmtType = DevFmtFloat;  break;
+    case AUDIO_U8:     devtype = DevFmtUByte;  break;
+    case AUDIO_S8:     devtype = DevFmtByte;   break;
+    case AUDIO_U16SYS: devtype = DevFmtUShort; break;
+    case AUDIO_S16SYS: devtype = DevFmtShort;  break;
+    case AUDIO_S32SYS: devtype = DevFmtInt;    break;
+    case AUDIO_F32SYS: devtype = DevFmtFloat;  break;
     default:
-        throw al::backend_exception{ALC_INVALID_VALUE, "Unhandled SDL format: 0x%04x",
+        SDL_CloseAudioDevice(devid);
+        throw al::backend_exception{al::backend_error::DeviceError, "Unhandled SDL format: 0x%04x",
             have.format};
     }
-    mDevice->UpdateSize = have.samples;
-    mDevice->BufferSize = have.samples * 2; /* SDL always (tries to) use two periods. */
 
-    mFrameSize = mDevice->frameSizeFromFmt();
-    mFrequency = mDevice->Frequency;
-    mFmtChans = mDevice->FmtChans;
-    mFmtType = mDevice->FmtType;
-    mUpdateSize = mDevice->UpdateSize;
+    if(mDeviceID)
+        SDL_CloseAudioDevice(mDeviceID);
+    mDeviceID = devid;
+
+    mFrameSize = BytesFromDevFmt(devtype) * have.channels;
+    mFrequency = static_cast<uint>(have.freq);
+    mFmtChans = devchans;
+    mFmtType = devtype;
+    mUpdateSize = have.samples;
 
     mDevice->DeviceName = name ? name : defaultDeviceName;
 }
@@ -167,26 +170,17 @@ bool Sdl2Backend::reset()
     mDevice->FmtChans = mFmtChans;
     mDevice->FmtType = mFmtType;
     mDevice->UpdateSize = mUpdateSize;
-    mDevice->BufferSize = mUpdateSize * 2;
-    SetDefaultWFXChannelOrder(mDevice);
+    mDevice->BufferSize = mUpdateSize * 2; /* SDL always (tries to) use two periods. */
+    setDefaultWFXChannelOrder();
     return true;
 }
 
-bool Sdl2Backend::start()
-{
-    SDL_PauseAudioDevice(mDeviceID, 0);
-    return true;
-}
+void Sdl2Backend::start()
+{ SDL_PauseAudioDevice(mDeviceID, 0); }
 
 void Sdl2Backend::stop()
 { SDL_PauseAudioDevice(mDeviceID, 1); }
 
-void Sdl2Backend::lock()
-{ SDL_LockAudioDevice(mDeviceID); }
-
-void Sdl2Backend::unlock()
-{ SDL_UnlockAudioDevice(mDeviceID); }
-
 } // namespace
 
 BackendFactory &SDL2BackendFactory::getFactory()
@@ -201,25 +195,28 @@ bool SDL2BackendFactory::init()
 bool SDL2BackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback; }
 
-void SDL2BackendFactory::probe(DevProbe type, std::string *outnames)
+std::string SDL2BackendFactory::probe(BackendType type)
 {
-    if(type != DevProbe::Playback)
-        return;
+    std::string outnames;
+
+    if(type != BackendType::Playback)
+        return outnames;
 
     int num_devices{SDL_GetNumAudioDevices(SDL_FALSE)};
 
     /* Includes null char. */
-    outnames->append(defaultDeviceName, sizeof(defaultDeviceName));
+    outnames.append(defaultDeviceName, sizeof(defaultDeviceName));
     for(int i{0};i < num_devices;++i)
     {
         std::string name{DEVNAME_PREFIX};
         name += SDL_GetAudioDeviceName(i, SDL_FALSE);
         if(!name.empty())
-            outnames->append(name.c_str(), name.length()+1);
+            outnames.append(name.c_str(), name.length()+1);
     }
+    return outnames;
 }
 
-BackendPtr SDL2BackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SDL2BackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new Sdl2Backend{device}};
diff --git a/alc/backends/sdl2.h b/alc/backends/sdl2.h
index 041d47ee..3bd8df86 100644
--- a/alc/backends/sdl2.h
+++ b/alc/backends/sdl2.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_SDL2_H
 #define BACKENDS_SDL2_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct SDL2BackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/sndio.cpp b/alc/backends/sndio.cpp
index 7799316f..077e77f2 100644
--- a/alc/backends/sndio.cpp
+++ b/alc/backends/sndio.cpp
@@ -20,44 +20,52 @@
 
 #include "config.h"
 
-#include "backends/sndio.h"
+#include "sndio.h"
 
+#include <functional>
+#include <inttypes.h>
+#include <poll.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
 #include <thread>
-#include <functional>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
+#include "ringbuffer.h"
 #include "threads.h"
 #include "vector.h"
-#include "ringbuffer.h"
 
 #include <sndio.h>
 
 
 namespace {
 
-static const ALCchar sndio_device[] = "SndIO Default";
+static const char sndio_device[] = "SndIO Default";
+
+struct SioPar : public sio_par {
+    SioPar() { sio_initpar(this); }
 
+    void clear() { sio_initpar(this); }
+};
 
 struct SndioPlayback final : public BackendBase {
-    SndioPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    SndioPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~SndioPlayback() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     sio_hdl *mSndHandle{nullptr};
+    uint mFrameStep{};
 
-    al::vector<ALubyte> mBuffer;
+    al::vector<al::byte> mBuffer;
 
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
@@ -74,33 +82,29 @@ SndioPlayback::~SndioPlayback()
 
 int SndioPlayback::mixerProc()
 {
+    const size_t frameStep{mFrameStep};
+    const size_t frameSize{frameStep * mDevice->bytesFromFmt()};
+
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    const ALuint frameSize{mDevice->frameSizeFromFmt()};
-
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
-        ALubyte *WritePtr{mBuffer.data()};
-        size_t len{mBuffer.size()};
+        al::span<al::byte> buffer{mBuffer};
 
+        mDevice->renderSamples(buffer.data(), static_cast<uint>(buffer.size() / frameSize),
+            frameStep);
+        while(!buffer.empty() && !mKillNow.load(std::memory_order_acquire))
         {
-            std::lock_guard<SndioPlayback> _{*this};
-            aluMixData(mDevice, WritePtr, static_cast<ALuint>(len/frameSize));
-        }
-        while(len > 0 && !mKillNow.load(std::memory_order_acquire))
-        {
-            size_t wrote{sio_write(mSndHandle, WritePtr, len)};
-            if(wrote == 0)
+            size_t wrote{sio_write(mSndHandle, buffer.data(), buffer.size())};
+            if(wrote > buffer.size() || wrote == 0)
             {
-                ERR("sio_write failed\n");
-                aluHandleDisconnect(mDevice, "Failed to write playback samples");
+                ERR("sio_write failed: 0x%" PRIx64 "\n", wrote);
+                mDevice->handleDisconnect("Failed to write playback samples");
                 break;
             }
-
-            len -= wrote;
-            WritePtr += wrote;
+            buffer = buffer.subspan(wrote);
         }
     }
 
@@ -108,126 +112,150 @@ int SndioPlayback::mixerProc()
 }
 
 
-void SndioPlayback::open(const ALCchar *name)
+void SndioPlayback::open(const char *name)
 {
     if(!name)
         name = sndio_device;
     else if(strcmp(name, sndio_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
-    mSndHandle = sio_open(nullptr, SIO_PLAY, 0);
-    if(mSndHandle == nullptr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open backend device"};
+    sio_hdl *sndHandle{sio_open(nullptr, SIO_PLAY, 0)};
+    if(!sndHandle)
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not open backend device"};
+
+    if(mSndHandle)
+        sio_close(mSndHandle);
+    mSndHandle = sndHandle;
 
     mDevice->DeviceName = name;
 }
 
 bool SndioPlayback::reset()
 {
-    sio_par par;
-    sio_initpar(&par);
-
-    par.rate = mDevice->Frequency;
-    par.pchan = ((mDevice->FmtChans != DevFmtMono) ? 2 : 1);
+    SioPar par;
 
-    switch(mDevice->FmtType)
+    auto tryfmt = mDevice->FmtType;
+retry_params:
+    switch(tryfmt)
     {
-        case DevFmtByte:
-            par.bits = 8;
-            par.sig = 1;
-            break;
-        case DevFmtUByte:
-            par.bits = 8;
-            par.sig = 0;
-            break;
-        case DevFmtFloat:
-        case DevFmtShort:
-            par.bits = 16;
-            par.sig = 1;
-            break;
-        case DevFmtUShort:
-            par.bits = 16;
-            par.sig = 0;
-            break;
-        case DevFmtInt:
-            par.bits = 32;
-            par.sig = 1;
-            break;
-        case DevFmtUInt:
-            par.bits = 32;
-            par.sig = 0;
-            break;
+    case DevFmtByte:
+        par.bits = 8;
+        par.sig = 1;
+        break;
+    case DevFmtUByte:
+        par.bits = 8;
+        par.sig = 0;
+        break;
+    case DevFmtShort:
+        par.bits = 16;
+        par.sig = 1;
+        break;
+    case DevFmtUShort:
+        par.bits = 16;
+        par.sig = 0;
+        break;
+    case DevFmtFloat:
+    case DevFmtInt:
+        par.bits = 32;
+        par.sig = 1;
+        break;
+    case DevFmtUInt:
+        par.bits = 32;
+        par.sig = 0;
+        break;
     }
+    par.bps = SIO_BPS(par.bits);
     par.le = SIO_LE_NATIVE;
+    par.msb = 1;
+
+    par.rate = mDevice->Frequency;
+    par.pchan = mDevice->channelsFromFmt();
 
     par.round = mDevice->UpdateSize;
     par.appbufsz = mDevice->BufferSize - mDevice->UpdateSize;
     if(!par.appbufsz) par.appbufsz = mDevice->UpdateSize;
 
-    if(!sio_setpar(mSndHandle, &par) || !sio_getpar(mSndHandle, &par))
-    {
-        ERR("Failed to set device parameters\n");
-        return false;
+    try {
+        if(!sio_setpar(mSndHandle, &par))
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to set device parameters"};
+
+        par.clear();
+        if(!sio_getpar(mSndHandle, &par))
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Failed to get device parameters"};
+
+        if(par.bps > 1 && par.le != SIO_LE_NATIVE)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "%s-endian samples not supported", par.le ? "Little" : "Big"};
+        if(par.bits < par.bps*8 && !par.msb)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "MSB-padded samples not supported (%u of %u bits)", par.bits, par.bps*8};
+        if(par.pchan < 1)
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "No playback channels on device"};
     }
-
-    if(par.bits != par.bps*8)
-    {
-        ERR("Padded samples not supported (%u of %u bits)\n", par.bits, par.bps*8);
-        return true;
+    catch(al::backend_exception &e) {
+        if(tryfmt == DevFmtShort)
+            throw;
+        par.clear();
+        tryfmt = DevFmtShort;
+        goto retry_params;
     }
 
-    mDevice->Frequency = par.rate;
-    mDevice->FmtChans = ((par.pchan==1) ? DevFmtMono : DevFmtStereo);
-
-    if(par.bits == 8 && par.sig == 1)
-        mDevice->FmtType = DevFmtByte;
-    else if(par.bits == 8 && par.sig == 0)
-        mDevice->FmtType = DevFmtUByte;
-    else if(par.bits == 16 && par.sig == 1)
-        mDevice->FmtType = DevFmtShort;
-    else if(par.bits == 16 && par.sig == 0)
-        mDevice->FmtType = DevFmtUShort;
-    else if(par.bits == 32 && par.sig == 1)
-        mDevice->FmtType = DevFmtInt;
-    else if(par.bits == 32 && par.sig == 0)
-        mDevice->FmtType = DevFmtUInt;
+    if(par.bps == 1)
+        mDevice->FmtType = (par.sig==1) ? DevFmtByte : DevFmtUByte;
+    else if(par.bps == 2)
+        mDevice->FmtType = (par.sig==1) ? DevFmtShort : DevFmtUShort;
+    else if(par.bps == 4)
+        mDevice->FmtType = (par.sig==1) ? DevFmtInt : DevFmtUInt;
     else
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Unhandled sample format: %s %u-bit", (par.sig?"signed":"unsigned"), par.bps*8};
+
+    mFrameStep = par.pchan;
+    if(par.pchan != mDevice->channelsFromFmt())
     {
-        ERR("Unhandled sample format: %s %u-bit\n", (par.sig?"signed":"unsigned"), par.bits);
-        return false;
+        WARN("Got %u channel%s for %s\n", par.pchan, (par.pchan==1)?"":"s",
+            DevFmtChannelsString(mDevice->FmtChans));
+        if(par.pchan < 2) mDevice->FmtChans = DevFmtMono;
+        else mDevice->FmtChans = DevFmtStereo;
     }
+    mDevice->Frequency = par.rate;
 
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     mDevice->UpdateSize = par.round;
     mDevice->BufferSize = par.bufsz + par.round;
 
-    mBuffer.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
-    std::fill(mBuffer.begin(), mBuffer.end(), 0);
+    mBuffer.resize(mDevice->UpdateSize * par.pchan*par.bps);
+    if(par.sig == 1)
+        std::fill(mBuffer.begin(), mBuffer.end(), al::byte{});
+    else if(par.bits == 8)
+        std::fill_n(mBuffer.data(), mBuffer.size(), al::byte(0x80));
+    else if(par.bits == 16)
+        std::fill_n(reinterpret_cast<uint16_t*>(mBuffer.data()), mBuffer.size()/2, 0x8000);
+    else if(par.bits == 32)
+        std::fill_n(reinterpret_cast<uint32_t*>(mBuffer.data()), mBuffer.size()/4, 0x80000000u);
 
     return true;
 }
 
-bool SndioPlayback::start()
+void SndioPlayback::start()
 {
     if(!sio_start(mSndHandle))
-    {
-        ERR("Error starting playback\n");
-        return false;
-    }
+        throw al::backend_exception{al::backend_error::DeviceError, "Error starting playback"};
 
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&SndioPlayback::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
+        sio_stop(mSndHandle);
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    sio_stop(mSndHandle);
-    return false;
 }
 
 void SndioPlayback::stop()
@@ -241,17 +269,22 @@ void SndioPlayback::stop()
 }
 
 
+/* TODO: This could be improved by avoiding the ring buffer and record thread,
+ * counting the available samples with the sio_onmove callback and reading
+ * directly from the device. However, this depends on reasonable support for
+ * capture buffer sizes apps may request.
+ */
 struct SndioCapture final : public BackendBase {
-    SndioCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    SndioCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~SndioCapture() override;
 
     int recordProc();
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
     sio_hdl *mSndHandle{nullptr};
 
@@ -275,150 +308,182 @@ int SndioCapture::recordProc()
     SetRTPriority();
     althrd_setname(RECORD_THREAD_NAME);
 
-    const ALuint frameSize{mDevice->frameSizeFromFmt()};
+    const uint frameSize{mDevice->frameSizeFromFmt()};
 
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    int nfds_pre{sio_nfds(mSndHandle)};
+    if(nfds_pre <= 0)
     {
-        auto data = mRing->getWriteVector();
-        size_t todo{data.first.len + data.second.len};
-        if(todo == 0)
+        mDevice->handleDisconnect("Incorrect return value from sio_nfds(): %d", nfds_pre);
+        return 1;
+    }
+
+    auto fds = std::make_unique<pollfd[]>(static_cast<uint>(nfds_pre));
+
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
+    {
+        /* Wait until there's some samples to read. */
+        const int nfds{sio_pollfd(mSndHandle, fds.get(), POLLIN)};
+        if(nfds <= 0)
         {
-            static char junk[4096];
-            sio_read(mSndHandle, junk,
-                minz(sizeof(junk)/frameSize, mDevice->UpdateSize)*frameSize);
-            continue;
+            mDevice->handleDisconnect("Failed to get polling fds: %d", nfds);
+            break;
+        }
+        int pollres{::poll(fds.get(), static_cast<uint>(nfds), 2000)};
+        if(pollres < 0)
+        {
+            if(errno == EINTR) continue;
+            mDevice->handleDisconnect("Poll error: %s", strerror(errno));
+            break;
         }
+        if(pollres == 0)
+            continue;
 
-        size_t total{0u};
-        data.first.len  *= frameSize;
-        data.second.len *= frameSize;
-        todo = minz(todo, mDevice->UpdateSize) * frameSize;
-        while(total < todo)
+        const int revents{sio_revents(mSndHandle, fds.get())};
+        if((revents&POLLHUP))
         {
-            if(!data.first.len)
-                data.first = data.second;
+            mDevice->handleDisconnect("Got POLLHUP from poll events");
+            break;
+        }
+        if(!(revents&POLLIN))
+            continue;
 
-            size_t got{sio_read(mSndHandle, data.first.buf, minz(todo-total, data.first.len))};
-            if(!got)
+        auto data = mRing->getWriteVector();
+        al::span<al::byte> buffer{data.first.buf, data.first.len*frameSize};
+        while(!buffer.empty())
+        {
+            size_t got{sio_read(mSndHandle, buffer.data(), buffer.size())};
+            if(got == 0)
+                break;
+            if(got > buffer.size())
             {
-                aluHandleDisconnect(mDevice, "Failed to read capture samples");
+                ERR("sio_read failed: 0x%" PRIx64 "\n", got);
+                mDevice->handleDisconnect("sio_read failed: 0x%" PRIx64, got);
                 break;
             }
 
-            data.first.buf += got;
-            data.first.len -= got;
-            total += got;
+            mRing->writeAdvance(got / frameSize);
+            buffer = buffer.subspan(got);
+            if(buffer.empty())
+            {
+                data = mRing->getWriteVector();
+                buffer = {data.first.buf, data.first.len*frameSize};
+            }
+        }
+        if(buffer.empty())
+        {
+            /* Got samples to read, but no place to store it. Drop it. */
+            static char junk[4096];
+            sio_read(mSndHandle, junk, sizeof(junk) - (sizeof(junk)%frameSize));
         }
-        mRing->writeAdvance(total / frameSize);
     }
 
     return 0;
 }
 
 
-void SndioCapture::open(const ALCchar *name)
+void SndioCapture::open(const char *name)
 {
     if(!name)
         name = sndio_device;
     else if(strcmp(name, sndio_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
-    mSndHandle = sio_open(nullptr, SIO_REC, 0);
+    mSndHandle = sio_open(nullptr, SIO_REC, true);
     if(mSndHandle == nullptr)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open backend device"};
-
-    sio_par par;
-    sio_initpar(&par);
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not open backend device"};
 
+    SioPar par;
     switch(mDevice->FmtType)
     {
     case DevFmtByte:
-        par.bps = 1;
+        par.bits = 8;
         par.sig = 1;
         break;
     case DevFmtUByte:
-        par.bps = 1;
+        par.bits = 8;
         par.sig = 0;
         break;
     case DevFmtShort:
-        par.bps = 2;
+        par.bits = 16;
         par.sig = 1;
         break;
     case DevFmtUShort:
-        par.bps = 2;
+        par.bits = 16;
         par.sig = 0;
         break;
     case DevFmtInt:
-        par.bps = 4;
+        par.bits = 32;
         par.sig = 1;
         break;
     case DevFmtUInt:
-        par.bps = 4;
+        par.bits = 32;
         par.sig = 0;
         break;
     case DevFmtFloat:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture samples not supported",
-            DevFmtTypeString(mDevice->FmtType)};
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
     }
-    par.bits = par.bps * 8;
+    par.bps = SIO_BPS(par.bits);
     par.le = SIO_LE_NATIVE;
-    par.msb = SIO_LE_NATIVE ? 0 : 1;
+    par.msb = 1;
     par.rchan = mDevice->channelsFromFmt();
     par.rate = mDevice->Frequency;
 
     par.appbufsz = maxu(mDevice->BufferSize, mDevice->Frequency/10);
-    par.round = minu(par.appbufsz, mDevice->Frequency/40);
-
-    mDevice->UpdateSize = par.round;
-    mDevice->BufferSize = par.appbufsz;
+    par.round = minu(par.appbufsz/2, mDevice->Frequency/40);
 
     if(!sio_setpar(mSndHandle, &par) || !sio_getpar(mSndHandle, &par))
-        throw al::backend_exception{ALC_INVALID_VALUE, "Failed to set device praameters"};
-
-    if(par.bits != par.bps*8)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to set device praameters"};
+
+    if(par.bps > 1 && par.le != SIO_LE_NATIVE)
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "%s-endian samples not supported", par.le ? "Little" : "Big"};
+    if(par.bits < par.bps*8 && !par.msb)
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Padded samples not supported (got %u of %u bits)", par.bits, par.bps*8};
 
-    if(!((mDevice->FmtType == DevFmtByte && par.bits == 8 && par.sig != 0)
-        || (mDevice->FmtType == DevFmtUByte && par.bits == 8 && par.sig == 0)
-        || (mDevice->FmtType == DevFmtShort && par.bits == 16 && par.sig != 0)
-        || (mDevice->FmtType == DevFmtUShort && par.bits == 16 && par.sig == 0)
-        || (mDevice->FmtType == DevFmtInt && par.bits == 32 && par.sig != 0)
-        || (mDevice->FmtType == DevFmtUInt && par.bits == 32 && par.sig == 0))
-        || mDevice->channelsFromFmt() != par.rchan || mDevice->Frequency != par.rate)
-        throw al::backend_exception{ALC_INVALID_VALUE,
+    auto match_fmt = [](DevFmtType fmttype, const sio_par &p) -> bool
+    {
+        return (fmttype == DevFmtByte && p.bps == 1 && p.sig != 0)
+            || (fmttype == DevFmtUByte && p.bps == 1 && p.sig == 0)
+            || (fmttype == DevFmtShort && p.bps == 2 && p.sig != 0)
+            || (fmttype == DevFmtUShort && p.bps == 2 && p.sig == 0)
+            || (fmttype == DevFmtInt && p.bps == 4 && p.sig != 0)
+            || (fmttype == DevFmtUInt && p.bps == 4 && p.sig == 0);
+    };
+    if(!match_fmt(mDevice->FmtType, par) || mDevice->channelsFromFmt() != par.rchan
+        || mDevice->Frequency != par.rate)
+        throw al::backend_exception{al::backend_error::DeviceError,
             "Failed to set format %s %s %uhz, got %c%u %u-channel %uhz instead",
             DevFmtTypeString(mDevice->FmtType), DevFmtChannelsString(mDevice->FmtChans),
-            mDevice->Frequency, par.sig?'s':'u', par.bits, par.rchan, par.rate};
+            mDevice->Frequency, par.sig?'s':'u', par.bps*8, par.rchan, par.rate};
 
-    mRing = CreateRingBuffer(mDevice->BufferSize, par.bps*par.rchan, false);
+    mRing = RingBuffer::Create(mDevice->BufferSize, par.bps*par.rchan, false);
+    mDevice->BufferSize = static_cast<uint>(mRing->writeSpace());
+    mDevice->UpdateSize = par.round;
 
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
     mDevice->DeviceName = name;
 }
 
-bool SndioCapture::start()
+void SndioCapture::start()
 {
     if(!sio_start(mSndHandle))
-    {
-        ERR("Error starting playback\n");
-        return false;
-    }
+        throw al::backend_exception{al::backend_error::DeviceError, "Error starting capture"};
 
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&SndioCapture::recordProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create record thread: %s\n", e.what());
+        sio_stop(mSndHandle);
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start capture thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    sio_stop(mSndHandle);
-    return false;
 }
 
 void SndioCapture::stop()
@@ -431,14 +496,11 @@ void SndioCapture::stop()
         ERR("Error stopping device\n");
 }
 
-ALCenum SndioCapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+void SndioCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
-ALCuint SndioCapture::availableSamples()
-{ return static_cast<ALCuint>(mRing->readSpace()); }
+uint SndioCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
 
 } // namespace
 
@@ -454,19 +516,21 @@ bool SndIOBackendFactory::init()
 bool SndIOBackendFactory::querySupport(BackendType type)
 { return (type == BackendType::Playback || type == BackendType::Capture); }
 
-void SndIOBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string SndIOBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-        case DevProbe::Capture:
-            /* Includes null char. */
-            outnames->append(sndio_device, sizeof(sndio_device));
-            break;
+    case BackendType::Playback:
+    case BackendType::Capture:
+        /* Includes null char. */
+        outnames.append(sndio_device, sizeof(sndio_device));
+        break;
     }
+    return outnames;
 }
 
-BackendPtr SndIOBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SndIOBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new SndioPlayback{device}};
diff --git a/alc/backends/sndio.h b/alc/backends/sndio.h
index 1ed63d5e..d9433191 100644
--- a/alc/backends/sndio.h
+++ b/alc/backends/sndio.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_SNDIO_H
 #define BACKENDS_SNDIO_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct SndIOBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/solaris.cpp b/alc/backends/solaris.cpp
index 7cc2606e..791609ce 100644
--- a/alc/backends/solaris.cpp
+++ b/alc/backends/solaris.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/solaris.h"
+#include "solaris.h"
 
 #include <sys/ioctl.h>
 #include <sys/types.h>
@@ -34,42 +34,44 @@
 #include <errno.h>
 #include <poll.h>
 #include <math.h>
+#include <string.h>
 
 #include <thread>
 #include <functional>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
-#include "alconfig.h"
+#include "albyte.h"
+#include "alc/alconfig.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "threads.h"
 #include "vector.h"
-#include "compat.h"
 
 #include <sys/audioio.h>
 
 
 namespace {
 
-constexpr ALCchar solaris_device[] = "Solaris Default";
+constexpr char solaris_device[] = "Solaris Default";
 
 std::string solaris_driver{"/dev/audio"};
 
 
 struct SolarisBackend final : public BackendBase {
-    SolarisBackend(ALCdevice *device) noexcept : BackendBase{device} { }
+    SolarisBackend(DeviceBase *device) noexcept : BackendBase{device} { }
     ~SolarisBackend() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     int mFd{-1};
 
-    al::vector<ALubyte> mBuffer;
+    uint mFrameStep{};
+    al::vector<al::byte> mBuffer;
 
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
@@ -89,26 +91,23 @@ int SolarisBackend::mixerProc()
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    const ALuint frame_size{mDevice->frameSizeFromFmt()};
+    const size_t frame_step{mDevice->channelsFromFmt()};
+    const uint frame_size{mDevice->frameSizeFromFmt()};
 
-    std::unique_lock<SolarisBackend> dlock{*this};
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         pollfd pollitem{};
         pollitem.fd = mFd;
         pollitem.events = POLLOUT;
 
-        dlock.unlock();
         int pret{poll(&pollitem, 1, 1000)};
-        dlock.lock();
         if(pret < 0)
         {
             if(errno == EINTR || errno == EAGAIN)
                 continue;
             ERR("poll failed: %s\n", strerror(errno));
-            aluHandleDisconnect(mDevice, "Failed to wait for playback buffer: %s",
-                strerror(errno));
+            mDevice->handleDisconnect("Failed to wait for playback buffer: %s", strerror(errno));
             break;
         }
         else if(pret == 0)
@@ -117,9 +116,9 @@ int SolarisBackend::mixerProc()
             continue;
         }
 
-        ALubyte *write_ptr{mBuffer.data()};
+        al::byte *write_ptr{mBuffer.data()};
         size_t to_write{mBuffer.size()};
-        aluMixData(mDevice, write_ptr, to_write/frame_size);
+        mDevice->renderSamples(write_ptr, static_cast<uint>(to_write/frame_size), frame_step);
         while(to_write > 0 && !mKillNow.load(std::memory_order_acquire))
         {
             ssize_t wrote{write(mFd, write_ptr, to_write)};
@@ -128,12 +127,11 @@ int SolarisBackend::mixerProc()
                 if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
                     continue;
                 ERR("write failed: %s\n", strerror(errno));
-                aluHandleDisconnect(mDevice, "Failed to write playback samples: %s",
-                    strerror(errno));
+                mDevice->handleDisconnect("Failed to write playback samples: %s", strerror(errno));
                 break;
             }
 
-            to_write -= wrote;
+            to_write -= static_cast<size_t>(wrote);
             write_ptr += wrote;
         }
     }
@@ -142,18 +140,23 @@ int SolarisBackend::mixerProc()
 }
 
 
-void SolarisBackend::open(const ALCchar *name)
+void SolarisBackend::open(const char *name)
 {
     if(!name)
         name = solaris_device;
     else if(strcmp(name, solaris_device) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
 
-    mFd = ::open(solaris_driver.c_str(), O_WRONLY);
-    if(mFd == -1)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open %s: %s",
+    int fd{::open(solaris_driver.c_str(), O_WRONLY)};
+    if(fd == -1)
+        throw al::backend_exception{al::backend_error::NoDevice, "Could not open %s: %s",
             solaris_driver.c_str(), strerror(errno)};
 
+    if(mFd != -1)
+        ::close(mFd);
+    mFd = fd;
+
     mDevice->DeviceName = name;
 }
 
@@ -163,36 +166,29 @@ bool SolarisBackend::reset()
     AUDIO_INITINFO(&info);
 
     info.play.sample_rate = mDevice->Frequency;
-
-    if(mDevice->FmtChans != DevFmtMono)
-        mDevice->FmtChans = DevFmtStereo;
-    ALuint numChannels{mDevice->channelsFromFmt()};
-    info.play.channels = numChannels;
-
+    info.play.channels = mDevice->channelsFromFmt();
     switch(mDevice->FmtType)
     {
-        case DevFmtByte:
-            info.play.precision = 8;
-            info.play.encoding = AUDIO_ENCODING_LINEAR;
-            break;
-        case DevFmtUByte:
-            info.play.precision = 8;
-            info.play.encoding = AUDIO_ENCODING_LINEAR8;
-            break;
-        case DevFmtUShort:
-        case DevFmtInt:
-        case DevFmtUInt:
-        case DevFmtFloat:
-            mDevice->FmtType = DevFmtShort;
-            /* fall-through */
-        case DevFmtShort:
-            info.play.precision = 16;
-            info.play.encoding = AUDIO_ENCODING_LINEAR;
-            break;
+    case DevFmtByte:
+        info.play.precision = 8;
+        info.play.encoding = AUDIO_ENCODING_LINEAR;
+        break;
+    case DevFmtUByte:
+        info.play.precision = 8;
+        info.play.encoding = AUDIO_ENCODING_LINEAR8;
+        break;
+    case DevFmtUShort:
+    case DevFmtInt:
+    case DevFmtUInt:
+    case DevFmtFloat:
+        mDevice->FmtType = DevFmtShort;
+        /* fall-through */
+    case DevFmtShort:
+        info.play.precision = 16;
+        info.play.encoding = AUDIO_ENCODING_LINEAR;
+        break;
     }
-
-    ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
-    info.play.buffer_size = mDevice->BufferSize * frameSize;
+    info.play.buffer_size = mDevice->BufferSize * mDevice->frameSizeFromFmt();
 
     if(ioctl(mFd, AUDIO_SETINFO, &info) < 0)
     {
@@ -202,46 +198,54 @@ bool SolarisBackend::reset()
 
     if(mDevice->channelsFromFmt() != info.play.channels)
     {
-        ERR("Failed to set %s, got %u channels instead\n", DevFmtChannelsString(mDevice->FmtChans),
-            info.play.channels);
-        return false;
+        if(info.play.channels >= 2)
+            mDevice->FmtChans = DevFmtStereo;
+        else if(info.play.channels == 1)
+            mDevice->FmtChans = DevFmtMono;
+        else
+            throw al::backend_exception{al::backend_error::DeviceError,
+                "Got %u device channels", info.play.channels};
     }
 
-    if(!((info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR8 && mDevice->FmtType == DevFmtUByte) ||
-         (info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtByte) ||
-         (info.play.precision == 16 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtShort) ||
-         (info.play.precision == 32 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtInt)))
+    if(info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR8)
+        mDevice->FmtType = DevFmtUByte;
+    else if(info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR)
+        mDevice->FmtType = DevFmtByte;
+    else if(info.play.precision == 16 && info.play.encoding == AUDIO_ENCODING_LINEAR)
+        mDevice->FmtType = DevFmtShort;
+    else if(info.play.precision == 32 && info.play.encoding == AUDIO_ENCODING_LINEAR)
+        mDevice->FmtType = DevFmtInt;
+    else
     {
-        ERR("Could not set %s samples, got %d (0x%x)\n", DevFmtTypeString(mDevice->FmtType),
-            info.play.precision, info.play.encoding);
+        ERR("Got unhandled sample type: %d (0x%x)\n", info.play.precision, info.play.encoding);
         return false;
     }
 
+    uint frame_size{mDevice->bytesFromFmt() * info.play.channels};
+    mFrameStep = info.play.channels;
     mDevice->Frequency = info.play.sample_rate;
-    mDevice->BufferSize = info.play.buffer_size / frameSize;
+    mDevice->BufferSize = info.play.buffer_size / frame_size;
+    /* How to get the actual period size/count? */
     mDevice->UpdateSize = mDevice->BufferSize / 2;
 
-    SetDefaultChannelOrder(mDevice);
+    setDefaultChannelOrder();
 
-    mBuffer.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
-    std::fill(mBuffer.begin(), mBuffer.end(), 0);
+    mBuffer.resize(mDevice->UpdateSize * size_t{frame_size});
+    std::fill(mBuffer.begin(), mBuffer.end(), al::byte{});
 
     return true;
 }
 
-bool SolarisBackend::start()
+void SolarisBackend::start()
 {
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&SolarisBackend::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Could not create playback thread: %s\n", e.what());
-    }
-    catch(...) {
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    return false;
 }
 
 void SolarisBackend::stop()
@@ -272,26 +276,26 @@ bool SolarisBackendFactory::init()
 bool SolarisBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback; }
 
-void SolarisBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string SolarisBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-        {
-#ifdef HAVE_STAT
-            struct stat buf;
-            if(stat(solaris_driver.c_str(), &buf) == 0)
-#endif
-                outnames->append(solaris_device, sizeof(solaris_device));
-        }
-        break;
+    case BackendType::Playback:
+    {
+        struct stat buf;
+        if(stat(solaris_driver.c_str(), &buf) == 0)
+            outnames.append(solaris_device, sizeof(solaris_device));
+    }
+    break;
 
-        case DevProbe::Capture:
-            break;
+    case BackendType::Capture:
+        break;
     }
+    return outnames;
 }
 
-BackendPtr SolarisBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr SolarisBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new SolarisBackend{device}};
diff --git a/alc/backends/solaris.h b/alc/backends/solaris.h
index 98b10593..5da6ad3a 100644
--- a/alc/backends/solaris.h
+++ b/alc/backends/solaris.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_SOLARIS_H
 #define BACKENDS_SOLARIS_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct SolarisBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/wasapi.cpp b/alc/backends/wasapi.cpp
index 37a547af..e834eef4 100644
--- a/alc/backends/wasapi.cpp
+++ b/alc/backends/wasapi.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/wasapi.h"
+#include "wasapi.h"
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -43,23 +43,28 @@
 #include <ksmedia.h>
 #endif
 
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstring>
 #include <deque>
+#include <functional>
+#include <future>
 #include <mutex>
-#include <atomic>
+#include <string>
 #include <thread>
 #include <vector>
-#include <string>
-#include <future>
-#include <algorithm>
-#include <functional>
-#include <condition_variable>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
+#include "albit.h"
+#include "alc/alconfig.h"
+#include "alnumeric.h"
+#include "comptr.h"
+#include "core/converter.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "ringbuffer.h"
-#include "compat.h"
-#include "converter.h"
 #include "strutils.h"
 #include "threads.h"
 
@@ -82,8 +87,15 @@ DEFINE_PROPERTYKEY(PKEY_AudioEndpoint_GUID, 0x1da5d803, 0xd492, 0x4edd, 0x8c, 0x
 
 namespace {
 
-inline constexpr REFERENCE_TIME operator "" _reftime(unsigned long long int n) noexcept
-{ return static_cast<REFERENCE_TIME>(n); }
+using std::chrono::nanoseconds;
+using std::chrono::milliseconds;
+using std::chrono::seconds;
+
+using ReferenceTime = std::chrono::duration<REFERENCE_TIME,std::ratio<1,10000000>>;
+
+inline constexpr ReferenceTime operator "" _reftime(unsigned long long int n) noexcept
+{ return ReferenceTime{static_cast<REFERENCE_TIME>(n)}; }
+
 
 #define MONO SPEAKER_FRONT_CENTER
 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
@@ -92,20 +104,51 @@ inline constexpr REFERENCE_TIME operator "" _reftime(unsigned long long int n) n
 #define X5DOT1REAR (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
 #define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
-#define X7DOT1_WIDE (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_FRONT_LEFT_OF_CENTER|SPEAKER_FRONT_RIGHT_OF_CENTER)
+#define X7DOT1DOT4 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT|SPEAKER_TOP_FRONT_LEFT|SPEAKER_TOP_FRONT_RIGHT|SPEAKER_TOP_BACK_LEFT|SPEAKER_TOP_BACK_RIGHT)
 
-#define REFTIME_PER_SEC 10000000_reftime
+constexpr inline DWORD MaskFromTopBits(DWORD b) noexcept
+{
+    b |= b>>1;
+    b |= b>>2;
+    b |= b>>4;
+    b |= b>>8;
+    b |= b>>16;
+    return b;
+}
+constexpr DWORD MonoMask{MaskFromTopBits(MONO)};
+constexpr DWORD StereoMask{MaskFromTopBits(STEREO)};
+constexpr DWORD QuadMask{MaskFromTopBits(QUAD)};
+constexpr DWORD X51Mask{MaskFromTopBits(X5DOT1)};
+constexpr DWORD X51RearMask{MaskFromTopBits(X5DOT1REAR)};
+constexpr DWORD X61Mask{MaskFromTopBits(X6DOT1)};
+constexpr DWORD X71Mask{MaskFromTopBits(X7DOT1)};
+constexpr DWORD X714Mask{MaskFromTopBits(X7DOT1DOT4)};
 
-#define DEVNAME_HEAD "OpenAL Soft on "
+constexpr char DevNameHead[] = "OpenAL Soft on ";
+constexpr size_t DevNameHeadLen{al::size(DevNameHead) - 1};
 
 
-/* Scales the given value using 64-bit integer math, ceiling the result. */
-inline int64_t ScaleCeil(int64_t val, int64_t new_scale, int64_t old_scale)
+/* Scales the given reftime value, rounding the result. */
+inline uint RefTime2Samples(const ReferenceTime &val, uint srate)
 {
-    return (val*new_scale + old_scale-1) / old_scale;
+    const auto retval = (val*srate + ReferenceTime{seconds{1}}/2) / seconds{1};
+    return static_cast<uint>(mini64(retval, std::numeric_limits<uint>::max()));
 }
 
 
+class GuidPrinter {
+    char mMsg[64];
+
+public:
+    GuidPrinter(const GUID &guid)
+    {
+        std::snprintf(mMsg, al::size(mMsg), "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+            DWORD{guid.Data1}, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2],
+            guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
+    }
+    const char *c_str() const { return mMsg; }
+};
+
 struct PropVariant {
     PROPVARIANT mProp;
 
@@ -139,10 +182,9 @@ struct DevMap {
 
 bool checkName(const al::vector<DevMap> &list, const std::string &name)
 {
-    return std::find_if(list.cbegin(), list.cend(),
-        [&name](const DevMap &entry) -> bool
-        { return entry.name == name; }
-    ) != list.cend();
+    auto match_name = [&name](const DevMap &entry) -> bool
+    { return entry.name == name; };
+    return std::find_if(list.cbegin(), list.cend(), match_name) != list.cend();
 }
 
 al::vector<DevMap> PlaybackDevices;
@@ -152,15 +194,16 @@ al::vector<DevMap> CaptureDevices;
 using NameGUIDPair = std::pair<std::string,std::string>;
 NameGUIDPair get_device_name_and_guid(IMMDevice *device)
 {
-    std::string name{DEVNAME_HEAD};
-    std::string guid;
+    static constexpr char UnknownName[]{"Unknown Device Name"};
+    static constexpr char UnknownGuid[]{"Unknown Device GUID"};
+    std::string name, guid;
 
-    IPropertyStore *ps;
-    HRESULT hr = device->OpenPropertyStore(STGM_READ, &ps);
+    ComPtr<IPropertyStore> ps;
+    HRESULT hr = device->OpenPropertyStore(STGM_READ, ps.getPtr());
     if(FAILED(hr))
     {
         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
-        return { name+"Unknown Device Name", "Unknown Device GUID" };
+        return std::make_pair(UnknownName, UnknownGuid);
     }
 
     PropVariant pvprop;
@@ -168,14 +211,14 @@ NameGUIDPair get_device_name_and_guid(IMMDevice *device)
     if(FAILED(hr))
     {
         WARN("GetValue Device_FriendlyName failed: 0x%08lx\n", hr);
-        name += "Unknown Device Name";
+        name += UnknownName;
     }
     else if(pvprop->vt == VT_LPWSTR)
         name += wstr_to_utf8(pvprop->pwszVal);
     else
     {
         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvprop->vt);
-        name += "Unknown Device Name";
+        name += UnknownName;
     }
 
     pvprop.clear();
@@ -183,60 +226,61 @@ NameGUIDPair get_device_name_and_guid(IMMDevice *device)
     if(FAILED(hr))
     {
         WARN("GetValue AudioEndpoint_GUID failed: 0x%08lx\n", hr);
-        guid = "Unknown Device GUID";
+        guid = UnknownGuid;
     }
     else if(pvprop->vt == VT_LPWSTR)
         guid = wstr_to_utf8(pvprop->pwszVal);
     else
     {
         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvprop->vt);
-        guid = "Unknown Device GUID";
+        guid = UnknownGuid;
     }
 
-    ps->Release();
-
-    return {name, guid};
+    return std::make_pair(std::move(name), std::move(guid));
 }
 
-void get_device_formfactor(IMMDevice *device, EndpointFormFactor *formfactor)
+EndpointFormFactor get_device_formfactor(IMMDevice *device)
 {
-    IPropertyStore *ps;
-    HRESULT hr = device->OpenPropertyStore(STGM_READ, &ps);
+    ComPtr<IPropertyStore> ps;
+    HRESULT hr{device->OpenPropertyStore(STGM_READ, ps.getPtr())};
     if(FAILED(hr))
     {
         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
-        return;
+        return UnknownFormFactor;
     }
 
+    EndpointFormFactor formfactor{UnknownFormFactor};
     PropVariant pvform;
-    hr = ps->GetValue(reinterpret_cast<const PROPERTYKEY&>(PKEY_AudioEndpoint_FormFactor), pvform.get());
+    hr = ps->GetValue(PKEY_AudioEndpoint_FormFactor, pvform.get());
     if(FAILED(hr))
         WARN("GetValue AudioEndpoint_FormFactor failed: 0x%08lx\n", hr);
     else if(pvform->vt == VT_UI4)
-        *formfactor = static_cast<EndpointFormFactor>(pvform->ulVal);
-    else if(pvform->vt == VT_EMPTY)
-        *formfactor = UnknownFormFactor;
-    else
+        formfactor = static_cast<EndpointFormFactor>(pvform->ulVal);
+    else if(pvform->vt != VT_EMPTY)
         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvform->vt);
-
-    ps->Release();
+    return formfactor;
 }
 
 
 void add_device(IMMDevice *device, const WCHAR *devid, al::vector<DevMap> &list)
 {
-    std::string basename, guidstr;
-    std::tie(basename, guidstr) = get_device_name_and_guid(device);
+    for(auto &entry : list)
+    {
+        if(entry.devid == devid)
+            return;
+    }
+
+    auto name_guid = get_device_name_and_guid(device);
 
     int count{1};
-    std::string newname{basename};
+    std::string newname{name_guid.first};
     while(checkName(list, newname))
     {
-        newname = basename;
+        newname = name_guid.first;
         newname += " #";
         newname += std::to_string(++count);
     }
-    list.emplace_back(std::move(newname), std::move(guidstr), devid);
+    list.emplace_back(std::move(newname), std::move(name_guid.second), devid);
     const DevMap &newentry = list.back();
 
     TRACE("Got device \"%s\", \"%s\", \"%ls\"\n", newentry.name.c_str(),
@@ -247,7 +291,7 @@ WCHAR *get_device_id(IMMDevice *device)
 {
     WCHAR *devid;
 
-    HRESULT hr = device->GetId(&devid);
+    const HRESULT hr{device->GetId(&devid)};
     if(FAILED(hr))
     {
         ERR("Failed to get device id: %lx\n", hr);
@@ -257,55 +301,47 @@ WCHAR *get_device_id(IMMDevice *device)
     return devid;
 }
 
-HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, al::vector<DevMap> &list)
+void probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, al::vector<DevMap> &list)
 {
-    IMMDeviceCollection *coll;
-    HRESULT hr{devenum->EnumAudioEndpoints(flowdir, DEVICE_STATE_ACTIVE, &coll)};
+    al::vector<DevMap>{}.swap(list);
+
+    ComPtr<IMMDeviceCollection> coll;
+    HRESULT hr{devenum->EnumAudioEndpoints(flowdir, DEVICE_STATE_ACTIVE, coll.getPtr())};
     if(FAILED(hr))
     {
         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
-        return hr;
+        return;
     }
 
-    IMMDevice *defdev{nullptr};
-    WCHAR *defdevid{nullptr};
     UINT count{0};
     hr = coll->GetCount(&count);
     if(SUCCEEDED(hr) && count > 0)
-    {
-        list.clear();
         list.reserve(count);
 
-        hr = devenum->GetDefaultAudioEndpoint(flowdir, eMultimedia, &defdev);
-    }
-    if(SUCCEEDED(hr) && defdev != nullptr)
+    ComPtr<IMMDevice> device;
+    hr = devenum->GetDefaultAudioEndpoint(flowdir, eMultimedia, device.getPtr());
+    if(SUCCEEDED(hr))
     {
-        defdevid = get_device_id(defdev);
-        if(defdevid)
-            add_device(defdev, defdevid, list);
+        if(WCHAR *devid{get_device_id(device.get())})
+        {
+            add_device(device.get(), devid, list);
+            CoTaskMemFree(devid);
+        }
+        device = nullptr;
     }
 
     for(UINT i{0};i < count;++i)
     {
-        IMMDevice *device;
-        hr = coll->Item(i, &device);
+        hr = coll->Item(i, device.getPtr());
         if(FAILED(hr)) continue;
 
-        WCHAR *devid{get_device_id(device)};
-        if(devid)
+        if(WCHAR *devid{get_device_id(device.get())})
         {
-            if(!defdevid || wcscmp(devid, defdevid) != 0)
-                add_device(device, devid, list);
+            add_device(device.get(), devid, list);
             CoTaskMemFree(devid);
         }
-        device->Release();
+        device = nullptr;
     }
-
-    if(defdev) defdev->Release();
-    if(defdevid) CoTaskMemFree(defdevid);
-    coll->Release();
-
-    return S_OK;
 }
 
 
@@ -356,21 +392,6 @@ void TraceFormat(const char *msg, const WAVEFORMATEX *format)
     constexpr size_t fmtex_extra_size{sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX)};
     if(format->wFormatTag == WAVE_FORMAT_EXTENSIBLE && format->cbSize >= fmtex_extra_size)
     {
-        class GuidPrinter {
-            char mMsg[64];
-
-        public:
-            GuidPrinter(const GUID &guid)
-            {
-                std::snprintf(mMsg, al::size(mMsg),
-                    "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
-                    DWORD{guid.Data1}, guid.Data2, guid.Data3,
-                    guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
-                    guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
-            }
-            const char *c_str() const { return mMsg; }
-        };
-
         const WAVEFORMATEXTENSIBLE *fmtex{
             CONTAINING_RECORD(format, const WAVEFORMATEXTENSIBLE, Format)};
         TRACE("%s:\n"
@@ -411,9 +432,9 @@ enum class MsgType {
     CloseDevice,
     EnumeratePlayback,
     EnumerateCapture,
-    QuitThread,
 
-    Count
+    Count,
+    QuitThread = Count
 };
 
 constexpr char MessageStr[static_cast<size_t>(MsgType::Count)][20]{
@@ -423,8 +444,7 @@ constexpr char MessageStr[static_cast<size_t>(MsgType::Count)][20]{
     "Stop Device",
     "Close Device",
     "Enumerate Playback",
-    "Enumerate Capture",
-    "Quit"
+    "Enumerate Capture"
 };
 
 
@@ -432,7 +452,7 @@ constexpr char MessageStr[static_cast<size_t>(MsgType::Count)][20]{
 struct WasapiProxy {
     virtual ~WasapiProxy() = default;
 
-    virtual HRESULT openProxy() = 0;
+    virtual HRESULT openProxy(const char *name) = 0;
     virtual void closeProxy() = 0;
 
     virtual HRESULT resetProxy() = 0;
@@ -442,18 +462,25 @@ struct WasapiProxy {
     struct Msg {
         MsgType mType;
         WasapiProxy *mProxy;
+        const char *mParam;
         std::promise<HRESULT> mPromise;
+
+        explicit operator bool() const noexcept { return mType != MsgType::QuitThread; }
     };
+    static std::thread sThread;
     static std::deque<Msg> mMsgQueue;
     static std::mutex mMsgQueueLock;
     static std::condition_variable mMsgQueueCond;
+    static std::mutex sThreadLock;
+    static size_t sInitCount;
 
-    std::future<HRESULT> pushMessage(MsgType type)
+    std::future<HRESULT> pushMessage(MsgType type, const char *param=nullptr)
     {
         std::promise<HRESULT> promise;
         std::future<HRESULT> future{promise.get_future()};
-        { std::lock_guard<std::mutex> _{mMsgQueueLock};
-            mMsgQueue.emplace_back(Msg{type, this, std::move(promise)});
+        {
+            std::lock_guard<std::mutex> _{mMsgQueueLock};
+            mMsgQueue.emplace_back(Msg{type, this, param, std::move(promise)});
         }
         mMsgQueueCond.notify_one();
         return future;
@@ -463,84 +490,89 @@ struct WasapiProxy {
     {
         std::promise<HRESULT> promise;
         std::future<HRESULT> future{promise.get_future()};
-        { std::lock_guard<std::mutex> _{mMsgQueueLock};
-            mMsgQueue.emplace_back(Msg{type, nullptr, std::move(promise)});
+        {
+            std::lock_guard<std::mutex> _{mMsgQueueLock};
+            mMsgQueue.emplace_back(Msg{type, nullptr, nullptr, std::move(promise)});
         }
         mMsgQueueCond.notify_one();
         return future;
     }
 
-    static bool popMessage(Msg &msg)
+    static Msg popMessage()
     {
         std::unique_lock<std::mutex> lock{mMsgQueueLock};
-        while(mMsgQueue.empty())
-            mMsgQueueCond.wait(lock);
-        msg = std::move(mMsgQueue.front());
+        mMsgQueueCond.wait(lock, []{return !mMsgQueue.empty();});
+        Msg msg{std::move(mMsgQueue.front())};
         mMsgQueue.pop_front();
-        return msg.mType != MsgType::QuitThread;
+        return msg;
     }
 
     static int messageHandler(std::promise<HRESULT> *promise);
+
+    static HRESULT InitThread()
+    {
+        std::lock_guard<std::mutex> _{sThreadLock};
+        HRESULT res{S_OK};
+        if(!sThread.joinable())
+        {
+            std::promise<HRESULT> promise;
+            auto future = promise.get_future();
+
+            sThread = std::thread{&WasapiProxy::messageHandler, &promise};
+            res = future.get();
+            if(FAILED(res))
+            {
+                sThread.join();
+                return res;
+            }
+        }
+        ++sInitCount;
+        return res;
+    }
+
+    static void DeinitThread()
+    {
+        std::lock_guard<std::mutex> _{sThreadLock};
+        if(!--sInitCount && sThread.joinable())
+        {
+            pushMessageStatic(MsgType::QuitThread);
+            sThread.join();
+        }
+    }
 };
+std::thread WasapiProxy::sThread;
 std::deque<WasapiProxy::Msg> WasapiProxy::mMsgQueue;
 std::mutex WasapiProxy::mMsgQueueLock;
 std::condition_variable WasapiProxy::mMsgQueueCond;
+std::mutex WasapiProxy::sThreadLock;
+size_t WasapiProxy::sInitCount{0};
 
 int WasapiProxy::messageHandler(std::promise<HRESULT> *promise)
 {
     TRACE("Starting message thread\n");
 
-    HRESULT cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-    if(FAILED(cohr))
-    {
-        WARN("Failed to initialize COM: 0x%08lx\n", cohr);
-        promise->set_value(cohr);
-        return 0;
-    }
-
-    void *ptr{};
-    HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
-        IID_IMMDeviceEnumerator, &ptr)};
+    HRESULT hr{CoInitializeEx(nullptr, COINIT_MULTITHREADED)};
     if(FAILED(hr))
     {
-        WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
+        WARN("Failed to initialize COM: 0x%08lx\n", hr);
         promise->set_value(hr);
-        CoUninitialize();
         return 0;
     }
-    auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
-    Enumerator->Release();
-    Enumerator = nullptr;
-    CoUninitialize();
-
-    TRACE("Message thread initialization complete\n");
     promise->set_value(S_OK);
     promise = nullptr;
 
     TRACE("Starting message loop\n");
-    ALuint deviceCount{0};
-    Msg msg;
-    while(popMessage(msg))
+    while(Msg msg{popMessage()})
     {
-        TRACE("Got message \"%s\" (0x%04x, this=%p)\n",
-            MessageStr[static_cast<size_t>(msg.mType)], static_cast<int>(msg.mType),
-            decltype(std::declval<void*>()){msg.mProxy});
+        TRACE("Got message \"%s\" (0x%04x, this=%p, param=%p)\n",
+            MessageStr[static_cast<size_t>(msg.mType)], static_cast<uint>(msg.mType),
+            static_cast<void*>(msg.mProxy), static_cast<const void*>(msg.mParam));
 
         switch(msg.mType)
         {
         case MsgType::OpenDevice:
-            hr = cohr = S_OK;
-            if(++deviceCount == 1)
-                hr = cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-            if(SUCCEEDED(hr))
-                hr = msg.mProxy->openProxy();
+            hr = msg.mProxy->openProxy(msg.mParam);
             msg.mPromise.set_value(hr);
-
-            if(FAILED(hr))
-            {
-                if(--deviceCount == 0 && SUCCEEDED(cohr))
-                    CoUninitialize();
-            }
             continue;
 
         case MsgType::ResetDevice:
@@ -561,78 +593,77 @@ int WasapiProxy::messageHandler(std::promise<HRESULT> *promise)
         case MsgType::CloseDevice:
             msg.mProxy->closeProxy();
             msg.mPromise.set_value(S_OK);
-
-            if(--deviceCount == 0)
-                CoUninitialize();
             continue;
 
         case MsgType::EnumeratePlayback:
         case MsgType::EnumerateCapture:
-            hr = cohr = S_OK;
-            if(++deviceCount == 1)
-                hr = cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-            if(SUCCEEDED(hr))
-                hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, &ptr);
-            if(FAILED(hr))
-                msg.mPromise.set_value(hr);
-            else
             {
-                Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
-
-                if(msg.mType == MsgType::EnumeratePlayback)
-                    hr = probe_devices(Enumerator, eRender, PlaybackDevices);
-                else if(msg.mType == MsgType::EnumerateCapture)
-                    hr = probe_devices(Enumerator, eCapture, CaptureDevices);
-                msg.mPromise.set_value(hr);
+                void *ptr{};
+                hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
+                    IID_IMMDeviceEnumerator, &ptr);
+                if(FAILED(hr))
+                    msg.mPromise.set_value(hr);
+                else
+                {
+                    ComPtr<IMMDeviceEnumerator> devenum{static_cast<IMMDeviceEnumerator*>(ptr)};
 
-                Enumerator->Release();
-                Enumerator = nullptr;
+                    if(msg.mType == MsgType::EnumeratePlayback)
+                        probe_devices(devenum.get(), eRender, PlaybackDevices);
+                    else if(msg.mType == MsgType::EnumerateCapture)
+                        probe_devices(devenum.get(), eCapture, CaptureDevices);
+                    msg.mPromise.set_value(S_OK);
+                }
+                continue;
             }
 
-            if(--deviceCount == 0 && SUCCEEDED(cohr))
-                CoUninitialize();
-            continue;
-
-        default:
-            ERR("Unexpected message: %u\n", static_cast<unsigned int>(msg.mType));
-            msg.mPromise.set_value(E_FAIL);
-            continue;
+        case MsgType::QuitThread:
+            break;
         }
+        ERR("Unexpected message: %u\n", static_cast<uint>(msg.mType));
+        msg.mPromise.set_value(E_FAIL);
     }
     TRACE("Message loop finished\n");
+    CoUninitialize();
 
     return 0;
 }
 
 
 struct WasapiPlayback final : public BackendBase, WasapiProxy {
-    WasapiPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    WasapiPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~WasapiPlayback() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
-    HRESULT openProxy() override;
+    void open(const char *name) override;
+    HRESULT openProxy(const char *name) override;
     void closeProxy() override;
 
     bool reset() override;
     HRESULT resetProxy() override;
-    bool start() override;
+    void start() override;
     HRESULT startProxy() override;
     void stop() override;
     void stopProxy() override;
 
     ClockLatency getClockLatency() override;
 
-    std::wstring mDevId;
-
-    IMMDevice *mMMDev{nullptr};
-    IAudioClient *mClient{nullptr};
-    IAudioRenderClient *mRender{nullptr};
+    HRESULT mOpenStatus{E_FAIL};
+    ComPtr<IMMDevice> mMMDev{nullptr};
+    ComPtr<IAudioClient> mClient{nullptr};
+    ComPtr<IAudioRenderClient> mRender{nullptr};
     HANDLE mNotifyEvent{nullptr};
 
+    UINT32 mOrigBufferSize{}, mOrigUpdateSize{};
+    std::unique_ptr<char[]> mResampleBuffer{};
+    uint mBufferFilled{0};
+    SampleConverterPtr mResampler;
+
+    WAVEFORMATEXTENSIBLE mFormat{};
     std::atomic<UINT32> mPadding{0u};
 
+    std::mutex mMutex;
+
     std::atomic<bool> mKillNow{true};
     std::thread mThread;
 
@@ -641,7 +672,12 @@ struct WasapiPlayback final : public BackendBase, WasapiProxy {
 
 WasapiPlayback::~WasapiPlayback()
 {
-    pushMessage(MsgType::CloseDevice).wait();
+    if(SUCCEEDED(mOpenStatus))
+    {
+        pushMessage(MsgType::CloseDevice).wait();
+        DeinitThread();
+    }
+    mOpenStatus = E_FAIL;
 
     if(mNotifyEvent != nullptr)
         CloseHandle(mNotifyEvent);
@@ -651,19 +687,20 @@ WasapiPlayback::~WasapiPlayback()
 
 FORCE_ALIGN int WasapiPlayback::mixerProc()
 {
-    HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    HRESULT hr{CoInitializeEx(nullptr, COINIT_MULTITHREADED)};
     if(FAILED(hr))
     {
         ERR("CoInitializeEx(nullptr, COINIT_MULTITHREADED) failed: 0x%08lx\n", hr);
-        aluHandleDisconnect(mDevice, "COM init failed: 0x%08lx", hr);
+        mDevice->handleDisconnect("COM init failed: 0x%08lx", hr);
         return 1;
     }
 
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    const ALuint update_size{mDevice->UpdateSize};
-    const UINT32 buffer_len{mDevice->BufferSize};
+    const uint frame_size{mFormat.Format.nChannels * mFormat.Format.wBitsPerSample / 8u};
+    const uint update_size{mOrigUpdateSize};
+    const UINT32 buffer_len{mOrigBufferSize};
     while(!mKillNow.load(std::memory_order_relaxed))
     {
         UINT32 written;
@@ -671,12 +708,12 @@ FORCE_ALIGN int WasapiPlayback::mixerProc()
         if(FAILED(hr))
         {
             ERR("Failed to get padding: 0x%08lx\n", hr);
-            aluHandleDisconnect(mDevice, "Failed to retrieve buffer padding: 0x%08lx", hr);
+            mDevice->handleDisconnect("Failed to retrieve buffer padding: 0x%08lx", hr);
             break;
         }
         mPadding.store(written, std::memory_order_relaxed);
 
-        ALuint len{buffer_len - written};
+        uint len{buffer_len - written};
         if(len < update_size)
         {
             DWORD res{WaitForSingleObjectEx(mNotifyEvent, 2000, FALSE)};
@@ -689,16 +726,45 @@ FORCE_ALIGN int WasapiPlayback::mixerProc()
         hr = mRender->GetBuffer(len, &buffer);
         if(SUCCEEDED(hr))
         {
-            std::unique_lock<WasapiPlayback> dlock{*this};
-            aluMixData(mDevice, buffer, len);
-            mPadding.store(written + len, std::memory_order_relaxed);
-            dlock.unlock();
+            if(mResampler)
+            {
+                std::lock_guard<std::mutex> _{mMutex};
+                for(UINT32 done{0};done < len;)
+                {
+                    if(mBufferFilled == 0)
+                    {
+                        mDevice->renderSamples(mResampleBuffer.get(), mDevice->UpdateSize,
+                            mFormat.Format.nChannels);
+                        mBufferFilled = mDevice->UpdateSize;
+                    }
+
+                    const void *src{mResampleBuffer.get()};
+                    uint srclen{mBufferFilled};
+                    uint got{mResampler->convert(&src, &srclen, buffer, len-done)};
+                    buffer += got*frame_size;
+                    done += got;
+
+                    mPadding.store(written + done, std::memory_order_relaxed);
+                    if(srclen)
+                    {
+                        const char *bsrc{static_cast<const char*>(src)};
+                        std::copy(bsrc, bsrc + srclen*frame_size, mResampleBuffer.get());
+                    }
+                    mBufferFilled = srclen;
+                }
+            }
+            else
+            {
+                std::lock_guard<std::mutex> _{mMutex};
+                mDevice->renderSamples(buffer, len, mFormat.Format.nChannels);
+                mPadding.store(written + len, std::memory_order_relaxed);
+            }
             hr = mRender->ReleaseBuffer(len, 0);
         }
         if(FAILED(hr))
         {
             ERR("Failed to buffer data: 0x%08lx\n", hr);
-            aluHandleDisconnect(mDevice, "Failed to send playback samples: 0x%08lx", hr);
+            mDevice->handleDisconnect("Failed to send playback samples: 0x%08lx", hr);
             break;
         }
     }
@@ -709,103 +775,101 @@ FORCE_ALIGN int WasapiPlayback::mixerProc()
 }
 
 
-void WasapiPlayback::open(const ALCchar *name)
+void WasapiPlayback::open(const char *name)
 {
-    HRESULT hr{S_OK};
+    if(SUCCEEDED(mOpenStatus))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Unexpected duplicate open call"};
 
     mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
     if(mNotifyEvent == nullptr)
     {
         ERR("Failed to create notify events: %lu\n", GetLastError());
-        hr = E_FAIL;
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to create notify events"};
     }
 
-    if(SUCCEEDED(hr))
+    HRESULT hr{InitThread()};
+    if(FAILED(hr))
     {
-        if(name)
-        {
-            if(PlaybackDevices.empty())
-                pushMessage(MsgType::EnumeratePlayback).wait();
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to init COM thread: 0x%08lx", hr};
+    }
 
-            hr = E_FAIL;
-            auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-                [name](const DevMap &entry) -> bool
-                { return entry.name == name || entry.endpoint_guid == name; }
-            );
-            if(iter == PlaybackDevices.cend())
-            {
-                std::wstring wname{utf8_to_wstr(name)};
-                iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
-                    [&wname](const DevMap &entry) -> bool
-                    { return entry.devid == wname; }
-                );
-            }
-            if(iter == PlaybackDevices.cend())
-                WARN("Failed to find device name matching \"%s\"\n", name);
-            else
-            {
-                mDevId = iter->devid;
-                mDevice->DeviceName = iter->name;
-                hr = S_OK;
-            }
+    if(name)
+    {
+        if(PlaybackDevices.empty())
+            pushMessage(MsgType::EnumeratePlayback);
+        if(std::strncmp(name, DevNameHead, DevNameHeadLen) == 0)
+        {
+            name += DevNameHeadLen;
+            if(*name == '\0')
+                name = nullptr;
         }
     }
 
-    if(SUCCEEDED(hr))
-        hr = pushMessage(MsgType::OpenDevice).get();
-
-    if(FAILED(hr))
+    mOpenStatus = pushMessage(MsgType::OpenDevice, name).get();
+    if(FAILED(mOpenStatus))
     {
-        if(mNotifyEvent != nullptr)
-            CloseHandle(mNotifyEvent);
-        mNotifyEvent = nullptr;
-
-        mDevId.clear();
-
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
+        DeinitThread();
+        throw al::backend_exception{al::backend_error::DeviceError, "Device init failed: 0x%08lx",
+            mOpenStatus};
     }
 }
 
-HRESULT WasapiPlayback::openProxy()
+HRESULT WasapiPlayback::openProxy(const char *name)
 {
-    void *ptr;
-    HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, &ptr)};
-    if(SUCCEEDED(hr))
+    const wchar_t *devid{nullptr};
+    if(name)
     {
-        auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
-        if(mDevId.empty())
-            hr = Enumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, &mMMDev);
-        else
-            hr = Enumerator->GetDevice(mDevId.c_str(), &mMMDev);
-        Enumerator->Release();
+        auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
+            [name](const DevMap &entry) -> bool
+            { return entry.name == name || entry.endpoint_guid == name; });
+        if(iter == PlaybackDevices.cend())
+        {
+            const std::wstring wname{utf8_to_wstr(name)};
+            iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
+                [&wname](const DevMap &entry) -> bool
+                { return entry.devid == wname; });
+        }
+        if(iter == PlaybackDevices.cend())
+        {
+            WARN("Failed to find device name matching \"%s\"\n", name);
+            return E_FAIL;
+        }
+        name = iter->name.c_str();
+        devid = iter->devid.c_str();
     }
-    if(SUCCEEDED(hr))
-        hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
+
+    void *ptr;
+    ComPtr<IMMDevice> mmdev;
+    HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
+        IID_IMMDeviceEnumerator, &ptr)};
     if(SUCCEEDED(hr))
     {
-        mClient = static_cast<IAudioClient*>(ptr);
-        if(mDevice->DeviceName.empty())
-            mDevice->DeviceName = get_device_name_and_guid(mMMDev).first;
+        ComPtr<IMMDeviceEnumerator> enumerator{static_cast<IMMDeviceEnumerator*>(ptr)};
+        if(!devid)
+            hr = enumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, mmdev.getPtr());
+        else
+            hr = enumerator->GetDevice(devid, mmdev.getPtr());
     }
-
     if(FAILED(hr))
     {
-        if(mMMDev)
-            mMMDev->Release();
-        mMMDev = nullptr;
+        WARN("Failed to open device \"%s\"\n", name?name:"(default)");
+        return hr;
     }
 
+    mClient = nullptr;
+    mMMDev = std::move(mmdev);
+    if(name) mDevice->DeviceName = std::string{DevNameHead} + name;
+    else mDevice->DeviceName = DevNameHead + get_device_name_and_guid(mMMDev.get()).first;
+
     return hr;
 }
 
 void WasapiPlayback::closeProxy()
 {
-    if(mClient)
-        mClient->Release();
     mClient = nullptr;
-
-    if(mMMDev)
-        mMMDev->Release();
     mMMDev = nullptr;
 }
 
@@ -814,24 +878,22 @@ bool WasapiPlayback::reset()
 {
     HRESULT hr{pushMessage(MsgType::ResetDevice).get()};
     if(FAILED(hr))
-        throw al::backend_exception{ALC_INVALID_VALUE, "0x%08lx", hr};
+        throw al::backend_exception{al::backend_error::DeviceError, "0x%08lx", hr};
     return true;
 }
 
 HRESULT WasapiPlayback::resetProxy()
 {
-    if(mClient)
-        mClient->Release();
     mClient = nullptr;
 
     void *ptr;
-    HRESULT hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
+    HRESULT hr{mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr)};
     if(FAILED(hr))
     {
         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
         return hr;
     }
-    mClient = static_cast<IAudioClient*>(ptr);
+    mClient = ComPtr<IAudioClient>{static_cast<IAudioClient*>(ptr)};
 
     WAVEFORMATEX *wfx;
     hr = mClient->GetMixFormat(&wfx);
@@ -840,6 +902,7 @@ HRESULT WasapiPlayback::resetProxy()
         ERR("Failed to get mix format: 0x%08lx\n", hr);
         return hr;
     }
+    TraceFormat("Device mix format", wfx);
 
     WAVEFORMATEXTENSIBLE OutputType;
     if(!MakeExtensible(&OutputType, wfx))
@@ -850,97 +913,116 @@ HRESULT WasapiPlayback::resetProxy()
     CoTaskMemFree(wfx);
     wfx = nullptr;
 
-    const REFERENCE_TIME per_time{mDevice->UpdateSize * REFTIME_PER_SEC / mDevice->Frequency};
-    const REFERENCE_TIME buf_time{mDevice->BufferSize * REFTIME_PER_SEC / mDevice->Frequency};
+    const ReferenceTime per_time{ReferenceTime{seconds{mDevice->UpdateSize}} / mDevice->Frequency};
+    const ReferenceTime buf_time{ReferenceTime{seconds{mDevice->BufferSize}} / mDevice->Frequency};
+    bool isRear51{false};
 
-    if(!mDevice->Flags.get<FrequencyRequest>())
+    if(!mDevice->Flags.test(FrequencyRequest))
         mDevice->Frequency = OutputType.Format.nSamplesPerSec;
-    if(!mDevice->Flags.get<ChannelsRequest>())
+    if(!mDevice->Flags.test(ChannelsRequest))
     {
-        if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
-            mDevice->FmtChans = DevFmtMono;
-        else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
-            mDevice->FmtChans = DevFmtStereo;
-        else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
-            mDevice->FmtChans = DevFmtQuad;
-        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
-            mDevice->FmtChans = DevFmtX51;
-        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
-            mDevice->FmtChans = DevFmtX51Rear;
-        else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
-            mDevice->FmtChans = DevFmtX61;
-        else if(OutputType.Format.nChannels == 8 && (OutputType.dwChannelMask == X7DOT1 || OutputType.dwChannelMask == X7DOT1_WIDE))
+        /* If not requesting a channel configuration, auto-select given what
+         * fits the mask's lsb (to ensure no gaps in the output channels). If
+         * there's no mask, we can only assume mono or stereo.
+         */
+        const uint32_t chancount{OutputType.Format.nChannels};
+        const DWORD chanmask{OutputType.dwChannelMask};
+        if(chancount >= 12 && (chanmask&X714Mask) == X7DOT1DOT4)
             mDevice->FmtChans = DevFmtX71;
+        else if(chancount >= 8 && (chanmask&X71Mask) == X7DOT1)
+            mDevice->FmtChans = DevFmtX71;
+        else if(chancount >= 7 && (chanmask&X61Mask) == X6DOT1)
+            mDevice->FmtChans = DevFmtX61;
+        else if(chancount >= 6 && (chanmask&X51Mask) == X5DOT1)
+            mDevice->FmtChans = DevFmtX51;
+        else if(chancount >= 6 && (chanmask&X51RearMask) == X5DOT1REAR)
+        {
+            mDevice->FmtChans = DevFmtX51;
+            isRear51 = true;
+        }
+        else if(chancount >= 4 && (chanmask&QuadMask) == QUAD)
+            mDevice->FmtChans = DevFmtQuad;
+        else if(chancount >= 2 && ((chanmask&StereoMask) == STEREO || !chanmask))
+            mDevice->FmtChans = DevFmtStereo;
+        else if(chancount >= 1 && ((chanmask&MonoMask) == MONO || !chanmask))
+            mDevice->FmtChans = DevFmtMono;
         else
-            ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
+            ERR("Unhandled channel config: %d -- 0x%08lx\n", chancount, chanmask);
+    }
+    else
+    {
+        const uint32_t chancount{OutputType.Format.nChannels};
+        const DWORD chanmask{OutputType.dwChannelMask};
+        isRear51 = (chancount == 6 && (chanmask&X51RearMask) == X5DOT1REAR);
     }
 
     OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
     switch(mDevice->FmtChans)
     {
-        case DevFmtMono:
-            OutputType.Format.nChannels = 1;
-            OutputType.dwChannelMask = MONO;
-            break;
-        case DevFmtAmbi3D:
-            mDevice->FmtChans = DevFmtStereo;
-            /*fall-through*/
-        case DevFmtStereo:
-            OutputType.Format.nChannels = 2;
-            OutputType.dwChannelMask = STEREO;
-            break;
-        case DevFmtQuad:
-            OutputType.Format.nChannels = 4;
-            OutputType.dwChannelMask = QUAD;
-            break;
-        case DevFmtX51:
-            OutputType.Format.nChannels = 6;
-            OutputType.dwChannelMask = X5DOT1;
-            break;
-        case DevFmtX51Rear:
-            OutputType.Format.nChannels = 6;
-            OutputType.dwChannelMask = X5DOT1REAR;
-            break;
-        case DevFmtX61:
-            OutputType.Format.nChannels = 7;
-            OutputType.dwChannelMask = X6DOT1;
-            break;
-        case DevFmtX71:
-            OutputType.Format.nChannels = 8;
-            OutputType.dwChannelMask = X7DOT1;
-            break;
+    case DevFmtMono:
+        OutputType.Format.nChannels = 1;
+        OutputType.dwChannelMask = MONO;
+        break;
+    case DevFmtAmbi3D:
+        mDevice->FmtChans = DevFmtStereo;
+        /*fall-through*/
+    case DevFmtStereo:
+        OutputType.Format.nChannels = 2;
+        OutputType.dwChannelMask = STEREO;
+        break;
+    case DevFmtQuad:
+        OutputType.Format.nChannels = 4;
+        OutputType.dwChannelMask = QUAD;
+        break;
+    case DevFmtX51:
+        OutputType.Format.nChannels = 6;
+        OutputType.dwChannelMask = isRear51 ? X5DOT1REAR : X5DOT1;
+        break;
+    case DevFmtX61:
+        OutputType.Format.nChannels = 7;
+        OutputType.dwChannelMask = X6DOT1;
+        break;
+    case DevFmtX71:
+    case DevFmtX3D71:
+        OutputType.Format.nChannels = 8;
+        OutputType.dwChannelMask = X7DOT1;
+        break;
+    case DevFmtX714:
+        OutputType.Format.nChannels = 12;
+        OutputType.dwChannelMask = X7DOT1DOT4;
+        break;
     }
     switch(mDevice->FmtType)
     {
-        case DevFmtByte:
-            mDevice->FmtType = DevFmtUByte;
-            /* fall-through */
-        case DevFmtUByte:
-            OutputType.Format.wBitsPerSample = 8;
-            OutputType.Samples.wValidBitsPerSample = 8;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtUShort:
-            mDevice->FmtType = DevFmtShort;
-            /* fall-through */
-        case DevFmtShort:
-            OutputType.Format.wBitsPerSample = 16;
-            OutputType.Samples.wValidBitsPerSample = 16;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtUInt:
-            mDevice->FmtType = DevFmtInt;
-            /* fall-through */
-        case DevFmtInt:
-            OutputType.Format.wBitsPerSample = 32;
-            OutputType.Samples.wValidBitsPerSample = 32;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtFloat:
-            OutputType.Format.wBitsPerSample = 32;
-            OutputType.Samples.wValidBitsPerSample = 32;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
-            break;
+    case DevFmtByte:
+        mDevice->FmtType = DevFmtUByte;
+        /* fall-through */
+    case DevFmtUByte:
+        OutputType.Format.wBitsPerSample = 8;
+        OutputType.Samples.wValidBitsPerSample = 8;
+        OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtUShort:
+        mDevice->FmtType = DevFmtShort;
+        /* fall-through */
+    case DevFmtShort:
+        OutputType.Format.wBitsPerSample = 16;
+        OutputType.Samples.wValidBitsPerSample = 16;
+        OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtUInt:
+        mDevice->FmtType = DevFmtInt;
+        /* fall-through */
+    case DevFmtInt:
+        OutputType.Format.wBitsPerSample = 32;
+        OutputType.Samples.wValidBitsPerSample = 32;
+        OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtFloat:
+        OutputType.Format.wBitsPerSample = 32;
+        OutputType.Samples.wValidBitsPerSample = 32;
+        OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+        break;
     }
     OutputType.Format.nSamplesPerSec = mDevice->Frequency;
 
@@ -953,7 +1035,7 @@ HRESULT WasapiPlayback::resetProxy()
     hr = mClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
     if(FAILED(hr))
     {
-        ERR("Failed to check format support: 0x%08lx\n", hr);
+        WARN("Failed to check format support: 0x%08lx\n", hr);
         hr = mClient->GetMixFormat(&wfx);
     }
     if(FAILED(hr))
@@ -973,27 +1055,76 @@ HRESULT WasapiPlayback::resetProxy()
         CoTaskMemFree(wfx);
         wfx = nullptr;
 
-        mDevice->Frequency = OutputType.Format.nSamplesPerSec;
-        if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
-            mDevice->FmtChans = DevFmtMono;
-        else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
-            mDevice->FmtChans = DevFmtStereo;
-        else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
-            mDevice->FmtChans = DevFmtQuad;
-        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
-            mDevice->FmtChans = DevFmtX51;
-        else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
-            mDevice->FmtChans = DevFmtX51Rear;
-        else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
-            mDevice->FmtChans = DevFmtX61;
-        else if(OutputType.Format.nChannels == 8 && (OutputType.dwChannelMask == X7DOT1 || OutputType.dwChannelMask == X7DOT1_WIDE))
-            mDevice->FmtChans = DevFmtX71;
+        if(!GetConfigValueBool(mDevice->DeviceName.c_str(), "wasapi", "allow-resampler", true))
+            mDevice->Frequency = OutputType.Format.nSamplesPerSec;
         else
+            mDevice->Frequency = minu(mDevice->Frequency, OutputType.Format.nSamplesPerSec);
+
+        const uint32_t chancount{OutputType.Format.nChannels};
+        const DWORD chanmask{OutputType.dwChannelMask};
+        /* Don't update the channel format if the requested format fits what's
+         * supported.
+         */
+        bool chansok{false};
+        if(mDevice->Flags.test(ChannelsRequest))
         {
-            ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
-            mDevice->FmtChans = DevFmtStereo;
-            OutputType.Format.nChannels = 2;
-            OutputType.dwChannelMask = STEREO;
+            /* When requesting a channel configuration, make sure it fits the
+             * mask's lsb (to ensure no gaps in the output channels). If
+             * there's no mask, assume the request fits with enough channels.
+             */
+            switch(mDevice->FmtChans)
+            {
+            case DevFmtMono:
+                chansok = (chancount >= 1 && ((chanmask&MonoMask) == MONO || !chanmask));
+                break;
+            case DevFmtStereo:
+                chansok = (chancount >= 2 && ((chanmask&StereoMask) == STEREO || !chanmask));
+                break;
+            case DevFmtQuad:
+                chansok = (chancount >= 4 && ((chanmask&QuadMask) == QUAD || !chanmask));
+                break;
+            case DevFmtX51:
+                chansok = (chancount >= 6 && ((chanmask&X51Mask) == X5DOT1
+                        || (chanmask&X51RearMask) == X5DOT1REAR || !chanmask));
+                break;
+            case DevFmtX61:
+                chansok = (chancount >= 7 && ((chanmask&X61Mask) == X6DOT1 || !chanmask));
+                break;
+            case DevFmtX71:
+            case DevFmtX3D71:
+                chansok = (chancount >= 8 && ((chanmask&X71Mask) == X7DOT1 || !chanmask));
+                break;
+            case DevFmtX714:
+                chansok = (chancount >= 12 && ((chanmask&X714Mask) == X7DOT1DOT4 || !chanmask));
+            case DevFmtAmbi3D:
+                break;
+            }
+        }
+        if(!chansok)
+        {
+            if(chancount >= 12 && (chanmask&X714Mask) == X7DOT1DOT4)
+                mDevice->FmtChans = DevFmtX714;
+            else if(chancount >= 8 && (chanmask&X71Mask) == X7DOT1)
+                mDevice->FmtChans = DevFmtX71;
+            else if(chancount >= 7 && (chanmask&X61Mask) == X6DOT1)
+                mDevice->FmtChans = DevFmtX61;
+            else if(chancount >= 6 && ((chanmask&X51Mask) == X5DOT1
+                || (chanmask&X51RearMask) == X5DOT1REAR))
+                mDevice->FmtChans = DevFmtX51;
+            else if(chancount >= 4 && (chanmask&QuadMask) == QUAD)
+                mDevice->FmtChans = DevFmtQuad;
+            else if(chancount >= 2 && ((chanmask&StereoMask) == STEREO || !chanmask))
+                mDevice->FmtChans = DevFmtStereo;
+            else if(chancount >= 1 && ((chanmask&MonoMask) == MONO || !chanmask))
+                mDevice->FmtChans = DevFmtMono;
+            else
+            {
+                ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels,
+                    OutputType.dwChannelMask);
+                mDevice->FmtChans = DevFmtStereo;
+                OutputType.Format.nChannels = 2;
+                OutputType.dwChannelMask = STEREO;
+            }
         }
 
         if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_PCM))
@@ -1017,7 +1148,7 @@ HRESULT WasapiPlayback::resetProxy()
         }
         else
         {
-            ERR("Unhandled format sub-type\n");
+            ERR("Unhandled format sub-type: %s\n", GuidPrinter{OutputType.SubFormat}.c_str());
             mDevice->FmtType = DevFmtShort;
             if(OutputType.Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
                 OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
@@ -1026,25 +1157,24 @@ HRESULT WasapiPlayback::resetProxy()
         }
         OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
     }
+    mFormat = OutputType;
 
-    EndpointFormFactor formfactor = UnknownFormFactor;
-    get_device_formfactor(mMMDev, &formfactor);
-    mDevice->IsHeadphones = (mDevice->FmtChans == DevFmtStereo &&
-        (formfactor == Headphones || formfactor == Headset));
+    const EndpointFormFactor formfactor{get_device_formfactor(mMMDev.get())};
+    mDevice->Flags.set(DirectEar, (formfactor == Headphones || formfactor == Headset));
 
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
 
-    hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK, buf_time,
-        0, &OutputType.Format, nullptr);
+    hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
+        buf_time.count(), 0, &OutputType.Format, nullptr);
     if(FAILED(hr))
     {
         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
         return hr;
     }
 
-    UINT32 buffer_len{}, min_len{};
-    REFERENCE_TIME min_per{};
-    hr = mClient->GetDevicePeriod(&min_per, nullptr);
+    UINT32 buffer_len{};
+    ReferenceTime min_per{};
+    hr = mClient->GetDevicePeriod(&reinterpret_cast<REFERENCE_TIME&>(min_per), nullptr);
     if(SUCCEEDED(hr))
         hr = mClient->GetBufferSize(&buffer_len);
     if(FAILED(hr))
@@ -1056,11 +1186,31 @@ HRESULT WasapiPlayback::resetProxy()
     /* Find the nearest multiple of the period size to the update size */
     if(min_per < per_time)
         min_per *= maxi64((per_time + min_per/2) / min_per, 1);
-    min_len = static_cast<UINT32>(ScaleCeil(min_per, mDevice->Frequency, REFTIME_PER_SEC));
-    min_len = minu(min_len, buffer_len/2);
 
-    mDevice->UpdateSize = min_len;
-    mDevice->BufferSize = buffer_len;
+    mOrigBufferSize = buffer_len;
+    mOrigUpdateSize = minu(RefTime2Samples(min_per, mFormat.Format.nSamplesPerSec), buffer_len/2);
+
+    mDevice->BufferSize = static_cast<uint>(uint64_t{buffer_len} * mDevice->Frequency /
+        mFormat.Format.nSamplesPerSec);
+    mDevice->UpdateSize = minu(RefTime2Samples(min_per, mDevice->Frequency),
+        mDevice->BufferSize/2);
+
+    mResampler = nullptr;
+    mResampleBuffer = nullptr;
+    mBufferFilled = 0;
+    if(mDevice->Frequency != mFormat.Format.nSamplesPerSec)
+    {
+        mResampler = SampleConverter::Create(mDevice->FmtType, mDevice->FmtType,
+            mFormat.Format.nChannels, mDevice->Frequency, mFormat.Format.nSamplesPerSec,
+            Resampler::FastBSinc24);
+        mResampleBuffer = std::make_unique<char[]>(size_t{mDevice->UpdateSize} *
+            mFormat.Format.nChannels * mFormat.Format.wBitsPerSample / 8);
+
+        TRACE("Created converter for %s/%s format, dst: %luhz (%u), src: %uhz (%u)\n",
+            DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
+            mFormat.Format.nSamplesPerSec, mOrigUpdateSize, mDevice->Frequency,
+            mDevice->UpdateSize);
+    }
 
     hr = mClient->SetEventHandle(mNotifyEvent);
     if(FAILED(hr))
@@ -1073,17 +1223,19 @@ HRESULT WasapiPlayback::resetProxy()
 }
 
 
-bool WasapiPlayback::start()
+void WasapiPlayback::start()
 {
-    HRESULT hr{pushMessage(MsgType::StartDevice).get()};
-    return SUCCEEDED(hr) ? true : false;
+    const HRESULT hr{pushMessage(MsgType::StartDevice).get()};
+    if(FAILED(hr))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start playback: 0x%lx", hr};
 }
 
 HRESULT WasapiPlayback::startProxy()
 {
     ResetEvent(mNotifyEvent);
 
-    HRESULT hr = mClient->Start();
+    HRESULT hr{mClient->Start()};
     if(FAILED(hr))
     {
         ERR("Failed to start audio client: 0x%08lx\n", hr);
@@ -1094,13 +1246,12 @@ HRESULT WasapiPlayback::startProxy()
     hr = mClient->GetService(IID_IAudioRenderClient, &ptr);
     if(SUCCEEDED(hr))
     {
-        mRender = static_cast<IAudioRenderClient*>(ptr);
+        mRender = ComPtr<IAudioRenderClient>{static_cast<IAudioRenderClient*>(ptr)};
         try {
             mKillNow.store(false, std::memory_order_release);
             mThread = std::thread{std::mem_fn(&WasapiPlayback::mixerProc), this};
         }
         catch(...) {
-            mRender->Release();
             mRender = nullptr;
             ERR("Failed to start thread\n");
             hr = E_FAIL;
@@ -1125,7 +1276,6 @@ void WasapiPlayback::stopProxy()
     mKillNow.store(true, std::memory_order_release);
     mThread.join();
 
-    mRender->Release();
     mRender = nullptr;
     mClient->Stop();
 }
@@ -1135,39 +1285,44 @@ ClockLatency WasapiPlayback::getClockLatency()
 {
     ClockLatency ret;
 
-    std::lock_guard<WasapiPlayback> _{*this};
+    std::lock_guard<std::mutex> _{mMutex};
     ret.ClockTime = GetDeviceClockTime(mDevice);
-    ret.Latency  = std::chrono::seconds{mPadding.load(std::memory_order_relaxed)};
-    ret.Latency /= mDevice->Frequency;
+    ret.Latency  = seconds{mPadding.load(std::memory_order_relaxed)};
+    ret.Latency /= mFormat.Format.nSamplesPerSec;
+    if(mResampler)
+    {
+        auto extra = mResampler->currentInputDelay();
+        ret.Latency += std::chrono::duration_cast<nanoseconds>(extra) / mDevice->Frequency;
+        ret.Latency += nanoseconds{seconds{mBufferFilled}} / mDevice->Frequency;
+    }
 
     return ret;
 }
 
 
 struct WasapiCapture final : public BackendBase, WasapiProxy {
-    WasapiCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    WasapiCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~WasapiCapture() override;
 
     int recordProc();
 
-    void open(const ALCchar *name) override;
-    HRESULT openProxy() override;
+    void open(const char *name) override;
+    HRESULT openProxy(const char *name) override;
     void closeProxy() override;
 
     HRESULT resetProxy() override;
-    bool start() override;
+    void start() override;
     HRESULT startProxy() override;
     void stop() override;
     void stopProxy() override;
 
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
-
-    std::wstring mDevId;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
-    IMMDevice *mMMDev{nullptr};
-    IAudioClient *mClient{nullptr};
-    IAudioCaptureClient *mCapture{nullptr};
+    HRESULT mOpenStatus{E_FAIL};
+    ComPtr<IMMDevice> mMMDev{nullptr};
+    ComPtr<IAudioClient> mClient{nullptr};
+    ComPtr<IAudioCaptureClient> mCapture{nullptr};
     HANDLE mNotifyEvent{nullptr};
 
     ChannelConverter mChannelConv{};
@@ -1182,7 +1337,12 @@ struct WasapiCapture final : public BackendBase, WasapiProxy {
 
 WasapiCapture::~WasapiCapture()
 {
-    pushMessage(MsgType::CloseDevice).wait();
+    if(SUCCEEDED(mOpenStatus))
+    {
+        pushMessage(MsgType::CloseDevice).wait();
+        DeinitThread();
+    }
+    mOpenStatus = E_FAIL;
 
     if(mNotifyEvent != nullptr)
         CloseHandle(mNotifyEvent);
@@ -1192,11 +1352,11 @@ WasapiCapture::~WasapiCapture()
 
 FORCE_ALIGN int WasapiCapture::recordProc()
 {
-    HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    HRESULT hr{CoInitializeEx(nullptr, COINIT_MULTITHREADED)};
     if(FAILED(hr))
     {
         ERR("CoInitializeEx(nullptr, COINIT_MULTITHREADED) failed: 0x%08lx\n", hr);
-        aluHandleDisconnect(mDevice, "COM init failed: 0x%08lx", hr);
+        mDevice->handleDisconnect("COM init failed: 0x%08lx", hr);
         return 1;
     }
 
@@ -1232,11 +1392,11 @@ FORCE_ALIGN int WasapiCapture::recordProc()
                 size_t dstframes;
                 if(mSampleConv)
                 {
-                    const ALvoid *srcdata{rdata};
-                    ALuint srcframes{numsamples};
+                    const void *srcdata{rdata};
+                    uint srcframes{numsamples};
 
                     dstframes = mSampleConv->convert(&srcdata, &srcframes, data.first.buf,
-                        static_cast<ALuint>(minz(data.first.len, INT_MAX)));
+                        static_cast<uint>(minz(data.first.len, INT_MAX)));
                     if(srcframes > 0 && dstframes == data.first.len && data.second.len > 0)
                     {
                         /* If some source samples remain, all of the first dest
@@ -1244,12 +1404,12 @@ FORCE_ALIGN int WasapiCapture::recordProc()
                          * dest block, do another run for the second block.
                          */
                         dstframes += mSampleConv->convert(&srcdata, &srcframes, data.second.buf,
-                            static_cast<ALuint>(minz(data.second.len, INT_MAX)));
+                            static_cast<uint>(minz(data.second.len, INT_MAX)));
                     }
                 }
                 else
                 {
-                    const auto framesize = static_cast<ALuint>(mDevice->frameSizeFromFmt());
+                    const uint framesize{mDevice->frameSizeFromFmt()};
                     size_t len1{minz(data.first.len, numsamples)};
                     size_t len2{minz(data.second.len, numsamples-len1)};
 
@@ -1268,7 +1428,7 @@ FORCE_ALIGN int WasapiCapture::recordProc()
 
         if(FAILED(hr))
         {
-            aluHandleDisconnect(mDevice, "Failed to capture samples: 0x%08lx", hr);
+            mDevice->handleDisconnect("Failed to capture samples: 0x%08lx", hr);
             break;
         }
 
@@ -1282,119 +1442,112 @@ FORCE_ALIGN int WasapiCapture::recordProc()
 }
 
 
-void WasapiCapture::open(const ALCchar *name)
+void WasapiCapture::open(const char *name)
 {
-    HRESULT hr{S_OK};
+    if(SUCCEEDED(mOpenStatus))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Unexpected duplicate open call"};
 
     mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
     if(mNotifyEvent == nullptr)
     {
-        ERR("Failed to create notify event: %lu\n", GetLastError());
-        hr = E_FAIL;
+        ERR("Failed to create notify events: %lu\n", GetLastError());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to create notify events"};
     }
 
-    if(SUCCEEDED(hr))
+    HRESULT hr{InitThread()};
+    if(FAILED(hr))
     {
-        if(name)
-        {
-            if(CaptureDevices.empty())
-                pushMessage(MsgType::EnumerateCapture).wait();
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to init COM thread: 0x%08lx", hr};
+    }
 
-            hr = E_FAIL;
-            auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-                [name](const DevMap &entry) -> bool
-                { return entry.name == name || entry.endpoint_guid == name; }
-            );
-            if(iter == CaptureDevices.cend())
-            {
-                std::wstring wname{utf8_to_wstr(name)};
-                iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
-                    [&wname](const DevMap &entry) -> bool
-                    { return entry.devid == wname; }
-                );
-            }
-            if(iter == CaptureDevices.cend())
-                WARN("Failed to find device name matching \"%s\"\n", name);
-            else
-            {
-                mDevId = iter->devid;
-                mDevice->DeviceName = iter->name;
-                hr = S_OK;
-            }
+    if(name)
+    {
+        if(CaptureDevices.empty())
+            pushMessage(MsgType::EnumerateCapture);
+        if(std::strncmp(name, DevNameHead, DevNameHeadLen) == 0)
+        {
+            name += DevNameHeadLen;
+            if(*name == '\0')
+                name = nullptr;
         }
     }
 
-    if(SUCCEEDED(hr))
-        hr = pushMessage(MsgType::OpenDevice).get();
-
-    if(FAILED(hr))
+    mOpenStatus = pushMessage(MsgType::OpenDevice, name).get();
+    if(FAILED(mOpenStatus))
     {
-        if(mNotifyEvent != nullptr)
-            CloseHandle(mNotifyEvent);
-        mNotifyEvent = nullptr;
-
-        mDevId.clear();
-
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
+        DeinitThread();
+        throw al::backend_exception{al::backend_error::DeviceError, "Device init failed: 0x%08lx",
+            mOpenStatus};
     }
 
     hr = pushMessage(MsgType::ResetDevice).get();
     if(FAILED(hr))
     {
         if(hr == E_OUTOFMEMORY)
-            throw al::backend_exception{ALC_OUT_OF_MEMORY, "Out of memory"};
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device reset failed"};
+            throw al::backend_exception{al::backend_error::OutOfMemory, "Out of memory"};
+        throw al::backend_exception{al::backend_error::DeviceError, "Device reset failed"};
     }
 }
 
-HRESULT WasapiCapture::openProxy()
+HRESULT WasapiCapture::openProxy(const char *name)
 {
+    const wchar_t *devid{nullptr};
+    if(name)
+    {
+        auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
+            [name](const DevMap &entry) -> bool
+            { return entry.name == name || entry.endpoint_guid == name; });
+        if(iter == CaptureDevices.cend())
+        {
+            const std::wstring wname{utf8_to_wstr(name)};
+            iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
+                [&wname](const DevMap &entry) -> bool
+                { return entry.devid == wname; });
+        }
+        if(iter == CaptureDevices.cend())
+        {
+            WARN("Failed to find device name matching \"%s\"\n", name);
+            return E_FAIL;
+        }
+        name = iter->name.c_str();
+        devid = iter->devid.c_str();
+    }
+
     void *ptr;
     HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
         IID_IMMDeviceEnumerator, &ptr)};
     if(SUCCEEDED(hr))
     {
-        auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
-        if(mDevId.empty())
-            hr = Enumerator->GetDefaultAudioEndpoint(eCapture, eMultimedia, &mMMDev);
+        ComPtr<IMMDeviceEnumerator> enumerator{static_cast<IMMDeviceEnumerator*>(ptr)};
+        if(!devid)
+            hr = enumerator->GetDefaultAudioEndpoint(eCapture, eMultimedia, mMMDev.getPtr());
         else
-            hr = Enumerator->GetDevice(mDevId.c_str(), &mMMDev);
-        Enumerator->Release();
+            hr = enumerator->GetDevice(devid, mMMDev.getPtr());
     }
-    if(SUCCEEDED(hr))
-        hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
-    if(SUCCEEDED(hr))
-    {
-        mClient = static_cast<IAudioClient*>(ptr);
-        if(mDevice->DeviceName.empty())
-            mDevice->DeviceName = get_device_name_and_guid(mMMDev).first;
-    }
-
     if(FAILED(hr))
     {
-        if(mMMDev)
-            mMMDev->Release();
-        mMMDev = nullptr;
+        WARN("Failed to open device \"%s\"\n", name?name:"(default)");
+        return hr;
     }
 
+    mClient = nullptr;
+    if(name) mDevice->DeviceName = std::string{DevNameHead} + name;
+    else mDevice->DeviceName = DevNameHead + get_device_name_and_guid(mMMDev.get()).first;
+
     return hr;
 }
 
 void WasapiCapture::closeProxy()
 {
-    if(mClient)
-        mClient->Release();
     mClient = nullptr;
-
-    if(mMMDev)
-        mMMDev->Release();
     mMMDev = nullptr;
 }
 
 HRESULT WasapiCapture::resetProxy()
 {
-    if(mClient)
-        mClient->Release();
     mClient = nullptr;
 
     void *ptr;
@@ -1404,86 +1557,112 @@ HRESULT WasapiCapture::resetProxy()
         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
         return hr;
     }
-    mClient = static_cast<IAudioClient*>(ptr);
+    mClient = ComPtr<IAudioClient>{static_cast<IAudioClient*>(ptr)};
+
+    WAVEFORMATEX *wfx;
+    hr = mClient->GetMixFormat(&wfx);
+    if(FAILED(hr))
+    {
+        ERR("Failed to get capture format: 0x%08lx\n", hr);
+        return hr;
+    }
+    TraceFormat("Device capture format", wfx);
+
+    WAVEFORMATEXTENSIBLE InputType{};
+    if(!MakeExtensible(&InputType, wfx))
+    {
+        CoTaskMemFree(wfx);
+        return E_FAIL;
+    }
+    CoTaskMemFree(wfx);
+    wfx = nullptr;
+
+    const bool isRear51{InputType.Format.nChannels == 6
+        && (InputType.dwChannelMask&X51RearMask) == X5DOT1REAR};
 
     // Make sure buffer is at least 100ms in size
-    REFERENCE_TIME buf_time{mDevice->BufferSize * REFTIME_PER_SEC / mDevice->Frequency};
-    buf_time = maxu64(buf_time, REFTIME_PER_SEC/10);
+    ReferenceTime buf_time{ReferenceTime{seconds{mDevice->BufferSize}} / mDevice->Frequency};
+    buf_time = std::max(buf_time, ReferenceTime{milliseconds{100}});
 
-    WAVEFORMATEXTENSIBLE OutputType{};
-    OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+    InputType = {};
+    InputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
     switch(mDevice->FmtChans)
     {
-        case DevFmtMono:
-            OutputType.Format.nChannels = 1;
-            OutputType.dwChannelMask = MONO;
-            break;
-        case DevFmtStereo:
-            OutputType.Format.nChannels = 2;
-            OutputType.dwChannelMask = STEREO;
-            break;
-        case DevFmtQuad:
-            OutputType.Format.nChannels = 4;
-            OutputType.dwChannelMask = QUAD;
-            break;
-        case DevFmtX51:
-            OutputType.Format.nChannels = 6;
-            OutputType.dwChannelMask = X5DOT1;
-            break;
-        case DevFmtX51Rear:
-            OutputType.Format.nChannels = 6;
-            OutputType.dwChannelMask = X5DOT1REAR;
-            break;
-        case DevFmtX61:
-            OutputType.Format.nChannels = 7;
-            OutputType.dwChannelMask = X6DOT1;
-            break;
-        case DevFmtX71:
-            OutputType.Format.nChannels = 8;
-            OutputType.dwChannelMask = X7DOT1;
-            break;
+    case DevFmtMono:
+        InputType.Format.nChannels = 1;
+        InputType.dwChannelMask = MONO;
+        break;
+    case DevFmtStereo:
+        InputType.Format.nChannels = 2;
+        InputType.dwChannelMask = STEREO;
+        break;
+    case DevFmtQuad:
+        InputType.Format.nChannels = 4;
+        InputType.dwChannelMask = QUAD;
+        break;
+    case DevFmtX51:
+        InputType.Format.nChannels = 6;
+        InputType.dwChannelMask = isRear51 ? X5DOT1REAR : X5DOT1;
+        break;
+    case DevFmtX61:
+        InputType.Format.nChannels = 7;
+        InputType.dwChannelMask = X6DOT1;
+        break;
+    case DevFmtX71:
+        InputType.Format.nChannels = 8;
+        InputType.dwChannelMask = X7DOT1;
+        break;
+    case DevFmtX714:
+        InputType.Format.nChannels = 12;
+        InputType.dwChannelMask = X7DOT1DOT4;
+        break;
 
-        case DevFmtAmbi3D:
-            return E_FAIL;
+    case DevFmtX3D71:
+    case DevFmtAmbi3D:
+        return E_FAIL;
     }
     switch(mDevice->FmtType)
     {
-        /* NOTE: Signedness doesn't matter, the converter will handle it. */
-        case DevFmtByte:
-        case DevFmtUByte:
-            OutputType.Format.wBitsPerSample = 8;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtShort:
-        case DevFmtUShort:
-            OutputType.Format.wBitsPerSample = 16;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtInt:
-        case DevFmtUInt:
-            OutputType.Format.wBitsPerSample = 32;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-            break;
-        case DevFmtFloat:
-            OutputType.Format.wBitsPerSample = 32;
-            OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
-            break;
+    /* NOTE: Signedness doesn't matter, the converter will handle it. */
+    case DevFmtByte:
+    case DevFmtUByte:
+        InputType.Format.wBitsPerSample = 8;
+        InputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtShort:
+    case DevFmtUShort:
+        InputType.Format.wBitsPerSample = 16;
+        InputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtInt:
+    case DevFmtUInt:
+        InputType.Format.wBitsPerSample = 32;
+        InputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
+        break;
+    case DevFmtFloat:
+        InputType.Format.wBitsPerSample = 32;
+        InputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+        break;
     }
-    OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
-    OutputType.Format.nSamplesPerSec = mDevice->Frequency;
+    InputType.Samples.wValidBitsPerSample = InputType.Format.wBitsPerSample;
+    InputType.Format.nSamplesPerSec = mDevice->Frequency;
 
-    OutputType.Format.nBlockAlign = static_cast<WORD>(OutputType.Format.nChannels *
-        OutputType.Format.wBitsPerSample / 8);
-    OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
-        OutputType.Format.nBlockAlign;
-    OutputType.Format.cbSize = sizeof(OutputType) - sizeof(OutputType.Format);
+    InputType.Format.nBlockAlign = static_cast<WORD>(InputType.Format.nChannels *
+        InputType.Format.wBitsPerSample / 8);
+    InputType.Format.nAvgBytesPerSec = InputType.Format.nSamplesPerSec *
+        InputType.Format.nBlockAlign;
+    InputType.Format.cbSize = sizeof(InputType) - sizeof(InputType.Format);
 
-    TraceFormat("Requesting capture format", &OutputType.Format);
-    WAVEFORMATEX *wfx;
-    hr = mClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
+    TraceFormat("Requesting capture format", &InputType.Format);
+    hr = mClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &InputType.Format, &wfx);
+    if(FAILED(hr))
+    {
+        WARN("Failed to check capture format support: 0x%08lx\n", hr);
+        hr = mClient->GetMixFormat(&wfx);
+    }
     if(FAILED(hr))
     {
-        ERR("Failed to check format support: 0x%08lx\n", hr);
+        ERR("Failed to find a supported capture format: 0x%08lx\n", hr);
         return hr;
     }
 
@@ -1493,92 +1672,132 @@ HRESULT WasapiCapture::resetProxy()
     if(wfx != nullptr)
     {
         TraceFormat("Got capture format", wfx);
-        if(!(wfx->nChannels == OutputType.Format.nChannels ||
-             (wfx->nChannels == 1 && OutputType.Format.nChannels == 2) ||
-             (wfx->nChannels == 2 && OutputType.Format.nChannels == 1)))
+        if(!MakeExtensible(&InputType, wfx))
         {
-            ERR("Failed to get matching format, wanted: %s %s %uhz, got: %d channel%s %d-bit %luhz\n",
-                DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
-                mDevice->Frequency, wfx->nChannels, (wfx->nChannels==1)?"":"s", wfx->wBitsPerSample,
-                wfx->nSamplesPerSec);
             CoTaskMemFree(wfx);
             return E_FAIL;
         }
+        CoTaskMemFree(wfx);
+        wfx = nullptr;
 
-        if(!MakeExtensible(&OutputType, wfx))
+        auto validate_fmt = [](DeviceBase *device, uint32_t chancount, DWORD chanmask) noexcept
+            -> bool
         {
-            CoTaskMemFree(wfx);
+            switch(device->FmtChans)
+            {
+            /* If the device wants mono, we can handle any input. */
+            case DevFmtMono:
+                return true;
+            /* If the device wants stereo, we can handle mono or stereo input. */
+            case DevFmtStereo:
+                return (chancount == 2 && (chanmask == 0 || (chanmask&StereoMask) == STEREO))
+                    || (chancount == 1 && (chanmask&MonoMask) == MONO);
+            /* Otherwise, the device must match the input type. */
+            case DevFmtQuad:
+                return (chancount == 4 && (chanmask == 0 || (chanmask&QuadMask) == QUAD));
+            /* 5.1 (Side) and 5.1 (Rear) are interchangeable here. */
+            case DevFmtX51:
+                return (chancount == 6 && (chanmask == 0 || (chanmask&X51Mask) == X5DOT1
+                        || (chanmask&X51RearMask) == X5DOT1REAR));
+            case DevFmtX61:
+                return (chancount == 7 && (chanmask == 0 || (chanmask&X61Mask) == X6DOT1));
+            case DevFmtX71:
+            case DevFmtX3D71:
+                return (chancount == 8 && (chanmask == 0 || (chanmask&X71Mask) == X7DOT1));
+            case DevFmtX714:
+                return (chancount == 12 && (chanmask == 0 || (chanmask&X714Mask) == X7DOT1DOT4));
+            case DevFmtAmbi3D:
+                return (chanmask == 0 && chancount == device->channelsFromFmt());
+            }
+            return false;
+        };
+        if(!validate_fmt(mDevice, InputType.Format.nChannels, InputType.dwChannelMask))
+        {
+            ERR("Failed to match format, wanted: %s %s %uhz, got: 0x%08lx mask %d channel%s %d-bit %luhz\n",
+                DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
+                mDevice->Frequency, InputType.dwChannelMask, InputType.Format.nChannels,
+                (InputType.Format.nChannels==1)?"":"s", InputType.Format.wBitsPerSample,
+                InputType.Format.nSamplesPerSec);
             return E_FAIL;
         }
-        CoTaskMemFree(wfx);
-        wfx = nullptr;
     }
 
-    DevFmtType srcType;
-    if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_PCM))
+    DevFmtType srcType{};
+    if(IsEqualGUID(InputType.SubFormat, KSDATAFORMAT_SUBTYPE_PCM))
     {
-        if(OutputType.Format.wBitsPerSample == 8)
+        if(InputType.Format.wBitsPerSample == 8)
             srcType = DevFmtUByte;
-        else if(OutputType.Format.wBitsPerSample == 16)
+        else if(InputType.Format.wBitsPerSample == 16)
             srcType = DevFmtShort;
-        else if(OutputType.Format.wBitsPerSample == 32)
+        else if(InputType.Format.wBitsPerSample == 32)
             srcType = DevFmtInt;
         else
         {
-            ERR("Unhandled integer bit depth: %d\n", OutputType.Format.wBitsPerSample);
+            ERR("Unhandled integer bit depth: %d\n", InputType.Format.wBitsPerSample);
             return E_FAIL;
         }
     }
-    else if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
+    else if(IsEqualGUID(InputType.SubFormat, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
     {
-        if(OutputType.Format.wBitsPerSample == 32)
+        if(InputType.Format.wBitsPerSample == 32)
             srcType = DevFmtFloat;
         else
         {
-            ERR("Unhandled float bit depth: %d\n", OutputType.Format.wBitsPerSample);
+            ERR("Unhandled float bit depth: %d\n", InputType.Format.wBitsPerSample);
             return E_FAIL;
         }
     }
     else
     {
-        ERR("Unhandled format sub-type\n");
+        ERR("Unhandled format sub-type: %s\n", GuidPrinter{InputType.SubFormat}.c_str());
         return E_FAIL;
     }
 
-    if(mDevice->FmtChans == DevFmtMono && OutputType.Format.nChannels == 2)
+    if(mDevice->FmtChans == DevFmtMono && InputType.Format.nChannels != 1)
     {
-        mChannelConv = ChannelConverter{srcType, DevFmtStereo, mDevice->FmtChans};
-        TRACE("Created %s stereo-to-mono converter\n", DevFmtTypeString(srcType));
+        uint chanmask{(1u<<InputType.Format.nChannels) - 1u};
+        /* Exclude LFE from the downmix. */
+        if((InputType.dwChannelMask&SPEAKER_LOW_FREQUENCY))
+        {
+            constexpr auto lfemask = MaskFromTopBits(SPEAKER_LOW_FREQUENCY);
+            const int lfeidx{al::popcount(InputType.dwChannelMask&lfemask) - 1};
+            chanmask &= ~(1u << lfeidx);
+        }
+
+        mChannelConv = ChannelConverter{srcType, InputType.Format.nChannels, chanmask,
+            mDevice->FmtChans};
+        TRACE("Created %s multichannel-to-mono converter\n", DevFmtTypeString(srcType));
         /* The channel converter always outputs float, so change the input type
          * for the resampler/type-converter.
          */
         srcType = DevFmtFloat;
     }
-    else if(mDevice->FmtChans == DevFmtStereo && OutputType.Format.nChannels == 1)
+    else if(mDevice->FmtChans == DevFmtStereo && InputType.Format.nChannels == 1)
     {
-        mChannelConv = ChannelConverter{srcType, DevFmtMono, mDevice->FmtChans};
+        mChannelConv = ChannelConverter{srcType, 1, 0x1, mDevice->FmtChans};
         TRACE("Created %s mono-to-stereo converter\n", DevFmtTypeString(srcType));
         srcType = DevFmtFloat;
     }
 
-    if(mDevice->Frequency != OutputType.Format.nSamplesPerSec || mDevice->FmtType != srcType)
+    if(mDevice->Frequency != InputType.Format.nSamplesPerSec || mDevice->FmtType != srcType)
     {
-        mSampleConv = CreateSampleConverter(srcType, mDevice->FmtType, mDevice->channelsFromFmt(),
-            OutputType.Format.nSamplesPerSec, mDevice->Frequency, Resampler::FastBSinc24);
+        mSampleConv = SampleConverter::Create(srcType, mDevice->FmtType,
+            mDevice->channelsFromFmt(), InputType.Format.nSamplesPerSec, mDevice->Frequency,
+            Resampler::FastBSinc24);
         if(!mSampleConv)
         {
             ERR("Failed to create converter for %s format, dst: %s %uhz, src: %s %luhz\n",
                 DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
-                mDevice->Frequency, DevFmtTypeString(srcType), OutputType.Format.nSamplesPerSec);
+                mDevice->Frequency, DevFmtTypeString(srcType), InputType.Format.nSamplesPerSec);
             return E_FAIL;
         }
         TRACE("Created converter for %s format, dst: %s %uhz, src: %s %luhz\n",
-              DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
-              mDevice->Frequency, DevFmtTypeString(srcType), OutputType.Format.nSamplesPerSec);
+            DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
+            mDevice->Frequency, DevFmtTypeString(srcType), InputType.Format.nSamplesPerSec);
     }
 
-    hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK, buf_time,
-        0, &OutputType.Format, nullptr);
+    hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
+        buf_time.count(), 0, &InputType.Format, nullptr);
     if(FAILED(hr))
     {
         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
@@ -1586,8 +1805,8 @@ HRESULT WasapiCapture::resetProxy()
     }
 
     UINT32 buffer_len{};
-    REFERENCE_TIME min_per{};
-    hr = mClient->GetDevicePeriod(&min_per, nullptr);
+    ReferenceTime min_per{};
+    hr = mClient->GetDevicePeriod(&reinterpret_cast<REFERENCE_TIME&>(min_per), nullptr);
     if(SUCCEEDED(hr))
         hr = mClient->GetBufferSize(&buffer_len);
     if(FAILED(hr))
@@ -1595,12 +1814,10 @@ HRESULT WasapiCapture::resetProxy()
         ERR("Failed to get buffer size: 0x%08lx\n", hr);
         return hr;
     }
-    mDevice->UpdateSize = static_cast<ALuint>(ScaleCeil(min_per, mDevice->Frequency,
-        REFTIME_PER_SEC));
+    mDevice->UpdateSize = RefTime2Samples(min_per, mDevice->Frequency);
     mDevice->BufferSize = buffer_len;
 
-    buffer_len = maxu(mDevice->BufferSize, buffer_len);
-    mRing = CreateRingBuffer(buffer_len, mDevice->frameSizeFromFmt(), false);
+    mRing = RingBuffer::Create(buffer_len, mDevice->frameSizeFromFmt(), false);
 
     hr = mClient->SetEventHandle(mNotifyEvent);
     if(FAILED(hr))
@@ -1613,10 +1830,12 @@ HRESULT WasapiCapture::resetProxy()
 }
 
 
-bool WasapiCapture::start()
+void WasapiCapture::start()
 {
-    HRESULT hr{pushMessage(MsgType::StartDevice).get()};
-    return SUCCEEDED(hr) ? true : false;
+    const HRESULT hr{pushMessage(MsgType::StartDevice).get()};
+    if(FAILED(hr))
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start recording: 0x%lx", hr};
 }
 
 HRESULT WasapiCapture::startProxy()
@@ -1634,13 +1853,12 @@ HRESULT WasapiCapture::startProxy()
     hr = mClient->GetService(IID_IAudioCaptureClient, &ptr);
     if(SUCCEEDED(hr))
     {
-        mCapture = static_cast<IAudioCaptureClient*>(ptr);
+        mCapture = ComPtr<IAudioCaptureClient>{static_cast<IAudioCaptureClient*>(ptr)};
         try {
             mKillNow.store(false, std::memory_order_release);
             mThread = std::thread{std::mem_fn(&WasapiCapture::recordProc), this};
         }
         catch(...) {
-            mCapture->Release();
             mCapture = nullptr;
             ERR("Failed to start thread\n");
             hr = E_FAIL;
@@ -1668,21 +1886,17 @@ void WasapiCapture::stopProxy()
     mKillNow.store(true, std::memory_order_release);
     mThread.join();
 
-    mCapture->Release();
     mCapture = nullptr;
     mClient->Stop();
     mClient->Reset();
 }
 
 
-ALCuint WasapiCapture::availableSamples()
-{ return static_cast<ALCuint>(mRing->readSpace()); }
+void WasapiCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
-ALCenum WasapiCapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+uint WasapiCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
 
 } // namespace
 
@@ -1693,48 +1907,78 @@ bool WasapiBackendFactory::init()
 
     if(FAILED(InitResult)) try
     {
-        std::promise<HRESULT> promise;
-        auto future = promise.get_future();
+        auto res = std::async(std::launch::async, []() -> HRESULT
+        {
+            HRESULT hr{CoInitializeEx(nullptr, COINIT_MULTITHREADED)};
+            if(FAILED(hr))
+            {
+                WARN("Failed to initialize COM: 0x%08lx\n", hr);
+                return hr;
+            }
+
+            void *ptr{};
+            hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
+                IID_IMMDeviceEnumerator, &ptr);
+            if(FAILED(hr))
+            {
+                WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
+                CoUninitialize();
+                return hr;
+            }
+            static_cast<IMMDeviceEnumerator*>(ptr)->Release();
+            CoUninitialize();
+
+            return S_OK;
+        });
 
-        std::thread{&WasapiProxy::messageHandler, &promise}.detach();
-        InitResult = future.get();
+        InitResult = res.get();
     }
     catch(...) {
     }
 
-    return SUCCEEDED(InitResult) ? ALC_TRUE : ALC_FALSE;
+    return SUCCEEDED(InitResult);
 }
 
 bool WasapiBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback || type == BackendType::Capture; }
 
-void WasapiBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string WasapiBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const DevMap &entry) -> void
-    {
-        /* +1 to also append the null char (to ensure a null-separated list and
-         * double-null terminated list).
-         */
-        outnames->append(entry.name.c_str(), entry.name.length()+1);
+    struct ProxyControl {
+        HRESULT mResult{};
+        ProxyControl() { mResult = WasapiProxy::InitThread(); }
+        ~ProxyControl() { if(SUCCEEDED(mResult)) WasapiProxy::DeinitThread(); }
     };
-    HRESULT hr{};
+    ProxyControl proxy;
+
+    std::string outnames;
+    if(FAILED(proxy.mResult))
+        return outnames;
+
     switch(type)
     {
-    case DevProbe::Playback:
-        hr = WasapiProxy::pushMessageStatic(MsgType::EnumeratePlayback).get();
-        if(SUCCEEDED(hr))
-            std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
+    case BackendType::Playback:
+        WasapiProxy::pushMessageStatic(MsgType::EnumeratePlayback).wait();
+        for(const DevMap &entry : PlaybackDevices)
+        {
+            /* +1 to also append the null char (to ensure a null-separated list
+             * and double-null terminated list).
+             */
+            outnames.append(DevNameHead).append(entry.name.c_str(), entry.name.length()+1);
+        }
         break;
 
-    case DevProbe::Capture:
-        hr = WasapiProxy::pushMessageStatic(MsgType::EnumerateCapture).get();
-        if(SUCCEEDED(hr))
-            std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
+    case BackendType::Capture:
+        WasapiProxy::pushMessageStatic(MsgType::EnumerateCapture).wait();
+        for(const DevMap &entry : CaptureDevices)
+            outnames.append(DevNameHead).append(entry.name.c_str(), entry.name.length()+1);
         break;
     }
+
+    return outnames;
 }
 
-BackendPtr WasapiBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WasapiBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new WasapiPlayback{device}};
diff --git a/alc/backends/wasapi.h b/alc/backends/wasapi.h
index 067dd259..bb2671ee 100644
--- a/alc/backends/wasapi.h
+++ b/alc/backends/wasapi.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_WASAPI_H
 #define BACKENDS_WASAPI_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct WasapiBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/wave.cpp b/alc/backends/wave.cpp
index 7bcc3436..1b40640c 100644
--- a/alc/backends/wave.cpp
+++ b/alc/backends/wave.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/wave.h"
+#include "wave.h"
 
 #include <algorithm>
 #include <atomic>
@@ -33,18 +33,15 @@
 #include <functional>
 #include <thread>
 
-#include "AL/al.h"
-
+#include "albit.h"
 #include "albyte.h"
-#include "alcmain.h"
-#include "alconfig.h"
-#include "alexcpt.h"
+#include "alc/alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
-#include "alu.h"
-#include "compat.h"
-#include "endiantest.h"
-#include "logging.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
+#include "opthelpers.h"
 #include "strutils.h"
 #include "threads.h"
 #include "vector.h"
@@ -56,50 +53,53 @@ using std::chrono::seconds;
 using std::chrono::milliseconds;
 using std::chrono::nanoseconds;
 
-constexpr ALCchar waveDevice[] = "Wave File Writer";
+using ubyte = unsigned char;
+using ushort = unsigned short;
+
+constexpr char waveDevice[] = "Wave File Writer";
 
-constexpr ALubyte SUBTYPE_PCM[]{
+constexpr ubyte SUBTYPE_PCM[]{
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
     0x00, 0x38, 0x9b, 0x71
 };
-constexpr ALubyte SUBTYPE_FLOAT[]{
+constexpr ubyte SUBTYPE_FLOAT[]{
     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
     0x00, 0x38, 0x9b, 0x71
 };
 
-constexpr ALubyte SUBTYPE_BFORMAT_PCM[]{
+constexpr ubyte SUBTYPE_BFORMAT_PCM[]{
     0x01, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
     0xca, 0x00, 0x00, 0x00
 };
 
-constexpr ALubyte SUBTYPE_BFORMAT_FLOAT[]{
+constexpr ubyte SUBTYPE_BFORMAT_FLOAT[]{
     0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
     0xca, 0x00, 0x00, 0x00
 };
 
-void fwrite16le(ALushort val, FILE *f)
+void fwrite16le(ushort val, FILE *f)
 {
-    ALubyte data[2]{ static_cast<ALubyte>(val&0xff), static_cast<ALubyte>((val>>8)&0xff) };
+    ubyte data[2]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff) };
     fwrite(data, 1, 2, f);
 }
 
-void fwrite32le(ALuint val, FILE *f)
+void fwrite32le(uint val, FILE *f)
 {
-    ALubyte data[4]{ static_cast<ALubyte>(val&0xff), static_cast<ALubyte>((val>>8)&0xff),
-        static_cast<ALubyte>((val>>16)&0xff), static_cast<ALubyte>((val>>24)&0xff) };
+    ubyte data[4]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff),
+        static_cast<ubyte>((val>>16)&0xff), static_cast<ubyte>((val>>24)&0xff) };
     fwrite(data, 1, 4, f);
 }
 
 
 struct WaveBackend final : public BackendBase {
-    WaveBackend(ALCdevice *device) noexcept : BackendBase{device} { }
+    WaveBackend(DeviceBase *device) noexcept : BackendBase{device} { }
     ~WaveBackend() override;
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
     FILE *mFile{nullptr};
@@ -126,12 +126,13 @@ int WaveBackend::mixerProc()
 
     althrd_setname(MIXER_THREAD_NAME);
 
-    const ALuint frameSize{mDevice->frameSizeFromFmt()};
+    const size_t frameStep{mDevice->channelsFromFmt()};
+    const size_t frameSize{mDevice->frameSizeFromFmt()};
 
     int64_t done{0};
     auto start = std::chrono::steady_clock::now();
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
         auto now = std::chrono::steady_clock::now();
 
@@ -145,45 +146,35 @@ int WaveBackend::mixerProc()
         }
         while(avail-done >= mDevice->UpdateSize)
         {
-            {
-                std::lock_guard<WaveBackend> _{*this};
-                aluMixData(mDevice, mBuffer.data(), mDevice->UpdateSize);
-            }
+            mDevice->renderSamples(mBuffer.data(), mDevice->UpdateSize, frameStep);
             done += mDevice->UpdateSize;
 
-            if(!IS_LITTLE_ENDIAN)
+            if(al::endian::native != al::endian::little)
             {
-                const ALuint bytesize{mDevice->bytesFromFmt()};
+                const uint bytesize{mDevice->bytesFromFmt()};
 
                 if(bytesize == 2)
                 {
-                    ALushort *samples = reinterpret_cast<ALushort*>(mBuffer.data());
-                    const size_t len{mBuffer.size() / 2};
-                    for(size_t i{0};i < len;i++)
-                    {
-                        const ALushort samp{samples[i]};
-                        samples[i] = static_cast<ALushort>((samp>>8) | (samp<<8));
-                    }
+                    const size_t len{mBuffer.size() & ~size_t{1}};
+                    for(size_t i{0};i < len;i+=2)
+                        std::swap(mBuffer[i], mBuffer[i+1]);
                 }
                 else if(bytesize == 4)
                 {
-                    ALuint *samples = reinterpret_cast<ALuint*>(mBuffer.data());
-                    const size_t len{mBuffer.size() / 4};
-                    for(size_t i{0};i < len;i++)
+                    const size_t len{mBuffer.size() & ~size_t{3}};
+                    for(size_t i{0};i < len;i+=4)
                     {
-                        const ALuint samp{samples[i]};
-                        samples[i] = (samp>>24) | ((samp>>8)&0x0000ff00) |
-                                     ((samp<<8)&0x00ff0000) | (samp<<24);
+                        std::swap(mBuffer[i  ], mBuffer[i+3]);
+                        std::swap(mBuffer[i+1], mBuffer[i+2]);
                     }
                 }
             }
 
-            size_t fs{fwrite(mBuffer.data(), frameSize, mDevice->UpdateSize, mFile)};
-            (void)fs;
-            if(ferror(mFile))
+            const size_t fs{fwrite(mBuffer.data(), frameSize, mDevice->UpdateSize, mFile)};
+            if(fs < mDevice->UpdateSize || ferror(mFile))
             {
                 ERR("Error writing to file\n");
-                aluHandleDisconnect(mDevice, "Failed to write playback samples");
+                mDevice->handleDisconnect("Failed to write playback samples");
                 break;
             }
         }
@@ -196,49 +187,54 @@ int WaveBackend::mixerProc()
         if(done >= mDevice->Frequency)
         {
             seconds s{done/mDevice->Frequency};
+            done %= mDevice->Frequency;
             start += s;
-            done -= mDevice->Frequency*s.count();
         }
     }
 
     return 0;
 }
 
-void WaveBackend::open(const ALCchar *name)
+void WaveBackend::open(const char *name)
 {
-    const char *fname{GetConfigValue(nullptr, "wave", "file", "")};
-    if(!fname[0]) throw al::backend_exception{ALC_INVALID_VALUE, "No wave output filename"};
+    auto fname = ConfigValueStr(nullptr, "wave", "file");
+    if(!fname) throw al::backend_exception{al::backend_error::NoDevice,
+        "No wave output filename"};
 
     if(!name)
         name = waveDevice;
     else if(strcmp(name, waveDevice) != 0)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
+
+    /* There's only one "device", so if it's already open, we're done. */
+    if(mFile) return;
 
 #ifdef _WIN32
     {
-        std::wstring wname = utf8_to_wstr(fname);
+        std::wstring wname{utf8_to_wstr(fname->c_str())};
         mFile = _wfopen(wname.c_str(), L"wb");
     }
 #else
-    mFile = fopen(fname, "wb");
+    mFile = fopen(fname->c_str(), "wb");
 #endif
     if(!mFile)
-        throw al::backend_exception{ALC_INVALID_VALUE, "Could not open file '%s': %s", fname,
-            strerror(errno)};
+        throw al::backend_exception{al::backend_error::DeviceError, "Could not open file '%s': %s",
+            fname->c_str(), strerror(errno)};
 
     mDevice->DeviceName = name;
 }
 
 bool WaveBackend::reset()
 {
-    ALuint channels=0, bytes=0, chanmask=0;
-    int isbformat = 0;
+    uint channels{0}, bytes{0}, chanmask{0};
+    bool isbformat{false};
     size_t val;
 
     fseek(mFile, 0, SEEK_SET);
     clearerr(mFile);
 
-    if(GetConfigValueBool(nullptr, "wave", "bformat", 0))
+    if(GetConfigValueBool(nullptr, "wave", "bformat", false))
     {
         mDevice->FmtChans = DevFmtAmbi3D;
         mDevice->mAmbiOrder = 1;
@@ -246,38 +242,43 @@ bool WaveBackend::reset()
 
     switch(mDevice->FmtType)
     {
-        case DevFmtByte:
-            mDevice->FmtType = DevFmtUByte;
-            break;
-        case DevFmtUShort:
-            mDevice->FmtType = DevFmtShort;
-            break;
-        case DevFmtUInt:
-            mDevice->FmtType = DevFmtInt;
-            break;
-        case DevFmtUByte:
-        case DevFmtShort:
-        case DevFmtInt:
-        case DevFmtFloat:
-            break;
+    case DevFmtByte:
+        mDevice->FmtType = DevFmtUByte;
+        break;
+    case DevFmtUShort:
+        mDevice->FmtType = DevFmtShort;
+        break;
+    case DevFmtUInt:
+        mDevice->FmtType = DevFmtInt;
+        break;
+    case DevFmtUByte:
+    case DevFmtShort:
+    case DevFmtInt:
+    case DevFmtFloat:
+        break;
     }
     switch(mDevice->FmtChans)
     {
-        case DevFmtMono:   chanmask = 0x04; break;
-        case DevFmtStereo: chanmask = 0x01 | 0x02; break;
-        case DevFmtQuad:   chanmask = 0x01 | 0x02 | 0x10 | 0x20; break;
-        case DevFmtX51: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x200 | 0x400; break;
-        case DevFmtX51Rear: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020; break;
-        case DevFmtX61: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x100 | 0x200 | 0x400; break;
-        case DevFmtX71: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020 | 0x200 | 0x400; break;
-        case DevFmtAmbi3D:
-            /* .amb output requires FuMa */
-            mDevice->mAmbiOrder = minu(mDevice->mAmbiOrder, 3);
-            mDevice->mAmbiLayout = AmbiLayout::FuMa;
-            mDevice->mAmbiScale = AmbiNorm::FuMa;
-            isbformat = 1;
-            chanmask = 0;
-            break;
+    case DevFmtMono:   chanmask = 0x04; break;
+    case DevFmtStereo: chanmask = 0x01 | 0x02; break;
+    case DevFmtQuad:   chanmask = 0x01 | 0x02 | 0x10 | 0x20; break;
+    case DevFmtX51: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x200 | 0x400; break;
+    case DevFmtX61: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x100 | 0x200 | 0x400; break;
+    case DevFmtX71: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020 | 0x200 | 0x400; break;
+    case DevFmtX714:
+        chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020 | 0x200 | 0x400 | 0x1000 | 0x4000
+            | 0x8000 | 0x20000;
+        break;
+    /* NOTE: Same as 7.1. */
+    case DevFmtX3D71: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020 | 0x200 | 0x400; break;
+    case DevFmtAmbi3D:
+        /* .amb output requires FuMa */
+        mDevice->mAmbiOrder = minu(mDevice->mAmbiOrder, 3);
+        mDevice->mAmbiLayout = DevAmbiLayout::FuMa;
+        mDevice->mAmbiScale = DevAmbiScaling::FuMa;
+        isbformat = true;
+        chanmask = 0;
+        break;
     }
     bytes = mDevice->bytesFromFmt();
     channels = mDevice->channelsFromFmt();
@@ -295,19 +296,19 @@ bool WaveBackend::reset()
     // 16-bit val, format type id (extensible: 0xFFFE)
     fwrite16le(0xFFFE, mFile);
     // 16-bit val, channel count
-    fwrite16le(static_cast<ALushort>(channels), mFile);
+    fwrite16le(static_cast<ushort>(channels), mFile);
     // 32-bit val, frequency
     fwrite32le(mDevice->Frequency, mFile);
     // 32-bit val, bytes per second
     fwrite32le(mDevice->Frequency * channels * bytes, mFile);
     // 16-bit val, frame size
-    fwrite16le(static_cast<ALushort>(channels * bytes), mFile);
+    fwrite16le(static_cast<ushort>(channels * bytes), mFile);
     // 16-bit val, bits per sample
-    fwrite16le(static_cast<ALushort>(bytes * 8), mFile);
+    fwrite16le(static_cast<ushort>(bytes * 8), mFile);
     // 16-bit val, extra byte count
     fwrite16le(22, mFile);
     // 16-bit val, valid bits per sample
-    fwrite16le(static_cast<ALushort>(bytes * 8), mFile);
+    fwrite16le(static_cast<ushort>(bytes * 8), mFile);
     // 32-bit val, channel mask
     fwrite32le(chanmask, mFile);
     // 16 byte GUID, sub-type format
@@ -326,27 +327,26 @@ bool WaveBackend::reset()
     }
     mDataStart = ftell(mFile);
 
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
 
-    const ALuint bufsize{mDevice->frameSizeFromFmt() * mDevice->UpdateSize};
+    const uint bufsize{mDevice->frameSizeFromFmt() * mDevice->UpdateSize};
     mBuffer.resize(bufsize);
 
     return true;
 }
 
-bool WaveBackend::start()
+void WaveBackend::start()
 {
+    if(mDataStart > 0 && fseek(mFile, 0, SEEK_END) != 0)
+        WARN("Failed to seek on output file\n");
     try {
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&WaveBackend::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Failed to start mixing thread: %s\n", e.what());
-    }
-    catch(...) {
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    return false;
 }
 
 void WaveBackend::stop()
@@ -355,14 +355,17 @@ void WaveBackend::stop()
         return;
     mThread.join();
 
-    long size{ftell(mFile)};
-    if(size > 0)
+    if(mDataStart > 0)
     {
-        long dataLen{size - mDataStart};
-        if(fseek(mFile, mDataStart-4, SEEK_SET) == 0)
-            fwrite32le(static_cast<ALuint>(dataLen), mFile); // 'data' header len
-        if(fseek(mFile, 4, SEEK_SET) == 0)
-            fwrite32le(static_cast<ALuint>(size-8), mFile); // 'WAVE' header len
+        long size{ftell(mFile)};
+        if(size > 0)
+        {
+            long dataLen{size - mDataStart};
+            if(fseek(mFile, 4, SEEK_SET) == 0)
+                fwrite32le(static_cast<uint>(size-8), mFile); // 'WAVE' header len
+            if(fseek(mFile, mDataStart-4, SEEK_SET) == 0)
+                fwrite32le(static_cast<uint>(dataLen), mFile); // 'data' header len
+        }
     }
 }
 
@@ -375,20 +378,22 @@ bool WaveBackendFactory::init()
 bool WaveBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback; }
 
-void WaveBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string WaveBackendFactory::probe(BackendType type)
 {
+    std::string outnames;
     switch(type)
     {
-        case DevProbe::Playback:
-            /* Includes null char. */
-            outnames->append(waveDevice, sizeof(waveDevice));
-            break;
-        case DevProbe::Capture:
-            break;
+    case BackendType::Playback:
+        /* Includes null char. */
+        outnames.append(waveDevice, sizeof(waveDevice));
+        break;
+    case BackendType::Capture:
+        break;
     }
+    return outnames;
 }
 
-BackendPtr WaveBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WaveBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new WaveBackend{device}};
diff --git a/alc/backends/wave.h b/alc/backends/wave.h
index b9b62d7f..e768d336 100644
--- a/alc/backends/wave.h
+++ b/alc/backends/wave.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_WAVE_H
 #define BACKENDS_WAVE_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct WaveBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/backends/winmm.cpp b/alc/backends/winmm.cpp
index 649bb345..38e1193f 100644
--- a/alc/backends/winmm.cpp
+++ b/alc/backends/winmm.cpp
@@ -20,7 +20,7 @@
 
 #include "config.h"
 
-#include "backends/winmm.h"
+#include "winmm.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -28,6 +28,7 @@
 
 #include <windows.h>
 #include <mmsystem.h>
+#include <mmreg.h>
 
 #include <array>
 #include <atomic>
@@ -37,13 +38,13 @@
 #include <algorithm>
 #include <functional>
 
-#include "alcmain.h"
-#include "alexcpt.h"
-#include "alu.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "core/helpers.h"
+#include "core/logging.h"
 #include "ringbuffer.h"
 #include "strutils.h"
 #include "threads.h"
-#include "compat.h"
 
 #ifndef WAVE_FORMAT_IEEE_FLOAT
 #define WAVE_FORMAT_IEEE_FLOAT  0x0003
@@ -64,9 +65,9 @@ void ProbePlaybackDevices(void)
 {
     PlaybackDevices.clear();
 
-    ALuint numdevs{waveOutGetNumDevs()};
+    UINT numdevs{waveOutGetNumDevs()};
     PlaybackDevices.reserve(numdevs);
-    for(ALuint i{0};i < numdevs;i++)
+    for(UINT i{0};i < numdevs;++i)
     {
         std::string dname;
 
@@ -95,9 +96,9 @@ void ProbeCaptureDevices(void)
 {
     CaptureDevices.clear();
 
-    ALuint numdevs{waveInGetNumDevs()};
+    UINT numdevs{waveInGetNumDevs()};
     CaptureDevices.reserve(numdevs);
-    for(ALuint i{0};i < numdevs;i++)
+    for(UINT i{0};i < numdevs;++i)
     {
         std::string dname;
 
@@ -124,7 +125,7 @@ void ProbeCaptureDevices(void)
 
 
 struct WinMMPlayback final : public BackendBase {
-    WinMMPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
+    WinMMPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
     ~WinMMPlayback() override;
 
     void CALLBACK waveOutProc(HWAVEOUT device, UINT msg, DWORD_PTR param1, DWORD_PTR param2) noexcept;
@@ -133,14 +134,14 @@ struct WinMMPlayback final : public BackendBase {
 
     int mixerProc();
 
-    void open(const ALCchar *name) override;
+    void open(const char *name) override;
     bool reset() override;
-    bool start() override;
+    void start() override;
     void stop() override;
 
-    std::atomic<ALuint> mWritable{0u};
+    std::atomic<uint> mWritable{0u};
     al::semaphore mSem;
-    ALuint mIdx{0u};
+    uint mIdx{0u};
     std::array<WAVEHDR,4> mWaveBuffer{};
 
     HWAVEOUT mOutHdl{nullptr};
@@ -180,36 +181,33 @@ FORCE_ALIGN int WinMMPlayback::mixerProc()
     SetRTPriority();
     althrd_setname(MIXER_THREAD_NAME);
 
-    std::unique_lock<WinMMPlayback> dlock{*this};
-    while(!mKillNow.load(std::memory_order_acquire) &&
-          mDevice->Connected.load(std::memory_order_acquire))
+    while(!mKillNow.load(std::memory_order_acquire)
+        && mDevice->Connected.load(std::memory_order_acquire))
     {
-        ALsizei todo = mWritable.load(std::memory_order_acquire);
+        uint todo{mWritable.load(std::memory_order_acquire)};
         if(todo < 1)
         {
-            dlock.unlock();
             mSem.wait();
-            dlock.lock();
             continue;
         }
 
         size_t widx{mIdx};
         do {
             WAVEHDR &waveHdr = mWaveBuffer[widx];
-            widx = (widx+1) % mWaveBuffer.size();
+            if(++widx == mWaveBuffer.size()) widx = 0;
 
-            aluMixData(mDevice, waveHdr.lpData, mDevice->UpdateSize);
+            mDevice->renderSamples(waveHdr.lpData, mDevice->UpdateSize, mFormat.nChannels);
             mWritable.fetch_sub(1, std::memory_order_acq_rel);
             waveOutWrite(mOutHdl, &waveHdr, sizeof(WAVEHDR));
         } while(--todo);
-        mIdx = static_cast<ALuint>(widx);
+        mIdx = static_cast<uint>(widx);
     }
 
     return 0;
 }
 
 
-void WinMMPlayback::open(const ALCchar *name)
+void WinMMPlayback::open(const char *name)
 {
     if(PlaybackDevices.empty())
         ProbePlaybackDevices();
@@ -219,51 +217,59 @@ void WinMMPlayback::open(const ALCchar *name)
         std::find(PlaybackDevices.cbegin(), PlaybackDevices.cend(), name) :
         PlaybackDevices.cbegin();
     if(iter == PlaybackDevices.cend())
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
     auto DeviceID = static_cast<UINT>(std::distance(PlaybackDevices.cbegin(), iter));
 
+    DevFmtType fmttype{mDevice->FmtType};
 retry_open:
-    mFormat = WAVEFORMATEX{};
-    if(mDevice->FmtType == DevFmtFloat)
+    WAVEFORMATEX format{};
+    if(fmttype == DevFmtFloat)
     {
-        mFormat.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
-        mFormat.wBitsPerSample = 32;
+        format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
+        format.wBitsPerSample = 32;
     }
     else
     {
-        mFormat.wFormatTag = WAVE_FORMAT_PCM;
-        if(mDevice->FmtType == DevFmtUByte || mDevice->FmtType == DevFmtByte)
-            mFormat.wBitsPerSample = 8;
+        format.wFormatTag = WAVE_FORMAT_PCM;
+        if(fmttype == DevFmtUByte || fmttype == DevFmtByte)
+            format.wBitsPerSample = 8;
         else
-            mFormat.wBitsPerSample = 16;
+            format.wBitsPerSample = 16;
     }
-    mFormat.nChannels = ((mDevice->FmtChans == DevFmtMono) ? 1 : 2);
-    mFormat.nBlockAlign = static_cast<WORD>(mFormat.wBitsPerSample * mFormat.nChannels / 8);
-    mFormat.nSamplesPerSec = mDevice->Frequency;
-    mFormat.nAvgBytesPerSec = mFormat.nSamplesPerSec * mFormat.nBlockAlign;
-    mFormat.cbSize = 0;
-
-    MMRESULT res{waveOutOpen(&mOutHdl, DeviceID, &mFormat,
+    format.nChannels = ((mDevice->FmtChans == DevFmtMono) ? 1 : 2);
+    format.nBlockAlign = static_cast<WORD>(format.wBitsPerSample * format.nChannels / 8);
+    format.nSamplesPerSec = mDevice->Frequency;
+    format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
+    format.cbSize = 0;
+
+    HWAVEOUT outHandle{};
+    MMRESULT res{waveOutOpen(&outHandle, DeviceID, &format,
         reinterpret_cast<DWORD_PTR>(&WinMMPlayback::waveOutProcC),
         reinterpret_cast<DWORD_PTR>(this), CALLBACK_FUNCTION)};
     if(res != MMSYSERR_NOERROR)
     {
-        if(mDevice->FmtType == DevFmtFloat)
+        if(fmttype == DevFmtFloat)
         {
-            mDevice->FmtType = DevFmtShort;
+            fmttype = DevFmtShort;
             goto retry_open;
         }
-        throw al::backend_exception{ALC_INVALID_VALUE, "waveOutOpen failed: %u", res};
+        throw al::backend_exception{al::backend_error::DeviceError, "waveOutOpen failed: %u", res};
     }
 
+    if(mOutHdl)
+        waveOutClose(mOutHdl);
+    mOutHdl = outHandle;
+    mFormat = format;
+
     mDevice->DeviceName = PlaybackDevices[DeviceID];
 }
 
 bool WinMMPlayback::reset()
 {
-    mDevice->BufferSize = static_cast<ALuint>(uint64_t{mDevice->BufferSize} *
+    mDevice->BufferSize = static_cast<uint>(uint64_t{mDevice->BufferSize} *
         mFormat.nSamplesPerSec / mDevice->Frequency);
-    mDevice->BufferSize = (mDevice->BufferSize+3) & ~0x3;
+    mDevice->BufferSize = (mDevice->BufferSize+3) & ~0x3u;
     mDevice->UpdateSize = mDevice->BufferSize / 4;
     mDevice->Frequency = mFormat.nSamplesPerSec;
 
@@ -295,7 +301,7 @@ bool WinMMPlayback::reset()
         return false;
     }
 
-    if(mFormat.nChannels == 2)
+    if(mFormat.nChannels >= 2)
         mDevice->FmtChans = DevFmtStereo;
     else if(mFormat.nChannels == 1)
         mDevice->FmtChans = DevFmtMono;
@@ -304,9 +310,9 @@ bool WinMMPlayback::reset()
         ERR("Unhandled channel count: %d\n", mFormat.nChannels);
         return false;
     }
-    SetDefaultWFXChannelOrder(mDevice);
+    setDefaultWFXChannelOrder();
 
-    ALuint BufferSize{mDevice->UpdateSize * mDevice->frameSizeFromFmt()};
+    uint BufferSize{mDevice->UpdateSize * mFormat.nChannels * mDevice->bytesFromFmt()};
 
     al_free(mWaveBuffer[0].lpData);
     mWaveBuffer[0] = WAVEHDR{};
@@ -323,25 +329,20 @@ bool WinMMPlayback::reset()
     return true;
 }
 
-bool WinMMPlayback::start()
+void WinMMPlayback::start()
 {
     try {
-        std::for_each(mWaveBuffer.begin(), mWaveBuffer.end(),
-            [this](WAVEHDR &waveHdr) -> void
-            { waveOutPrepareHeader(mOutHdl, &waveHdr, static_cast<UINT>(sizeof(WAVEHDR))); }
-        );
-        mWritable.store(static_cast<ALuint>(mWaveBuffer.size()), std::memory_order_release);
+        for(auto &waveHdr : mWaveBuffer)
+            waveOutPrepareHeader(mOutHdl, &waveHdr, sizeof(WAVEHDR));
+        mWritable.store(static_cast<uint>(mWaveBuffer.size()), std::memory_order_release);
 
         mKillNow.store(false, std::memory_order_release);
         mThread = std::thread{std::mem_fn(&WinMMPlayback::mixerProc), this};
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Failed to start mixing thread: %s\n", e.what());
-    }
-    catch(...) {
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start mixing thread: %s", e.what()};
     }
-    return false;
 }
 
 void WinMMPlayback::stop()
@@ -352,16 +353,14 @@ void WinMMPlayback::stop()
 
     while(mWritable.load(std::memory_order_acquire) < mWaveBuffer.size())
         mSem.wait();
-    std::for_each(mWaveBuffer.begin(), mWaveBuffer.end(),
-        [this](WAVEHDR &waveHdr) -> void
-        { waveOutUnprepareHeader(mOutHdl, &waveHdr, sizeof(WAVEHDR)); }
-    );
+    for(auto &waveHdr : mWaveBuffer)
+        waveOutUnprepareHeader(mOutHdl, &waveHdr, sizeof(WAVEHDR));
     mWritable.store(0, std::memory_order_release);
 }
 
 
 struct WinMMCapture final : public BackendBase {
-    WinMMCapture(ALCdevice *device) noexcept : BackendBase{device} { }
+    WinMMCapture(DeviceBase *device) noexcept : BackendBase{device} { }
     ~WinMMCapture() override;
 
     void CALLBACK waveInProc(HWAVEIN device, UINT msg, DWORD_PTR param1, DWORD_PTR param2) noexcept;
@@ -370,15 +369,15 @@ struct WinMMCapture final : public BackendBase {
 
     int captureProc();
 
-    void open(const ALCchar *name) override;
-    bool start() override;
+    void open(const char *name) override;
+    void start() override;
     void stop() override;
-    ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
-    ALCuint availableSamples() override;
+    void captureSamples(al::byte *buffer, uint samples) override;
+    uint availableSamples() override;
 
-    std::atomic<ALuint> mReadable{0u};
+    std::atomic<uint> mReadable{0u};
     al::semaphore mSem;
-    ALuint mIdx{0};
+    uint mIdx{0};
     std::array<WAVEHDR,4> mWaveBuffer{};
 
     HWAVEIN mInHdl{nullptr};
@@ -420,16 +419,13 @@ int WinMMCapture::captureProc()
 {
     althrd_setname(RECORD_THREAD_NAME);
 
-    std::unique_lock<WinMMCapture> dlock{*this};
     while(!mKillNow.load(std::memory_order_acquire) &&
           mDevice->Connected.load(std::memory_order_acquire))
     {
-        ALuint todo{mReadable.load(std::memory_order_acquire)};
+        uint todo{mReadable.load(std::memory_order_acquire)};
         if(todo < 1)
         {
-            dlock.unlock();
             mSem.wait();
-            dlock.lock();
             continue;
         }
 
@@ -442,14 +438,14 @@ int WinMMCapture::captureProc()
             mReadable.fetch_sub(1, std::memory_order_acq_rel);
             waveInAddBuffer(mInHdl, &waveHdr, sizeof(WAVEHDR));
         } while(--todo);
-        mIdx = static_cast<ALuint>(widx);
+        mIdx = static_cast<uint>(widx);
     }
 
     return 0;
 }
 
 
-void WinMMCapture::open(const ALCchar *name)
+void WinMMCapture::open(const char *name)
 {
     if(CaptureDevices.empty())
         ProbeCaptureDevices();
@@ -459,7 +455,8 @@ void WinMMCapture::open(const ALCchar *name)
         std::find(CaptureDevices.cbegin(), CaptureDevices.cend(), name) :
         CaptureDevices.cbegin();
     if(iter == CaptureDevices.cend())
-        throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
+        throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%s\" not found",
+            name};
     auto DeviceID = static_cast<UINT>(std::distance(CaptureDevices.cbegin(), iter));
 
     switch(mDevice->FmtChans)
@@ -470,11 +467,12 @@ void WinMMCapture::open(const ALCchar *name)
 
     case DevFmtQuad:
     case DevFmtX51:
-    case DevFmtX51Rear:
     case DevFmtX61:
     case DevFmtX71:
+    case DevFmtX714:
+    case DevFmtX3D71:
     case DevFmtAmbi3D:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s capture not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s capture not supported",
             DevFmtChannelsString(mDevice->FmtChans)};
     }
 
@@ -489,7 +487,7 @@ void WinMMCapture::open(const ALCchar *name)
     case DevFmtByte:
     case DevFmtUShort:
     case DevFmtUInt:
-        throw al::backend_exception{ALC_INVALID_VALUE, "%s samples not supported",
+        throw al::backend_exception{al::backend_error::DeviceError, "%s samples not supported",
             DevFmtTypeString(mDevice->FmtType)};
     }
 
@@ -507,7 +505,7 @@ void WinMMCapture::open(const ALCchar *name)
         reinterpret_cast<DWORD_PTR>(&WinMMCapture::waveInProcC),
         reinterpret_cast<DWORD_PTR>(this), CALLBACK_FUNCTION)};
     if(res != MMSYSERR_NOERROR)
-        throw al::backend_exception{ALC_INVALID_VALUE, "waveInOpen failed: %u", res};
+        throw al::backend_exception{al::backend_error::DeviceError, "waveInOpen failed: %u", res};
 
     // Ensure each buffer is 50ms each
     DWORD BufferSize{mFormat.nAvgBytesPerSec / 20u};
@@ -515,14 +513,14 @@ void WinMMCapture::open(const ALCchar *name)
 
     // Allocate circular memory buffer for the captured audio
     // Make sure circular buffer is at least 100ms in size
-    ALuint CapturedDataSize{mDevice->BufferSize};
-    CapturedDataSize = static_cast<ALuint>(maxz(CapturedDataSize, BufferSize*mWaveBuffer.size()));
+    uint CapturedDataSize{mDevice->BufferSize};
+    CapturedDataSize = static_cast<uint>(maxz(CapturedDataSize, BufferSize*mWaveBuffer.size()));
 
-    mRing = CreateRingBuffer(CapturedDataSize, mFormat.nBlockAlign, false);
+    mRing = RingBuffer::Create(CapturedDataSize, mFormat.nBlockAlign, false);
 
     al_free(mWaveBuffer[0].lpData);
     mWaveBuffer[0] = WAVEHDR{};
-    mWaveBuffer[0].lpData = static_cast<char*>(al_calloc(16, BufferSize*4));
+    mWaveBuffer[0].lpData = static_cast<char*>(al_calloc(16, BufferSize * mWaveBuffer.size()));
     mWaveBuffer[0].dwBufferLength = BufferSize;
     for(size_t i{1};i < mWaveBuffer.size();++i)
     {
@@ -534,7 +532,7 @@ void WinMMCapture::open(const ALCchar *name)
     mDevice->DeviceName = CaptureDevices[DeviceID];
 }
 
-bool WinMMCapture::start()
+void WinMMCapture::start()
 {
     try {
         for(size_t i{0};i < mWaveBuffer.size();++i)
@@ -547,14 +545,11 @@ bool WinMMCapture::start()
         mThread = std::thread{std::mem_fn(&WinMMCapture::captureProc), this};
 
         waveInStart(mInHdl);
-        return true;
     }
     catch(std::exception& e) {
-        ERR("Failed to start mixing thread: %s\n", e.what());
+        throw al::backend_exception{al::backend_error::DeviceError,
+            "Failed to start recording thread: %s", e.what()};
     }
-    catch(...) {
-    }
-    return false;
 }
 
 void WinMMCapture::stop()
@@ -576,14 +571,11 @@ void WinMMCapture::stop()
     mIdx = 0;
 }
 
-ALCenum WinMMCapture::captureSamples(al::byte *buffer, ALCuint samples)
-{
-    mRing->read(buffer, samples);
-    return ALC_NO_ERROR;
-}
+void WinMMCapture::captureSamples(al::byte *buffer, uint samples)
+{ mRing->read(buffer, samples); }
 
-ALCuint WinMMCapture::availableSamples()
-{ return static_cast<ALCuint>(mRing->readSpace()); }
+uint WinMMCapture::availableSamples()
+{ return static_cast<uint>(mRing->readSpace()); }
 
 } // namespace
 
@@ -594,31 +586,33 @@ bool WinMMBackendFactory::init()
 bool WinMMBackendFactory::querySupport(BackendType type)
 { return type == BackendType::Playback || type == BackendType::Capture; }
 
-void WinMMBackendFactory::probe(DevProbe type, std::string *outnames)
+std::string WinMMBackendFactory::probe(BackendType type)
 {
-    auto add_device = [outnames](const std::string &dname) -> void
+    std::string outnames;
+    auto add_device = [&outnames](const std::string &dname) -> void
     {
         /* +1 to also append the null char (to ensure a null-separated list and
          * double-null terminated list).
          */
         if(!dname.empty())
-            outnames->append(dname.c_str(), dname.length()+1);
+            outnames.append(dname.c_str(), dname.length()+1);
     };
     switch(type)
     {
-        case DevProbe::Playback:
-            ProbePlaybackDevices();
-            std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
-            break;
-
-        case DevProbe::Capture:
-            ProbeCaptureDevices();
-            std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
-            break;
+    case BackendType::Playback:
+        ProbePlaybackDevices();
+        std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
+        break;
+
+    case BackendType::Capture:
+        ProbeCaptureDevices();
+        std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
+        break;
     }
+    return outnames;
 }
 
-BackendPtr WinMMBackendFactory::createBackend(ALCdevice *device, BackendType type)
+BackendPtr WinMMBackendFactory::createBackend(DeviceBase *device, BackendType type)
 {
     if(type == BackendType::Playback)
         return BackendPtr{new WinMMPlayback{device}};
diff --git a/alc/backends/winmm.h b/alc/backends/winmm.h
index e357ec19..45a706aa 100644
--- a/alc/backends/winmm.h
+++ b/alc/backends/winmm.h
@@ -1,7 +1,7 @@
 #ifndef BACKENDS_WINMM_H
 #define BACKENDS_WINMM_H
 
-#include "backends/base.h"
+#include "base.h"
 
 struct WinMMBackendFactory final : public BackendFactory {
 public:
@@ -9,9 +9,9 @@ public:
 
     bool querySupport(BackendType type) override;
 
-    void probe(DevProbe type, std::string *outnames) override;
+    std::string probe(BackendType type) override;
 
-    BackendPtr createBackend(ALCdevice *device, BackendType type) override;
+    BackendPtr createBackend(DeviceBase *device, BackendType type) override;
 
     static BackendFactory &getFactory();
 };
diff --git a/alc/bformatdec.cpp b/alc/bformatdec.cpp
deleted file mode 100644
index 9fbe32b8..00000000
--- a/alc/bformatdec.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-
-#include "config.h"
-
-#include "bformatdec.h"
-
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cmath>
-#include <iterator>
-#include <numeric>
-
-#include "AL/al.h"
-
-#include "almalloc.h"
-#include "alu.h"
-#include "ambdec.h"
-#include "filters/splitter.h"
-#include "opthelpers.h"
-
-
-namespace {
-
-constexpr ALfloat Ambi3DDecoderHFScale[MAX_AMBI_ORDER+1] = {
-    1.00000000e+00f, 1.00000000e+00f
-};
-constexpr ALfloat Ambi3DDecoderHFScale2O[MAX_AMBI_ORDER+1] = {
-    7.45355990e-01f, 1.00000000e+00f
-};
-constexpr ALfloat Ambi3DDecoderHFScale3O[MAX_AMBI_ORDER+1] = {
-    5.89792205e-01f, 8.79693856e-01f
-};
-
-inline auto GetDecoderHFScales(ALuint order) noexcept -> const ALfloat(&)[MAX_AMBI_ORDER+1]
-{
-    if(order >= 3) return Ambi3DDecoderHFScale3O;
-    if(order == 2) return Ambi3DDecoderHFScale2O;
-    return Ambi3DDecoderHFScale;
-}
-
-inline auto GetAmbiScales(AmbDecScale scaletype) noexcept -> const std::array<float,MAX_AMBI_CHANNELS>&
-{
-    if(scaletype == AmbDecScale::FuMa) return AmbiScale::FromFuMa;
-    if(scaletype == AmbDecScale::SN3D) return AmbiScale::FromSN3D;
-    return AmbiScale::FromN3D;
-}
-
-} // namespace
-
-
-BFormatDec::BFormatDec(const AmbDecConf *conf, const bool allow_2band, const ALuint inchans,
-    const ALuint srate, const ALuint (&chanmap)[MAX_OUTPUT_CHANNELS])
-{
-    mDualBand = allow_2band && (conf->FreqBands == 2);
-    if(!mDualBand)
-        mSamples.resize(2);
-    else
-    {
-        ASSUME(inchans > 0);
-        mSamples.resize(inchans * 2);
-        mSamplesHF = mSamples.data();
-        mSamplesLF = mSamplesHF + inchans;
-    }
-    mNumChannels = inchans;
-
-    mEnabled = std::accumulate(std::begin(chanmap), std::begin(chanmap)+conf->Speakers.size(), 0u,
-        [](ALuint mask, const ALuint &chan) noexcept -> ALuint
-        { return mask | (1 << chan); }
-    );
-
-    const ALfloat xover_norm{conf->XOverFreq / static_cast<float>(srate)};
-
-    const bool periphonic{(conf->ChanMask&AMBI_PERIPHONIC_MASK) != 0};
-    const std::array<float,MAX_AMBI_CHANNELS> &coeff_scale = GetAmbiScales(conf->CoeffScale);
-    const size_t coeff_count{periphonic ? MAX_AMBI_CHANNELS : MAX_AMBI2D_CHANNELS};
-
-    if(!mDualBand)
-    {
-        for(size_t i{0u};i < conf->Speakers.size();i++)
-        {
-            ALfloat (&mtx)[MAX_AMBI_CHANNELS] = mMatrix.Single[chanmap[i]];
-            for(size_t j{0},k{0};j < coeff_count;j++)
-            {
-                const size_t l{periphonic ? j : AmbiIndex::From2D[j]};
-                if(!(conf->ChanMask&(1u<<l))) continue;
-                mtx[j] = conf->HFMatrix[i][k] / coeff_scale[l] *
-                    ((l>=9) ? conf->HFOrderGain[3] :
-                    (l>=4) ? conf->HFOrderGain[2] :
-                    (l>=1) ? conf->HFOrderGain[1] : conf->HFOrderGain[0]);
-                ++k;
-            }
-        }
-    }
-    else
-    {
-        mXOver[0].init(xover_norm);
-        std::fill(std::begin(mXOver)+1, std::end(mXOver), mXOver[0]);
-
-        const float ratio{std::pow(10.0f, conf->XOverRatio / 40.0f)};
-        for(size_t i{0u};i < conf->Speakers.size();i++)
-        {
-            ALfloat (&mtx)[sNumBands][MAX_AMBI_CHANNELS] = mMatrix.Dual[chanmap[i]];
-            for(size_t j{0},k{0};j < coeff_count;j++)
-            {
-                const size_t l{periphonic ? j : AmbiIndex::From2D[j]};
-                if(!(conf->ChanMask&(1u<<l))) continue;
-                mtx[sHFBand][j] = conf->HFMatrix[i][k] / coeff_scale[l] *
-                    ((l>=9) ? conf->HFOrderGain[3] :
-                    (l>=4) ? conf->HFOrderGain[2] :
-                    (l>=1) ? conf->HFOrderGain[1] : conf->HFOrderGain[0]) * ratio;
-                mtx[sLFBand][j] = conf->LFMatrix[i][k] / coeff_scale[l] *
-                    ((l>=9) ? conf->LFOrderGain[3] :
-                    (l>=4) ? conf->LFOrderGain[2] :
-                    (l>=1) ? conf->LFOrderGain[1] : conf->LFOrderGain[0]) / ratio;
-                ++k;
-            }
-        }
-    }
-}
-
-BFormatDec::BFormatDec(const ALuint inchans, const ALsizei chancount,
-    const ChannelDec (&chancoeffs)[MAX_OUTPUT_CHANNELS],
-    const ALuint (&chanmap)[MAX_OUTPUT_CHANNELS])
-{
-    mSamples.resize(2);
-    mNumChannels = inchans;
-
-    ASSUME(chancount > 0);
-    mEnabled = std::accumulate(std::begin(chanmap), std::begin(chanmap)+chancount, 0u,
-        [](ALuint mask, const ALuint &chan) noexcept -> ALuint
-        { return mask | (1 << chan); }
-    );
-
-    const ChannelDec *incoeffs{chancoeffs};
-    auto set_coeffs = [this,inchans,&incoeffs](const ALuint chanidx) noexcept -> void
-    {
-        ALfloat (&mtx)[MAX_AMBI_CHANNELS] = mMatrix.Single[chanidx];
-        const ALfloat (&coeffs)[MAX_AMBI_CHANNELS] = *(incoeffs++);
-
-        ASSUME(inchans > 0);
-        std::copy_n(std::begin(coeffs), inchans, std::begin(mtx));
-    };
-    std::for_each(chanmap, chanmap+chancount, set_coeffs);
-}
-
-
-void BFormatDec::process(const al::span<FloatBufferLine> OutBuffer,
-    const FloatBufferLine *InSamples, const size_t SamplesToDo)
-{
-    ASSUME(SamplesToDo > 0);
-
-    if(mDualBand)
-    {
-        for(ALuint i{0};i < mNumChannels;i++)
-            mXOver[i].process(mSamplesHF[i].data(), mSamplesLF[i].data(), InSamples[i].data(),
-                SamplesToDo);
-
-        ALfloat (*mixmtx)[sNumBands][MAX_AMBI_CHANNELS]{mMatrix.Dual};
-        ALuint enabled{mEnabled};
-        for(FloatBufferLine &outbuf : OutBuffer)
-        {
-            if LIKELY(enabled&1)
-            {
-                const al::span<float> outspan{outbuf.data(), SamplesToDo};
-                MixRowSamples(outspan, {(*mixmtx)[sHFBand], mNumChannels}, mSamplesHF->data(),
-                    mSamplesHF->size());
-                MixRowSamples(outspan, {(*mixmtx)[sLFBand], mNumChannels}, mSamplesLF->data(),
-                    mSamplesLF->size());
-            }
-            ++mixmtx;
-            enabled >>= 1;
-        }
-    }
-    else
-    {
-        ALfloat (*mixmtx)[MAX_AMBI_CHANNELS]{mMatrix.Single};
-        ALuint enabled{mEnabled};
-        for(FloatBufferLine &outbuf : OutBuffer)
-        {
-            if LIKELY(enabled&1)
-                MixRowSamples({outbuf.data(), SamplesToDo}, {*mixmtx, mNumChannels},
-                    InSamples->data(), InSamples->size());
-            ++mixmtx;
-            enabled >>= 1;
-        }
-    }
-}
-
-
-std::array<ALfloat,MAX_AMBI_ORDER+1> BFormatDec::GetHFOrderScales(const ALuint in_order, const ALuint out_order) noexcept
-{
-    std::array<ALfloat,MAX_AMBI_ORDER+1> ret{};
-
-    assert(out_order >= in_order);
-
-    const ALfloat (&target)[MAX_AMBI_ORDER+1] = GetDecoderHFScales(out_order);
-    const ALfloat (&input)[MAX_AMBI_ORDER+1] = GetDecoderHFScales(in_order);
-
-    for(ALuint i{0};i < in_order+1;++i)
-        ret[i] = input[i] / target[i];
-
-    return ret;
-}
diff --git a/alc/bformatdec.h b/alc/bformatdec.h
deleted file mode 100644
index edbb6d50..00000000
--- a/alc/bformatdec.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef BFORMATDEC_H
-#define BFORMATDEC_H
-
-#include <array>
-#include <cstddef>
-
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "almalloc.h"
-#include "alspan.h"
-#include "ambidefs.h"
-#include "devformat.h"
-#include "filters/splitter.h"
-#include "vector.h"
-
-struct AmbDecConf;
-
-
-using ChannelDec = ALfloat[MAX_AMBI_CHANNELS];
-
-class BFormatDec {
-    static constexpr size_t sHFBand{0};
-    static constexpr size_t sLFBand{1};
-    static constexpr size_t sNumBands{2};
-
-    bool mDualBand{false};
-    ALuint mEnabled{0u}; /* Bitfield of enabled channels. */
-
-    ALuint mNumChannels{0u};
-    union MatrixU {
-        ALfloat Dual[MAX_OUTPUT_CHANNELS][sNumBands][MAX_AMBI_CHANNELS];
-        ALfloat Single[MAX_OUTPUT_CHANNELS][MAX_AMBI_CHANNELS];
-    } mMatrix{};
-
-    /* NOTE: BandSplitter filters are unused with single-band decoding */
-    BandSplitter mXOver[MAX_AMBI_CHANNELS];
-
-    al::vector<FloatBufferLine, 16> mSamples;
-    /* These two alias into Samples */
-    FloatBufferLine *mSamplesHF{nullptr};
-    FloatBufferLine *mSamplesLF{nullptr};
-
-public:
-    BFormatDec(const AmbDecConf *conf, const bool allow_2band, const ALuint inchans,
-        const ALuint srate, const ALuint (&chanmap)[MAX_OUTPUT_CHANNELS]);
-    BFormatDec(const ALuint inchans, const ALsizei chancount,
-        const ChannelDec (&chancoeffs)[MAX_OUTPUT_CHANNELS],
-        const ALuint (&chanmap)[MAX_OUTPUT_CHANNELS]);
-
-    /* Decodes the ambisonic input to the given output channels. */
-    void process(const al::span<FloatBufferLine> OutBuffer, const FloatBufferLine *InSamples,
-        const size_t SamplesToDo);
-
-    /* Retrieves per-order HF scaling factors for "upsampling" ambisonic data. */
-    static std::array<ALfloat,MAX_AMBI_ORDER+1> GetHFOrderScales(const ALuint in_order,
-        const ALuint out_order) noexcept;
-
-    DEF_NEWDEL(BFormatDec)
-};
-
-#endif /* BFORMATDEC_H */
diff --git a/alc/compat.h b/alc/compat.h
deleted file mode 100644
index 960b4b94..00000000
--- a/alc/compat.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef AL_COMPAT_H
-#define AL_COMPAT_H
-
-#include <string>
-
-struct PathNamePair { std::string path, fname; };
-const PathNamePair &GetProcBinary(void);
-
-#endif /* AL_COMPAT_H */
diff --git a/alc/context.cpp b/alc/context.cpp
new file mode 100644
index 00000000..e02c549b
--- /dev/null
+++ b/alc/context.cpp
@@ -0,0 +1,1105 @@
+
+#include "config.h"
+
+#include "context.h"
+
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <numeric>
+#include <stddef.h>
+#include <stdexcept>
+
+#include "AL/efx.h"
+
+#include "al/auxeffectslot.h"
+#include "al/source.h"
+#include "al/effect.h"
+#include "al/event.h"
+#include "al/listener.h"
+#include "albit.h"
+#include "alc/alu.h"
+#include "core/async_event.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/logging.h"
+#include "core/voice.h"
+#include "core/voice_change.h"
+#include "device.h"
+#include "ringbuffer.h"
+#include "vecmat.h"
+
+#ifdef ALSOFT_EAX
+#include <cstring>
+#include "alstring.h"
+#include "al/eax/globals.h"
+#endif // ALSOFT_EAX
+
+namespace {
+
+using namespace std::placeholders;
+
+using voidp = void*;
+
+/* Default context extensions */
+constexpr ALchar alExtList[] =
+    "AL_EXT_ALAW "
+    "AL_EXT_BFORMAT "
+    "AL_EXT_DOUBLE "
+    "AL_EXT_EXPONENT_DISTANCE "
+    "AL_EXT_FLOAT32 "
+    "AL_EXT_IMA4 "
+    "AL_EXT_LINEAR_DISTANCE "
+    "AL_EXT_MCFORMATS "
+    "AL_EXT_MULAW "
+    "AL_EXT_MULAW_BFORMAT "
+    "AL_EXT_MULAW_MCFORMATS "
+    "AL_EXT_OFFSET "
+    "AL_EXT_source_distance_model "
+    "AL_EXT_SOURCE_RADIUS "
+    "AL_EXT_STATIC_BUFFER "
+    "AL_EXT_STEREO_ANGLES "
+    "AL_LOKI_quadriphonic "
+    "AL_SOFT_bformat_ex "
+    "AL_SOFTX_bformat_hoa "
+    "AL_SOFT_block_alignment "
+    "AL_SOFT_buffer_length_query "
+    "AL_SOFT_callback_buffer "
+    "AL_SOFTX_convolution_reverb "
+    "AL_SOFT_deferred_updates "
+    "AL_SOFT_direct_channels "
+    "AL_SOFT_direct_channels_remix "
+    "AL_SOFT_effect_target "
+    "AL_SOFT_events "
+    "AL_SOFT_gain_clamp_ex "
+    "AL_SOFTX_hold_on_disconnect "
+    "AL_SOFT_loop_points "
+    "AL_SOFTX_map_buffer "
+    "AL_SOFT_MSADPCM "
+    "AL_SOFT_source_latency "
+    "AL_SOFT_source_length "
+    "AL_SOFT_source_resampler "
+    "AL_SOFT_source_spatialize "
+    "AL_SOFT_source_start_delay "
+    "AL_SOFT_UHJ "
+    "AL_SOFT_UHJ_ex";
+
+} // namespace
+
+
+std::atomic<bool> ALCcontext::sGlobalContextLock{false};
+std::atomic<ALCcontext*> ALCcontext::sGlobalContext{nullptr};
+
+thread_local ALCcontext *ALCcontext::sLocalContext{nullptr};
+ALCcontext::ThreadCtx::~ThreadCtx()
+{
+    if(ALCcontext *ctx{ALCcontext::sLocalContext})
+    {
+        const bool result{ctx->releaseIfNoDelete()};
+        ERR("Context %p current for thread being destroyed%s!\n", voidp{ctx},
+            result ? "" : ", leak detected");
+    }
+}
+thread_local ALCcontext::ThreadCtx ALCcontext::sThreadContext;
+
+ALeffect ALCcontext::sDefaultEffect;
+
+
+#ifdef __MINGW32__
+ALCcontext *ALCcontext::getThreadContext() noexcept
+{ return sLocalContext; }
+void ALCcontext::setThreadContext(ALCcontext *context) noexcept
+{ sThreadContext.set(context); }
+#endif
+
+ALCcontext::ALCcontext(al::intrusive_ptr<ALCdevice> device)
+  : ContextBase{device.get()}, mALDevice{std::move(device)}
+{
+}
+
+ALCcontext::~ALCcontext()
+{
+    TRACE("Freeing context %p\n", voidp{this});
+
+    size_t count{std::accumulate(mSourceList.cbegin(), mSourceList.cend(), size_t{0u},
+        [](size_t cur, const SourceSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); })};
+    if(count > 0)
+        WARN("%zu Source%s not deleted\n", count, (count==1)?"":"s");
+    mSourceList.clear();
+    mNumSources = 0;
+
+#ifdef ALSOFT_EAX
+    eaxUninitialize();
+#endif // ALSOFT_EAX
+
+    mDefaultSlot = nullptr;
+    count = std::accumulate(mEffectSlotList.cbegin(), mEffectSlotList.cend(), size_t{0u},
+        [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); });
+    if(count > 0)
+        WARN("%zu AuxiliaryEffectSlot%s not deleted\n", count, (count==1)?"":"s");
+    mEffectSlotList.clear();
+    mNumEffectSlots = 0;
+}
+
+void ALCcontext::init()
+{
+    if(sDefaultEffect.type != AL_EFFECT_NULL && mDevice->Type == DeviceType::Playback)
+    {
+        mDefaultSlot = std::make_unique<ALeffectslot>(this);
+        aluInitEffectPanning(mDefaultSlot->mSlot, this);
+    }
+
+    EffectSlotArray *auxslots;
+    if(!mDefaultSlot)
+        auxslots = EffectSlot::CreatePtrArray(0);
+    else
+    {
+        auxslots = EffectSlot::CreatePtrArray(1);
+        (*auxslots)[0] = mDefaultSlot->mSlot;
+        mDefaultSlot->mState = SlotState::Playing;
+    }
+    mActiveAuxSlots.store(auxslots, std::memory_order_relaxed);
+
+    allocVoiceChanges();
+    {
+        VoiceChange *cur{mVoiceChangeTail};
+        while(VoiceChange *next{cur->mNext.load(std::memory_order_relaxed)})
+            cur = next;
+        mCurrentVoiceChange.store(cur, std::memory_order_relaxed);
+    }
+
+    mExtensionList = alExtList;
+
+    if(sBufferSubDataCompat)
+    {
+        std::string extlist{mExtensionList};
+
+        const auto pos = extlist.find("AL_EXT_SOURCE_RADIUS ");
+        if(pos != std::string::npos)
+            extlist.replace(pos, 20, "AL_SOFT_buffer_sub_data");
+        else
+            extlist += " AL_SOFT_buffer_sub_data";
+
+        mExtensionListOverride = std::move(extlist);
+        mExtensionList = mExtensionListOverride.c_str();
+    }
+
+#ifdef ALSOFT_EAX
+    eax_initialize_extensions();
+#endif // ALSOFT_EAX
+
+    mParams.Position = alu::Vector{0.0f, 0.0f, 0.0f, 1.0f};
+    mParams.Matrix = alu::Matrix::Identity();
+    mParams.Velocity = alu::Vector{};
+    mParams.Gain = mListener.Gain;
+    mParams.MetersPerUnit = mListener.mMetersPerUnit;
+    mParams.AirAbsorptionGainHF = mAirAbsorptionGainHF;
+    mParams.DopplerFactor = mDopplerFactor;
+    mParams.SpeedOfSound = mSpeedOfSound * mDopplerVelocity;
+    mParams.SourceDistanceModel = mSourceDistanceModel;
+    mParams.mDistanceModel = mDistanceModel;
+
+
+    mAsyncEvents = RingBuffer::Create(511, sizeof(AsyncEvent), false);
+    StartEventThrd(this);
+
+
+    allocVoices(256);
+    mActiveVoiceCount.store(64, std::memory_order_relaxed);
+}
+
+bool ALCcontext::deinit()
+{
+    if(sLocalContext == this)
+    {
+        WARN("%p released while current on thread\n", voidp{this});
+        sThreadContext.set(nullptr);
+        dec_ref();
+    }
+
+    ALCcontext *origctx{this};
+    if(sGlobalContext.compare_exchange_strong(origctx, nullptr))
+    {
+        while(sGlobalContextLock.load()) {
+            /* Wait to make sure another thread didn't get the context and is
+             * trying to increment its refcount.
+             */
+        }
+        dec_ref();
+    }
+
+    bool ret{};
+    /* First make sure this context exists in the device's list. */
+    auto *oldarray = mDevice->mContexts.load(std::memory_order_acquire);
+    if(auto toremove = static_cast<size_t>(std::count(oldarray->begin(), oldarray->end(), this)))
+    {
+        using ContextArray = al::FlexArray<ContextBase*>;
+        auto alloc_ctx_array = [](const size_t count) -> ContextArray*
+        {
+            if(count == 0) return &DeviceBase::sEmptyContextArray;
+            return ContextArray::Create(count).release();
+        };
+        auto *newarray = alloc_ctx_array(oldarray->size() - toremove);
+
+        /* Copy the current/old context handles to the new array, excluding the
+         * given context.
+         */
+        std::copy_if(oldarray->begin(), oldarray->end(), newarray->begin(),
+            [this](ContextBase *ctx) { return ctx != this; });
+
+        /* Store the new context array in the device. Wait for any current mix
+         * to finish before deleting the old array.
+         */
+        mDevice->mContexts.store(newarray);
+        if(oldarray != &DeviceBase::sEmptyContextArray)
+        {
+            mDevice->waitForMix();
+            delete oldarray;
+        }
+
+        ret = !newarray->empty();
+    }
+    else
+        ret = !oldarray->empty();
+
+    StopEventThrd(this);
+
+    return ret;
+}
+
+void ALCcontext::applyAllUpdates()
+{
+    /* Tell the mixer to stop applying updates, then wait for any active
+     * updating to finish, before providing updates.
+     */
+    mHoldUpdates.store(true, std::memory_order_release);
+    while((mUpdateCount.load(std::memory_order_acquire)&1) != 0) {
+        /* busy-wait */
+    }
+
+#ifdef ALSOFT_EAX
+    if(mEaxNeedsCommit)
+        eaxCommit();
+#endif
+
+    if(std::exchange(mPropsDirty, false))
+        UpdateContextProps(this);
+    UpdateAllEffectSlotProps(this);
+    UpdateAllSourceProps(this);
+
+    /* Now with all updates declared, let the mixer continue applying them so
+     * they all happen at once.
+     */
+    mHoldUpdates.store(false, std::memory_order_release);
+}
+
+#ifdef ALSOFT_EAX
+namespace {
+
+template<typename F>
+void ForEachSource(ALCcontext *context, F func)
+{
+    for(auto &sublist : context->mSourceList)
+    {
+        uint64_t usemask{~sublist.FreeMask};
+        while(usemask)
+        {
+            const int idx{al::countr_zero(usemask)};
+            usemask &= ~(1_u64 << idx);
+
+            func(sublist.Sources[idx]);
+        }
+    }
+}
+
+} // namespace
+
+
+bool ALCcontext::eaxIsCapable() const noexcept
+{
+    return eax_has_enough_aux_sends();
+}
+
+void ALCcontext::eaxUninitialize() noexcept
+{
+    if(!mEaxIsInitialized)
+        return;
+
+    mEaxIsInitialized = false;
+    mEaxIsTried = false;
+    mEaxFxSlots.uninitialize();
+}
+
+ALenum ALCcontext::eax_eax_set(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size)
+{
+    const auto call = create_eax_call(
+        EaxCallType::set,
+        property_set_id,
+        property_id,
+        property_source_id,
+        property_value,
+        property_value_size);
+
+    eax_initialize();
+
+    switch(call.get_property_set_id())
+    {
+    case EaxCallPropertySetId::context:
+        eax_set(call);
+        break;
+    case EaxCallPropertySetId::fx_slot:
+    case EaxCallPropertySetId::fx_slot_effect:
+        eax_dispatch_fx_slot(call);
+        break;
+    case EaxCallPropertySetId::source:
+        eax_dispatch_source(call);
+        break;
+    default:
+        eax_fail_unknown_property_set_id();
+    }
+    mEaxNeedsCommit = true;
+
+    if(!call.is_deferred())
+    {
+        eaxCommit();
+        if(!mDeferUpdates)
+            applyAllUpdates();
+    }
+
+    return AL_NO_ERROR;
+}
+
+ALenum ALCcontext::eax_eax_get(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size)
+{
+    const auto call = create_eax_call(
+        EaxCallType::get,
+        property_set_id,
+        property_id,
+        property_source_id,
+        property_value,
+        property_value_size);
+
+    eax_initialize();
+
+    switch(call.get_property_set_id())
+    {
+    case EaxCallPropertySetId::context:
+        eax_get(call);
+        break;
+    case EaxCallPropertySetId::fx_slot:
+    case EaxCallPropertySetId::fx_slot_effect:
+        eax_dispatch_fx_slot(call);
+        break;
+    case EaxCallPropertySetId::source:
+        eax_dispatch_source(call);
+        break;
+    default:
+        eax_fail_unknown_property_set_id();
+    }
+
+    return AL_NO_ERROR;
+}
+
+void ALCcontext::eaxSetLastError() noexcept
+{
+    mEaxLastError = EAXERR_INVALID_OPERATION;
+}
+
+[[noreturn]] void ALCcontext::eax_fail(const char* message)
+{
+    throw ContextException{message};
+}
+
+[[noreturn]] void ALCcontext::eax_fail_unknown_property_set_id()
+{
+    eax_fail("Unknown property ID.");
+}
+
+[[noreturn]] void ALCcontext::eax_fail_unknown_primary_fx_slot_id()
+{
+    eax_fail("Unknown primary FX Slot ID.");
+}
+
+[[noreturn]] void ALCcontext::eax_fail_unknown_property_id()
+{
+    eax_fail("Unknown property ID.");
+}
+
+[[noreturn]] void ALCcontext::eax_fail_unknown_version()
+{
+    eax_fail("Unknown version.");
+}
+
+void ALCcontext::eax_initialize_extensions()
+{
+    if(!eax_g_is_enabled)
+        return;
+
+    const auto string_max_capacity =
+        std::strlen(mExtensionList) + 1 +
+        std::strlen(eax1_ext_name) + 1 +
+        std::strlen(eax2_ext_name) + 1 +
+        std::strlen(eax3_ext_name) + 1 +
+        std::strlen(eax4_ext_name) + 1 +
+        std::strlen(eax5_ext_name) + 1 +
+        std::strlen(eax_x_ram_ext_name) + 1;
+
+    std::string extlist;
+    extlist.reserve(string_max_capacity);
+
+    if(eaxIsCapable())
+    {
+        extlist += eax1_ext_name;
+        extlist += ' ';
+
+        extlist += eax2_ext_name;
+        extlist += ' ';
+
+        extlist += eax3_ext_name;
+        extlist += ' ';
+
+        extlist += eax4_ext_name;
+        extlist += ' ';
+
+        extlist += eax5_ext_name;
+        extlist += ' ';
+    }
+
+    extlist += eax_x_ram_ext_name;
+    extlist += ' ';
+
+    extlist += mExtensionList;
+
+    mExtensionListOverride = std::move(extlist);
+    mExtensionList = mExtensionListOverride.c_str();
+}
+
+void ALCcontext::eax_initialize()
+{
+    if(mEaxIsInitialized)
+        return;
+
+    if(mEaxIsTried)
+        eax_fail("No EAX.");
+
+    mEaxIsTried = true;
+
+    if(!eax_g_is_enabled)
+        eax_fail("EAX disabled by a configuration.");
+
+    eax_ensure_compatibility();
+    eax_set_defaults();
+    eax_context_commit_air_absorbtion_hf();
+    eax_update_speaker_configuration();
+    eax_initialize_fx_slots();
+
+    mEaxIsInitialized = true;
+}
+
+bool ALCcontext::eax_has_no_default_effect_slot() const noexcept
+{
+    return mDefaultSlot == nullptr;
+}
+
+void ALCcontext::eax_ensure_no_default_effect_slot() const
+{
+    if(!eax_has_no_default_effect_slot())
+        eax_fail("There is a default effect slot in the context.");
+}
+
+bool ALCcontext::eax_has_enough_aux_sends() const noexcept
+{
+    return mALDevice->NumAuxSends >= EAX_MAX_FXSLOTS;
+}
+
+void ALCcontext::eax_ensure_enough_aux_sends() const
+{
+    if(!eax_has_enough_aux_sends())
+        eax_fail("Not enough aux sends.");
+}
+
+void ALCcontext::eax_ensure_compatibility()
+{
+    eax_ensure_enough_aux_sends();
+}
+
+unsigned long ALCcontext::eax_detect_speaker_configuration() const
+{
+#define EAX_PREFIX "[EAX_DETECT_SPEAKER_CONFIG]"
+
+    switch(mDevice->FmtChans)
+    {
+    case DevFmtMono: return SPEAKERS_2;
+    case DevFmtStereo:
+        /* Pretend 7.1 if using UHJ output, since they both provide full
+         * horizontal surround.
+         */
+        if(mDevice->mUhjEncoder)
+            return SPEAKERS_7;
+        if(mDevice->Flags.test(DirectEar))
+            return HEADPHONES;
+        return SPEAKERS_2;
+    case DevFmtQuad: return SPEAKERS_4;
+    case DevFmtX51: return SPEAKERS_5;
+    case DevFmtX61: return SPEAKERS_6;
+    case DevFmtX71: return SPEAKERS_7;
+    /* 7.1.4 is compatible with 7.1. This could instead be HEADPHONES to
+     * suggest with-height surround sound (like HRTF).
+     */
+    case DevFmtX714: return SPEAKERS_7;
+    /* 3D7.1 is only compatible with 5.1. This could instead be HEADPHONES to
+     * suggest full-sphere surround sound (like HRTF).
+     */
+    case DevFmtX3D71: return SPEAKERS_5;
+    /* This could also be HEADPHONES, since headphones-based HRTF and Ambi3D
+     * provide full-sphere surround sound. Depends if apps are more likely to
+     * consider headphones or 7.1 for surround sound support.
+     */
+    case DevFmtAmbi3D: return SPEAKERS_7;
+    }
+    ERR(EAX_PREFIX "Unexpected device channel format 0x%x.\n", mDevice->FmtChans);
+    return HEADPHONES;
+
+#undef EAX_PREFIX
+}
+
+void ALCcontext::eax_update_speaker_configuration()
+{
+    mEaxSpeakerConfig = eax_detect_speaker_configuration();
+}
+
+void ALCcontext::eax_set_last_error_defaults() noexcept
+{
+    mEaxLastError = EAX_OK;
+}
+
+void ALCcontext::eax_session_set_defaults() noexcept
+{
+    mEaxSession.ulEAXVersion = EAXCONTEXT_DEFAULTEAXSESSION;
+    mEaxSession.ulMaxActiveSends = EAXCONTEXT_DEFAULTMAXACTIVESENDS;
+}
+
+void ALCcontext::eax4_context_set_defaults(Eax4Props& props) noexcept
+{
+    props.guidPrimaryFXSlotID = EAX40CONTEXT_DEFAULTPRIMARYFXSLOTID;
+    props.flDistanceFactor = EAXCONTEXT_DEFAULTDISTANCEFACTOR;
+    props.flAirAbsorptionHF = EAXCONTEXT_DEFAULTAIRABSORPTIONHF;
+    props.flHFReference = EAXCONTEXT_DEFAULTHFREFERENCE;
+}
+
+void ALCcontext::eax4_context_set_defaults(Eax4State& state) noexcept
+{
+    eax4_context_set_defaults(state.i);
+    state.d = state.i;
+}
+
+void ALCcontext::eax5_context_set_defaults(Eax5Props& props) noexcept
+{
+    props.guidPrimaryFXSlotID = EAX50CONTEXT_DEFAULTPRIMARYFXSLOTID;
+    props.flDistanceFactor = EAXCONTEXT_DEFAULTDISTANCEFACTOR;
+    props.flAirAbsorptionHF = EAXCONTEXT_DEFAULTAIRABSORPTIONHF;
+    props.flHFReference = EAXCONTEXT_DEFAULTHFREFERENCE;
+    props.flMacroFXFactor = EAXCONTEXT_DEFAULTMACROFXFACTOR;
+}
+
+void ALCcontext::eax5_context_set_defaults(Eax5State& state) noexcept
+{
+    eax5_context_set_defaults(state.i);
+    state.d = state.i;
+}
+
+void ALCcontext::eax_context_set_defaults()
+{
+    eax5_context_set_defaults(mEax123);
+    eax4_context_set_defaults(mEax4);
+    eax5_context_set_defaults(mEax5);
+    mEax = mEax5.i;
+    mEaxVersion = 5;
+    mEaxDf = EaxDirtyFlags{};
+}
+
+void ALCcontext::eax_set_defaults()
+{
+    eax_set_last_error_defaults();
+    eax_session_set_defaults();
+    eax_context_set_defaults();
+}
+
+void ALCcontext::eax_dispatch_fx_slot(const EaxCall& call)
+{
+    const auto fx_slot_index = call.get_fx_slot_index();
+    if(!fx_slot_index.has_value())
+        eax_fail("Invalid fx slot index.");
+
+    auto& fx_slot = eaxGetFxSlot(*fx_slot_index);
+    if(fx_slot.eax_dispatch(call))
+    {
+        std::lock_guard<std::mutex> source_lock{mSourceLock};
+        ForEachSource(this, std::mem_fn(&ALsource::eaxMarkAsChanged));
+    }
+}
+
+void ALCcontext::eax_dispatch_source(const EaxCall& call)
+{
+    const auto source_id = call.get_property_al_name();
+    std::lock_guard<std::mutex> source_lock{mSourceLock};
+    const auto source = ALsource::EaxLookupSource(*this, source_id);
+
+    if (source == nullptr)
+        eax_fail("Source not found.");
+
+    source->eaxDispatch(call);
+}
+
+void ALCcontext::eax_get_misc(const EaxCall& call)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_NONE:
+        break;
+    case EAXCONTEXT_LASTERROR:
+        call.set_value<ContextException>(mEaxLastError);
+        break;
+    case EAXCONTEXT_SPEAKERCONFIG:
+        call.set_value<ContextException>(mEaxSpeakerConfig);
+        break;
+    case EAXCONTEXT_EAXSESSION:
+        call.set_value<ContextException>(mEaxSession);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+}
+
+void ALCcontext::eax4_get(const EaxCall& call, const Eax4Props& props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_ALLPARAMETERS:
+        call.set_value<ContextException>(props);
+        break;
+    case EAXCONTEXT_PRIMARYFXSLOTID:
+        call.set_value<ContextException>(props.guidPrimaryFXSlotID);
+        break;
+    case EAXCONTEXT_DISTANCEFACTOR:
+        call.set_value<ContextException>(props.flDistanceFactor);
+        break;
+    case EAXCONTEXT_AIRABSORPTIONHF:
+        call.set_value<ContextException>(props.flAirAbsorptionHF);
+        break;
+    case EAXCONTEXT_HFREFERENCE:
+        call.set_value<ContextException>(props.flHFReference);
+        break;
+    default:
+        eax_get_misc(call);
+        break;
+    }
+}
+
+void ALCcontext::eax5_get(const EaxCall& call, const Eax5Props& props)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_ALLPARAMETERS:
+        call.set_value<ContextException>(props);
+        break;
+    case EAXCONTEXT_PRIMARYFXSLOTID:
+        call.set_value<ContextException>(props.guidPrimaryFXSlotID);
+        break;
+    case EAXCONTEXT_DISTANCEFACTOR:
+        call.set_value<ContextException>(props.flDistanceFactor);
+        break;
+    case EAXCONTEXT_AIRABSORPTIONHF:
+        call.set_value<ContextException>(props.flAirAbsorptionHF);
+        break;
+    case EAXCONTEXT_HFREFERENCE:
+        call.set_value<ContextException>(props.flHFReference);
+        break;
+    case EAXCONTEXT_MACROFXFACTOR:
+        call.set_value<ContextException>(props.flMacroFXFactor);
+        break;
+    default:
+        eax_get_misc(call);
+        break;
+    }
+}
+
+void ALCcontext::eax_get(const EaxCall& call)
+{
+    switch(call.get_version())
+    {
+    case 4: eax4_get(call, mEax4.i); break;
+    case 5: eax5_get(call, mEax5.i); break;
+    default: eax_fail_unknown_version();
+    }
+}
+
+void ALCcontext::eax_context_commit_primary_fx_slot_id()
+{
+    mEaxPrimaryFxSlotIndex = mEax.guidPrimaryFXSlotID;
+}
+
+void ALCcontext::eax_context_commit_distance_factor()
+{
+    if(mListener.mMetersPerUnit == mEax.flDistanceFactor)
+        return;
+
+    mListener.mMetersPerUnit = mEax.flDistanceFactor;
+    mPropsDirty = true;
+}
+
+void ALCcontext::eax_context_commit_air_absorbtion_hf()
+{
+    const auto new_value = level_mb_to_gain(mEax.flAirAbsorptionHF);
+
+    if(mAirAbsorptionGainHF == new_value)
+        return;
+
+    mAirAbsorptionGainHF = new_value;
+    mPropsDirty = true;
+}
+
+void ALCcontext::eax_context_commit_hf_reference()
+{
+    // TODO
+}
+
+void ALCcontext::eax_context_commit_macro_fx_factor()
+{
+    // TODO
+}
+
+void ALCcontext::eax_initialize_fx_slots()
+{
+    mEaxFxSlots.initialize(*this);
+    mEaxPrimaryFxSlotIndex = mEax.guidPrimaryFXSlotID;
+}
+
+void ALCcontext::eax_update_sources()
+{
+    std::unique_lock<std::mutex> source_lock{mSourceLock};
+    auto update_source = [](ALsource &source)
+    { source.eaxCommit(); };
+    ForEachSource(this, update_source);
+}
+
+void ALCcontext::eax_set_misc(const EaxCall& call)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_NONE:
+        break;
+    case EAXCONTEXT_SPEAKERCONFIG:
+        eax_set<Eax5SpeakerConfigValidator>(call, mEaxSpeakerConfig);
+        break;
+    case EAXCONTEXT_EAXSESSION:
+        eax_set<Eax5SessionAllValidator>(call, mEaxSession);
+        break;
+    default:
+        eax_fail_unknown_property_id();
+    }
+}
+
+void ALCcontext::eax4_defer_all(const EaxCall& call, Eax4State& state)
+{
+    const auto& src = call.get_value<ContextException, const EAX40CONTEXTPROPERTIES>();
+    Eax4AllValidator{}(src);
+    const auto& dst_i = state.i;
+    auto& dst_d = state.d;
+    dst_d = src;
+
+    if(dst_i.guidPrimaryFXSlotID != dst_d.guidPrimaryFXSlotID)
+        mEaxDf |= eax_primary_fx_slot_id_dirty_bit;
+
+    if(dst_i.flDistanceFactor != dst_d.flDistanceFactor)
+        mEaxDf |= eax_distance_factor_dirty_bit;
+
+    if(dst_i.flAirAbsorptionHF != dst_d.flAirAbsorptionHF)
+        mEaxDf |= eax_air_absorption_hf_dirty_bit;
+
+    if(dst_i.flHFReference != dst_d.flHFReference)
+        mEaxDf |= eax_hf_reference_dirty_bit;
+}
+
+void ALCcontext::eax4_defer(const EaxCall& call, Eax4State& state)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_ALLPARAMETERS:
+        eax4_defer_all(call, state);
+        break;
+    case EAXCONTEXT_PRIMARYFXSLOTID:
+        eax_defer<Eax4PrimaryFxSlotIdValidator, eax_primary_fx_slot_id_dirty_bit>(
+            call, state, &EAX40CONTEXTPROPERTIES::guidPrimaryFXSlotID);
+        break;
+    case EAXCONTEXT_DISTANCEFACTOR:
+        eax_defer<Eax4DistanceFactorValidator, eax_distance_factor_dirty_bit>(
+            call, state, &EAX40CONTEXTPROPERTIES::flDistanceFactor);
+        break;
+    case EAXCONTEXT_AIRABSORPTIONHF:
+        eax_defer<Eax4AirAbsorptionHfValidator, eax_air_absorption_hf_dirty_bit>(
+            call, state, &EAX40CONTEXTPROPERTIES::flAirAbsorptionHF);
+        break;
+    case EAXCONTEXT_HFREFERENCE:
+        eax_defer<Eax4HfReferenceValidator, eax_hf_reference_dirty_bit>(
+            call, state, &EAX40CONTEXTPROPERTIES::flHFReference);
+        break;
+    default:
+        eax_set_misc(call);
+        break;
+    }
+}
+
+void ALCcontext::eax5_defer_all(const EaxCall& call, Eax5State& state)
+{
+    const auto& src = call.get_value<ContextException, const EAX50CONTEXTPROPERTIES>();
+    Eax4AllValidator{}(src);
+    const auto& dst_i = state.i;
+    auto& dst_d = state.d;
+    dst_d = src;
+
+    if(dst_i.guidPrimaryFXSlotID != dst_d.guidPrimaryFXSlotID)
+        mEaxDf |= eax_primary_fx_slot_id_dirty_bit;
+
+    if(dst_i.flDistanceFactor != dst_d.flDistanceFactor)
+        mEaxDf |= eax_distance_factor_dirty_bit;
+
+    if(dst_i.flAirAbsorptionHF != dst_d.flAirAbsorptionHF)
+        mEaxDf |= eax_air_absorption_hf_dirty_bit;
+
+    if(dst_i.flHFReference != dst_d.flHFReference)
+        mEaxDf |= eax_hf_reference_dirty_bit;
+
+    if(dst_i.flMacroFXFactor != dst_d.flMacroFXFactor)
+        mEaxDf |= eax_macro_fx_factor_dirty_bit;
+}
+
+void ALCcontext::eax5_defer(const EaxCall& call, Eax5State& state)
+{
+    switch(call.get_property_id())
+    {
+    case EAXCONTEXT_ALLPARAMETERS:
+        eax5_defer_all(call, state);
+        break;
+    case EAXCONTEXT_PRIMARYFXSLOTID:
+        eax_defer<Eax5PrimaryFxSlotIdValidator, eax_primary_fx_slot_id_dirty_bit>(
+            call, state, &EAX50CONTEXTPROPERTIES::guidPrimaryFXSlotID);
+        break;
+    case EAXCONTEXT_DISTANCEFACTOR:
+        eax_defer<Eax4DistanceFactorValidator, eax_distance_factor_dirty_bit>(
+            call, state, &EAX50CONTEXTPROPERTIES::flDistanceFactor);
+        break;
+    case EAXCONTEXT_AIRABSORPTIONHF:
+        eax_defer<Eax4AirAbsorptionHfValidator, eax_air_absorption_hf_dirty_bit>(
+            call, state, &EAX50CONTEXTPROPERTIES::flAirAbsorptionHF);
+        break;
+    case EAXCONTEXT_HFREFERENCE:
+        eax_defer<Eax4HfReferenceValidator, eax_hf_reference_dirty_bit>(
+            call, state, &EAX50CONTEXTPROPERTIES::flHFReference);
+        break;
+    case EAXCONTEXT_MACROFXFACTOR:
+        eax_defer<Eax5MacroFxFactorValidator, eax_macro_fx_factor_dirty_bit>(
+            call, state, &EAX50CONTEXTPROPERTIES::flMacroFXFactor);
+        break;
+    default:
+        eax_set_misc(call);
+        break;
+    }
+}
+
+void ALCcontext::eax_set(const EaxCall& call)
+{
+    const auto version = call.get_version();
+    switch(version)
+    {
+    case 4: eax4_defer(call, mEax4); break;
+    case 5: eax5_defer(call, mEax5); break;
+    default: eax_fail_unknown_version();
+    }
+    if(version != mEaxVersion)
+        mEaxDf = ~EaxDirtyFlags();
+    mEaxVersion = version;
+}
+
+void ALCcontext::eax4_context_commit(Eax4State& state, EaxDirtyFlags& dst_df)
+{
+    if(mEaxDf == EaxDirtyFlags{})
+        return;
+
+    eax_context_commit_property<eax_primary_fx_slot_id_dirty_bit>(
+        state, dst_df, &EAX40CONTEXTPROPERTIES::guidPrimaryFXSlotID);
+    eax_context_commit_property<eax_distance_factor_dirty_bit>(
+        state, dst_df, &EAX40CONTEXTPROPERTIES::flDistanceFactor);
+    eax_context_commit_property<eax_air_absorption_hf_dirty_bit>(
+        state, dst_df, &EAX40CONTEXTPROPERTIES::flAirAbsorptionHF);
+    eax_context_commit_property<eax_hf_reference_dirty_bit>(
+        state, dst_df, &EAX40CONTEXTPROPERTIES::flHFReference);
+
+    mEaxDf = EaxDirtyFlags{};
+}
+
+void ALCcontext::eax5_context_commit(Eax5State& state, EaxDirtyFlags& dst_df)
+{
+    if(mEaxDf == EaxDirtyFlags{})
+        return;
+
+    eax_context_commit_property<eax_primary_fx_slot_id_dirty_bit>(
+        state, dst_df, &EAX50CONTEXTPROPERTIES::guidPrimaryFXSlotID);
+    eax_context_commit_property<eax_distance_factor_dirty_bit>(
+        state, dst_df, &EAX50CONTEXTPROPERTIES::flDistanceFactor);
+    eax_context_commit_property<eax_air_absorption_hf_dirty_bit>(
+        state, dst_df, &EAX50CONTEXTPROPERTIES::flAirAbsorptionHF);
+    eax_context_commit_property<eax_hf_reference_dirty_bit>(
+        state, dst_df, &EAX50CONTEXTPROPERTIES::flHFReference);
+    eax_context_commit_property<eax_macro_fx_factor_dirty_bit>(
+        state, dst_df, &EAX50CONTEXTPROPERTIES::flMacroFXFactor);
+
+    mEaxDf = EaxDirtyFlags{};
+}
+
+void ALCcontext::eax_context_commit()
+{
+    auto dst_df = EaxDirtyFlags{};
+
+    switch(mEaxVersion)
+    {
+    case 1:
+    case 2:
+    case 3:
+        eax5_context_commit(mEax123, dst_df);
+        break;
+    case 4:
+        eax4_context_commit(mEax4, dst_df);
+        break;
+    case 5:
+        eax5_context_commit(mEax5, dst_df);
+        break;
+    }
+
+    if(dst_df == EaxDirtyFlags{})
+        return;
+
+    if((dst_df & eax_primary_fx_slot_id_dirty_bit) != EaxDirtyFlags{})
+        eax_context_commit_primary_fx_slot_id();
+
+    if((dst_df & eax_distance_factor_dirty_bit) != EaxDirtyFlags{})
+        eax_context_commit_distance_factor();
+
+    if((dst_df & eax_air_absorption_hf_dirty_bit) != EaxDirtyFlags{})
+        eax_context_commit_air_absorbtion_hf();
+
+    if((dst_df & eax_hf_reference_dirty_bit) != EaxDirtyFlags{})
+        eax_context_commit_hf_reference();
+
+    if((dst_df & eax_macro_fx_factor_dirty_bit) != EaxDirtyFlags{})
+        eax_context_commit_macro_fx_factor();
+
+    if((dst_df & eax_primary_fx_slot_id_dirty_bit) != EaxDirtyFlags{})
+        eax_update_sources();
+}
+
+void ALCcontext::eaxCommit()
+{
+    mEaxNeedsCommit = false;
+    eax_context_commit();
+    eaxCommitFxSlots();
+    eax_update_sources();
+}
+
+namespace {
+
+class EaxSetException : public EaxException {
+public:
+    explicit EaxSetException(const char* message)
+        : EaxException{"EAX_SET", message}
+    {}
+};
+
+[[noreturn]] void eax_fail_set(const char* message)
+{
+    throw EaxSetException{message};
+}
+
+class EaxGetException : public EaxException {
+public:
+    explicit EaxGetException(const char* message)
+        : EaxException{"EAX_GET", message}
+    {}
+};
+
+[[noreturn]] void eax_fail_get(const char* message)
+{
+    throw EaxGetException{message};
+}
+
+} // namespace
+
+
+FORCE_ALIGN ALenum AL_APIENTRY EAXSet(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size) noexcept
+try
+{
+    auto context = GetContextRef();
+
+    if(!context)
+        eax_fail_set("No current context.");
+
+    std::lock_guard<std::mutex> prop_lock{context->mPropLock};
+
+    return context->eax_eax_set(
+        property_set_id,
+        property_id,
+        property_source_id,
+        property_value,
+        property_value_size);
+}
+catch (...)
+{
+    eax_log_exception(__func__);
+    return AL_INVALID_OPERATION;
+}
+
+FORCE_ALIGN ALenum AL_APIENTRY EAXGet(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size) noexcept
+try
+{
+    auto context = GetContextRef();
+
+    if(!context)
+        eax_fail_get("No current context.");
+
+    std::lock_guard<std::mutex> prop_lock{context->mPropLock};
+
+    return context->eax_eax_get(
+        property_set_id,
+        property_id,
+        property_source_id,
+        property_value,
+        property_value_size);
+}
+catch (...)
+{
+    eax_log_exception(__func__);
+    return AL_INVALID_OPERATION;
+}
+#endif // ALSOFT_EAX
diff --git a/alc/context.h b/alc/context.h
new file mode 100644
index 00000000..e8efdbf1
--- /dev/null
+++ b/alc/context.h
@@ -0,0 +1,540 @@
+#ifndef ALC_CONTEXT_H
+#define ALC_CONTEXT_H
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <stdint.h>
+#include <utility>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "al/listener.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "atomic.h"
+#include "core/context.h"
+#include "intrusive_ptr.h"
+#include "vector.h"
+
+#ifdef ALSOFT_EAX
+#include "al/eax/call.h"
+#include "al/eax/exception.h"
+#include "al/eax/fx_slot_index.h"
+#include "al/eax/fx_slots.h"
+#include "al/eax/utils.h"
+#endif // ALSOFT_EAX
+
+struct ALeffect;
+struct ALeffectslot;
+struct ALsource;
+
+using uint = unsigned int;
+
+
+struct SourceSubList {
+    uint64_t FreeMask{~0_u64};
+    ALsource *Sources{nullptr}; /* 64 */
+
+    SourceSubList() noexcept = default;
+    SourceSubList(const SourceSubList&) = delete;
+    SourceSubList(SourceSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Sources{rhs.Sources}
+    { rhs.FreeMask = ~0_u64; rhs.Sources = nullptr; }
+    ~SourceSubList();
+
+    SourceSubList& operator=(const SourceSubList&) = delete;
+    SourceSubList& operator=(SourceSubList&& rhs) noexcept
+    { std::swap(FreeMask, rhs.FreeMask); std::swap(Sources, rhs.Sources); return *this; }
+};
+
+struct EffectSlotSubList {
+    uint64_t FreeMask{~0_u64};
+    ALeffectslot *EffectSlots{nullptr}; /* 64 */
+
+    EffectSlotSubList() noexcept = default;
+    EffectSlotSubList(const EffectSlotSubList&) = delete;
+    EffectSlotSubList(EffectSlotSubList&& rhs) noexcept
+      : FreeMask{rhs.FreeMask}, EffectSlots{rhs.EffectSlots}
+    { rhs.FreeMask = ~0_u64; rhs.EffectSlots = nullptr; }
+    ~EffectSlotSubList();
+
+    EffectSlotSubList& operator=(const EffectSlotSubList&) = delete;
+    EffectSlotSubList& operator=(EffectSlotSubList&& rhs) noexcept
+    { std::swap(FreeMask, rhs.FreeMask); std::swap(EffectSlots, rhs.EffectSlots); return *this; }
+};
+
+struct ALCcontext : public al::intrusive_ref<ALCcontext>, ContextBase {
+    const al::intrusive_ptr<ALCdevice> mALDevice;
+
+
+    bool mPropsDirty{true};
+    bool mDeferUpdates{false};
+
+    std::mutex mPropLock;
+
+    std::atomic<ALenum> mLastError{AL_NO_ERROR};
+
+    DistanceModel mDistanceModel{DistanceModel::Default};
+    bool mSourceDistanceModel{false};
+
+    float mDopplerFactor{1.0f};
+    float mDopplerVelocity{1.0f};
+    float mSpeedOfSound{SpeedOfSoundMetersPerSec};
+    float mAirAbsorptionGainHF{AirAbsorbGainHF};
+
+    std::mutex mEventCbLock;
+    ALEVENTPROCSOFT mEventCb{};
+    void *mEventParam{nullptr};
+
+    ALlistener mListener{};
+
+    al::vector<SourceSubList> mSourceList;
+    ALuint mNumSources{0};
+    std::mutex mSourceLock;
+
+    al::vector<EffectSlotSubList> mEffectSlotList;
+    ALuint mNumEffectSlots{0u};
+    std::mutex mEffectSlotLock;
+
+    /* Default effect slot */
+    std::unique_ptr<ALeffectslot> mDefaultSlot;
+
+    const char *mExtensionList{nullptr};
+
+    std::string mExtensionListOverride{};
+
+
+    ALCcontext(al::intrusive_ptr<ALCdevice> device);
+    ALCcontext(const ALCcontext&) = delete;
+    ALCcontext& operator=(const ALCcontext&) = delete;
+    ~ALCcontext();
+
+    void init();
+    /**
+     * Removes the context from its device and removes it from being current on
+     * the running thread or globally. Returns true if other contexts still
+     * exist on the device.
+     */
+    bool deinit();
+
+    /**
+     * Defers/suspends updates for the given context's listener and sources.
+     * This does *NOT* stop mixing, but rather prevents certain property
+     * changes from taking effect. mPropLock must be held when called.
+     */
+    void deferUpdates() noexcept { mDeferUpdates = true; }
+
+    /**
+     * Resumes update processing after being deferred. mPropLock must be held
+     * when called.
+     */
+    void processUpdates()
+    {
+        if(std::exchange(mDeferUpdates, false))
+            applyAllUpdates();
+    }
+
+    /**
+     * Applies all pending updates for the context, listener, effect slots, and
+     * sources.
+     */
+    void applyAllUpdates();
+
+#ifdef __USE_MINGW_ANSI_STDIO
+    [[gnu::format(gnu_printf, 3, 4)]]
+#else
+    [[gnu::format(printf, 3, 4)]]
+#endif
+    void setError(ALenum errorCode, const char *msg, ...);
+
+    /* Process-wide current context */
+    static std::atomic<bool> sGlobalContextLock;
+    static std::atomic<ALCcontext*> sGlobalContext;
+
+private:
+    /* Thread-local current context. */
+    static thread_local ALCcontext *sLocalContext;
+
+    /* Thread-local context handling. This handles attempting to release the
+     * context which may have been left current when the thread is destroyed.
+     */
+    class ThreadCtx {
+    public:
+        ~ThreadCtx();
+        void set(ALCcontext *ctx) const noexcept { sLocalContext = ctx; }
+    };
+    static thread_local ThreadCtx sThreadContext;
+
+public:
+    /* HACK: MinGW generates bad code when accessing an extern thread_local
+     * object. Add a wrapper function for it that only accesses it where it's
+     * defined.
+     */
+#ifdef __MINGW32__
+    static ALCcontext *getThreadContext() noexcept;
+    static void setThreadContext(ALCcontext *context) noexcept;
+#else
+    static ALCcontext *getThreadContext() noexcept { return sLocalContext; }
+    static void setThreadContext(ALCcontext *context) noexcept { sThreadContext.set(context); }
+#endif
+
+    /* Default effect that applies to sources that don't have an effect on send 0. */
+    static ALeffect sDefaultEffect;
+
+    DEF_NEWDEL(ALCcontext)
+
+#ifdef ALSOFT_EAX
+public:
+    bool hasEax() const noexcept { return mEaxIsInitialized; }
+    bool eaxIsCapable() const noexcept;
+
+    void eaxUninitialize() noexcept;
+
+    ALenum eax_eax_set(
+        const GUID* property_set_id,
+        ALuint property_id,
+        ALuint property_source_id,
+        ALvoid* property_value,
+        ALuint property_value_size);
+
+    ALenum eax_eax_get(
+        const GUID* property_set_id,
+        ALuint property_id,
+        ALuint property_source_id,
+        ALvoid* property_value,
+        ALuint property_value_size);
+
+    void eaxSetLastError() noexcept;
+
+    EaxFxSlotIndex eaxGetPrimaryFxSlotIndex() const noexcept
+    { return mEaxPrimaryFxSlotIndex; }
+
+    const ALeffectslot& eaxGetFxSlot(EaxFxSlotIndexValue fx_slot_index) const
+    { return mEaxFxSlots.get(fx_slot_index); }
+    ALeffectslot& eaxGetFxSlot(EaxFxSlotIndexValue fx_slot_index)
+    { return mEaxFxSlots.get(fx_slot_index); }
+
+    bool eaxNeedsCommit() const noexcept { return mEaxNeedsCommit; }
+    void eaxCommit();
+
+    void eaxCommitFxSlots()
+    { mEaxFxSlots.commit(); }
+
+private:
+    static constexpr auto eax_primary_fx_slot_id_dirty_bit = EaxDirtyFlags{1} << 0;
+    static constexpr auto eax_distance_factor_dirty_bit = EaxDirtyFlags{1} << 1;
+    static constexpr auto eax_air_absorption_hf_dirty_bit = EaxDirtyFlags{1} << 2;
+    static constexpr auto eax_hf_reference_dirty_bit = EaxDirtyFlags{1} << 3;
+    static constexpr auto eax_macro_fx_factor_dirty_bit = EaxDirtyFlags{1} << 4;
+
+    using Eax4Props = EAX40CONTEXTPROPERTIES;
+
+    struct Eax4State {
+        Eax4Props i; // Immediate.
+        Eax4Props d; // Deferred.
+    };
+
+    using Eax5Props = EAX50CONTEXTPROPERTIES;
+
+    struct Eax5State {
+        Eax5Props i; // Immediate.
+        Eax5Props d; // Deferred.
+    };
+
+    class ContextException : public EaxException
+    {
+    public:
+        explicit ContextException(const char* message)
+            : EaxException{"EAX_CONTEXT", message}
+        {}
+    };
+
+    struct Eax4PrimaryFxSlotIdValidator {
+        void operator()(const GUID& guidPrimaryFXSlotID) const
+        {
+            if(guidPrimaryFXSlotID != EAX_NULL_GUID &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX40_FXSlot0 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX40_FXSlot1 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX40_FXSlot2 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX40_FXSlot3)
+            {
+                eax_fail_unknown_primary_fx_slot_id();
+            }
+        }
+    };
+
+    struct Eax4DistanceFactorValidator {
+        void operator()(float flDistanceFactor) const
+        {
+            eax_validate_range<ContextException>(
+                "Distance Factor",
+                flDistanceFactor,
+                EAXCONTEXT_MINDISTANCEFACTOR,
+                EAXCONTEXT_MAXDISTANCEFACTOR);
+        }
+    };
+
+    struct Eax4AirAbsorptionHfValidator {
+        void operator()(float flAirAbsorptionHF) const
+        {
+            eax_validate_range<ContextException>(
+                "Air Absorption HF",
+                flAirAbsorptionHF,
+                EAXCONTEXT_MINAIRABSORPTIONHF,
+                EAXCONTEXT_MAXAIRABSORPTIONHF);
+        }
+    };
+
+    struct Eax4HfReferenceValidator {
+        void operator()(float flHFReference) const
+        {
+            eax_validate_range<ContextException>(
+                "HF Reference",
+                flHFReference,
+                EAXCONTEXT_MINHFREFERENCE,
+                EAXCONTEXT_MAXHFREFERENCE);
+        }
+    };
+
+    struct Eax4AllValidator {
+        void operator()(const EAX40CONTEXTPROPERTIES& all) const
+        {
+            Eax4PrimaryFxSlotIdValidator{}(all.guidPrimaryFXSlotID);
+            Eax4DistanceFactorValidator{}(all.flDistanceFactor);
+            Eax4AirAbsorptionHfValidator{}(all.flAirAbsorptionHF);
+            Eax4HfReferenceValidator{}(all.flHFReference);
+        }
+    };
+
+    struct Eax5PrimaryFxSlotIdValidator {
+        void operator()(const GUID& guidPrimaryFXSlotID) const
+        {
+            if(guidPrimaryFXSlotID != EAX_NULL_GUID &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX50_FXSlot0 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX50_FXSlot1 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX50_FXSlot2 &&
+                guidPrimaryFXSlotID != EAXPROPERTYID_EAX50_FXSlot3)
+            {
+                eax_fail_unknown_primary_fx_slot_id();
+            }
+        }
+    };
+
+    struct Eax5MacroFxFactorValidator {
+        void operator()(float flMacroFXFactor) const
+        {
+            eax_validate_range<ContextException>(
+                "Macro FX Factor",
+                flMacroFXFactor,
+                EAXCONTEXT_MINMACROFXFACTOR,
+                EAXCONTEXT_MAXMACROFXFACTOR);
+        }
+    };
+
+    struct Eax5AllValidator {
+        void operator()(const EAX50CONTEXTPROPERTIES& all) const
+        {
+            Eax5PrimaryFxSlotIdValidator{}(all.guidPrimaryFXSlotID);
+            Eax4DistanceFactorValidator{}(all.flDistanceFactor);
+            Eax4AirAbsorptionHfValidator{}(all.flAirAbsorptionHF);
+            Eax4HfReferenceValidator{}(all.flHFReference);
+            Eax5MacroFxFactorValidator{}(all.flMacroFXFactor);
+        }
+    };
+
+    struct Eax5EaxVersionValidator {
+        void operator()(unsigned long ulEAXVersion) const
+        {
+            eax_validate_range<ContextException>(
+                "EAX version",
+                ulEAXVersion,
+                EAXCONTEXT_MINEAXSESSION,
+                EAXCONTEXT_MAXEAXSESSION);
+        }
+    };
+
+    struct Eax5MaxActiveSendsValidator {
+        void operator()(unsigned long ulMaxActiveSends) const
+        {
+            eax_validate_range<ContextException>(
+                "Max Active Sends",
+                ulMaxActiveSends,
+                EAXCONTEXT_MINMAXACTIVESENDS,
+                EAXCONTEXT_MAXMAXACTIVESENDS);
+        }
+    };
+
+    struct Eax5SessionAllValidator {
+        void operator()(const EAXSESSIONPROPERTIES& all) const
+        {
+            Eax5EaxVersionValidator{}(all.ulEAXVersion);
+            Eax5MaxActiveSendsValidator{}(all.ulMaxActiveSends);
+        }
+    };
+
+    struct Eax5SpeakerConfigValidator {
+        void operator()(unsigned long ulSpeakerConfig) const
+        {
+            eax_validate_range<ContextException>(
+                "Speaker Config",
+                ulSpeakerConfig,
+                EAXCONTEXT_MINSPEAKERCONFIG,
+                EAXCONTEXT_MAXSPEAKERCONFIG);
+        }
+    };
+
+    bool mEaxIsInitialized{};
+    bool mEaxIsTried{};
+
+    long mEaxLastError{};
+    unsigned long mEaxSpeakerConfig{};
+
+    EaxFxSlotIndex mEaxPrimaryFxSlotIndex{};
+    EaxFxSlots mEaxFxSlots{};
+
+    int mEaxVersion{}; // Current EAX version.
+    bool mEaxNeedsCommit{};
+    EaxDirtyFlags mEaxDf{}; // Dirty flags for the current EAX version.
+    Eax5State mEax123{}; // EAX1/EAX2/EAX3 state.
+    Eax4State mEax4{}; // EAX4 state.
+    Eax5State mEax5{}; // EAX5 state.
+    Eax5Props mEax{}; // Current EAX state.
+    EAXSESSIONPROPERTIES mEaxSession{};
+
+    [[noreturn]] static void eax_fail(const char* message);
+    [[noreturn]] static void eax_fail_unknown_property_set_id();
+    [[noreturn]] static void eax_fail_unknown_primary_fx_slot_id();
+    [[noreturn]] static void eax_fail_unknown_property_id();
+    [[noreturn]] static void eax_fail_unknown_version();
+
+    // Gets a value from EAX call,
+    // validates it,
+    // and updates the current value.
+    template<typename TValidator, typename TProperty>
+    static void eax_set(const EaxCall& call, TProperty& property)
+    {
+        const auto& value = call.get_value<ContextException, const TProperty>();
+        TValidator{}(value);
+        property = value;
+    }
+
+    // Gets a new value from EAX call,
+    // validates it,
+    // updates the deferred value,
+    // updates a dirty flag.
+    template<
+        typename TValidator,
+        EaxDirtyFlags TDirtyBit,
+        typename TMemberResult,
+        typename TProps,
+        typename TState>
+    void eax_defer(const EaxCall& call, TState& state, TMemberResult TProps::*member) noexcept
+    {
+        const auto& src = call.get_value<ContextException, const TMemberResult>();
+        TValidator{}(src);
+        const auto& dst_i = state.i.*member;
+        auto& dst_d = state.d.*member;
+        dst_d = src;
+
+        if(dst_i != dst_d)
+            mEaxDf |= TDirtyBit;
+    }
+
+    template<
+        EaxDirtyFlags TDirtyBit,
+        typename TMemberResult,
+        typename TProps,
+        typename TState>
+    void eax_context_commit_property(TState& state, EaxDirtyFlags& dst_df,
+        TMemberResult TProps::*member) noexcept
+    {
+        if((mEaxDf & TDirtyBit) != EaxDirtyFlags{})
+        {
+            dst_df |= TDirtyBit;
+            const auto& src_d = state.d.*member;
+            state.i.*member = src_d;
+            mEax.*member = src_d;
+        }
+    }
+
+    void eax_initialize_extensions();
+    void eax_initialize();
+
+    bool eax_has_no_default_effect_slot() const noexcept;
+    void eax_ensure_no_default_effect_slot() const;
+    bool eax_has_enough_aux_sends() const noexcept;
+    void eax_ensure_enough_aux_sends() const;
+    void eax_ensure_compatibility();
+
+    unsigned long eax_detect_speaker_configuration() const;
+    void eax_update_speaker_configuration();
+
+    void eax_set_last_error_defaults() noexcept;
+    void eax_session_set_defaults() noexcept;
+    static void eax4_context_set_defaults(Eax4Props& props) noexcept;
+    static void eax4_context_set_defaults(Eax4State& state) noexcept;
+    static void eax5_context_set_defaults(Eax5Props& props) noexcept;
+    static void eax5_context_set_defaults(Eax5State& state) noexcept;
+    void eax_context_set_defaults();
+    void eax_set_defaults();
+
+    void eax_dispatch_fx_slot(const EaxCall& call);
+    void eax_dispatch_source(const EaxCall& call);
+
+    void eax_get_misc(const EaxCall& call);
+    void eax4_get(const EaxCall& call, const Eax4Props& props);
+    void eax5_get(const EaxCall& call, const Eax5Props& props);
+    void eax_get(const EaxCall& call);
+
+    void eax_context_commit_primary_fx_slot_id();
+    void eax_context_commit_distance_factor();
+    void eax_context_commit_air_absorbtion_hf();
+    void eax_context_commit_hf_reference();
+    void eax_context_commit_macro_fx_factor();
+
+    void eax_initialize_fx_slots();
+
+    void eax_update_sources();
+
+    void eax_set_misc(const EaxCall& call);
+    void eax4_defer_all(const EaxCall& call, Eax4State& state);
+    void eax4_defer(const EaxCall& call, Eax4State& state);
+    void eax5_defer_all(const EaxCall& call, Eax5State& state);
+    void eax5_defer(const EaxCall& call, Eax5State& state);
+    void eax_set(const EaxCall& call);
+
+    void eax4_context_commit(Eax4State& state, EaxDirtyFlags& dst_df);
+    void eax5_context_commit(Eax5State& state, EaxDirtyFlags& dst_df);
+    void eax_context_commit();
+#endif // ALSOFT_EAX
+};
+
+using ContextRef = al::intrusive_ptr<ALCcontext>;
+
+ContextRef GetContextRef(void);
+
+void UpdateContextProps(ALCcontext *context);
+
+
+extern bool TrapALError;
+
+
+#ifdef ALSOFT_EAX
+ALenum AL_APIENTRY EAXSet(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size) noexcept;
+
+ALenum AL_APIENTRY EAXGet(
+    const GUID* property_set_id,
+    ALuint property_id,
+    ALuint property_source_id,
+    ALvoid* property_value,
+    ALuint property_value_size) noexcept;
+#endif // ALSOFT_EAX
+
+#endif /* ALC_CONTEXT_H */
diff --git a/alc/converter.cpp b/alc/converter.cpp
deleted file mode 100644
index 553bad58..00000000
--- a/alc/converter.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-
-#include "config.h"
-
-#include "converter.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <iterator>
-
-#include "AL/al.h"
-
-#include "albyte.h"
-#include "alu.h"
-#include "fpu_modes.h"
-#include "mixer/defs.h"
-
-
-namespace {
-
-/* Base template left undefined. Should be marked =delete, but Clang 3.8.1
- * chokes on that given the inline specializations.
- */
-template<DevFmtType T>
-inline ALfloat LoadSample(typename DevFmtTypeTraits<T>::Type val) noexcept;
-
-template<> inline ALfloat LoadSample<DevFmtByte>(DevFmtTypeTraits<DevFmtByte>::Type val) noexcept
-{ return val * (1.0f/128.0f); }
-template<> inline ALfloat LoadSample<DevFmtShort>(DevFmtTypeTraits<DevFmtShort>::Type val) noexcept
-{ return val * (1.0f/32768.0f); }
-template<> inline ALfloat LoadSample<DevFmtInt>(DevFmtTypeTraits<DevFmtInt>::Type val) noexcept
-{ return static_cast<float>(val) * (1.0f/2147483648.0f); }
-template<> inline ALfloat LoadSample<DevFmtFloat>(DevFmtTypeTraits<DevFmtFloat>::Type val) noexcept
-{ return val; }
-
-template<> inline ALfloat LoadSample<DevFmtUByte>(DevFmtTypeTraits<DevFmtUByte>::Type val) noexcept
-{ return LoadSample<DevFmtByte>(static_cast<ALbyte>(val - 128)); }
-template<> inline ALfloat LoadSample<DevFmtUShort>(DevFmtTypeTraits<DevFmtUShort>::Type val) noexcept
-{ return LoadSample<DevFmtShort>(static_cast<ALshort>(val - 32768)); }
-template<> inline ALfloat LoadSample<DevFmtUInt>(DevFmtTypeTraits<DevFmtUInt>::Type val) noexcept
-{ return LoadSample<DevFmtInt>(static_cast<ALint>(val - 2147483648u)); }
-
-
-template<DevFmtType T>
-inline void LoadSampleArray(ALfloat *RESTRICT dst, const void *src, const size_t srcstep,
-    const size_t samples) noexcept
-{
-    using SampleType = typename DevFmtTypeTraits<T>::Type;
-
-    const SampleType *ssrc = static_cast<const SampleType*>(src);
-    for(size_t i{0u};i < samples;i++)
-        dst[i] = LoadSample<T>(ssrc[i*srcstep]);
-}
-
-void LoadSamples(ALfloat *dst, const ALvoid *src, const size_t srcstep, const DevFmtType srctype,
-    const size_t samples) noexcept
-{
-#define HANDLE_FMT(T)                                                         \
-    case T: LoadSampleArray<T>(dst, src, srcstep, samples); break
-    switch(srctype)
-    {
-        HANDLE_FMT(DevFmtByte);
-        HANDLE_FMT(DevFmtUByte);
-        HANDLE_FMT(DevFmtShort);
-        HANDLE_FMT(DevFmtUShort);
-        HANDLE_FMT(DevFmtInt);
-        HANDLE_FMT(DevFmtUInt);
-        HANDLE_FMT(DevFmtFloat);
-    }
-#undef HANDLE_FMT
-}
-
-
-template<DevFmtType T>
-inline typename DevFmtTypeTraits<T>::Type StoreSample(ALfloat) noexcept;
-
-template<> inline ALfloat StoreSample<DevFmtFloat>(ALfloat val) noexcept
-{ return val; }
-template<> inline ALint StoreSample<DevFmtInt>(ALfloat val) noexcept
-{ return fastf2i(clampf(val*2147483648.0f, -2147483648.0f, 2147483520.0f)); }
-template<> inline ALshort StoreSample<DevFmtShort>(ALfloat val) noexcept
-{ return static_cast<ALshort>(fastf2i(clampf(val*32768.0f, -32768.0f, 32767.0f))); }
-template<> inline ALbyte StoreSample<DevFmtByte>(ALfloat val) noexcept
-{ return static_cast<ALbyte>(fastf2i(clampf(val*128.0f, -128.0f, 127.0f))); }
-
-/* Define unsigned output variations. */
-template<> inline ALuint StoreSample<DevFmtUInt>(ALfloat val) noexcept
-{ return static_cast<ALuint>(StoreSample<DevFmtInt>(val)) + 2147483648u; }
-template<> inline ALushort StoreSample<DevFmtUShort>(ALfloat val) noexcept
-{ return static_cast<ALushort>(StoreSample<DevFmtShort>(val) + 32768); }
-template<> inline ALubyte StoreSample<DevFmtUByte>(ALfloat val) noexcept
-{ return static_cast<ALubyte>(StoreSample<DevFmtByte>(val) + 128); }
-
-template<DevFmtType T>
-inline void StoreSampleArray(void *dst, const ALfloat *RESTRICT src, const size_t dststep,
-    const size_t samples) noexcept
-{
-    using SampleType = typename DevFmtTypeTraits<T>::Type;
-
-    SampleType *sdst = static_cast<SampleType*>(dst);
-    for(size_t i{0u};i < samples;i++)
-        sdst[i*dststep] = StoreSample<T>(src[i]);
-}
-
-
-void StoreSamples(ALvoid *dst, const ALfloat *src, const size_t dststep, const DevFmtType dsttype,
-    const size_t samples) noexcept
-{
-#define HANDLE_FMT(T)                                                         \
-    case T: StoreSampleArray<T>(dst, src, dststep, samples); break
-    switch(dsttype)
-    {
-        HANDLE_FMT(DevFmtByte);
-        HANDLE_FMT(DevFmtUByte);
-        HANDLE_FMT(DevFmtShort);
-        HANDLE_FMT(DevFmtUShort);
-        HANDLE_FMT(DevFmtInt);
-        HANDLE_FMT(DevFmtUInt);
-        HANDLE_FMT(DevFmtFloat);
-    }
-#undef HANDLE_FMT
-}
-
-
-template<DevFmtType T>
-void Mono2Stereo(ALfloat *RESTRICT dst, const void *src, const size_t frames) noexcept
-{
-    using SampleType = typename DevFmtTypeTraits<T>::Type;
-
-    const SampleType *ssrc = static_cast<const SampleType*>(src);
-    for(size_t i{0u};i < frames;i++)
-        dst[i*2 + 1] = dst[i*2 + 0] = LoadSample<T>(ssrc[i]) * 0.707106781187f;
-}
-
-template<DevFmtType T>
-void Stereo2Mono(ALfloat *RESTRICT dst, const void *src, const size_t frames) noexcept
-{
-    using SampleType = typename DevFmtTypeTraits<T>::Type;
-
-    const SampleType *ssrc = static_cast<const SampleType*>(src);
-    for(size_t i{0u};i < frames;i++)
-        dst[i] = (LoadSample<T>(ssrc[i*2 + 0])+LoadSample<T>(ssrc[i*2 + 1])) *
-                 0.707106781187f;
-}
-
-} // namespace
-
-SampleConverterPtr CreateSampleConverter(DevFmtType srcType, DevFmtType dstType, size_t numchans,
-    ALuint srcRate, ALuint dstRate, Resampler resampler)
-{
-    if(numchans < 1 || srcRate < 1 || dstRate < 1)
-        return nullptr;
-
-    SampleConverterPtr converter{new (FamCount{numchans}) SampleConverter{numchans}};
-    converter->mSrcType = srcType;
-    converter->mDstType = dstType;
-    converter->mSrcTypeSize = BytesFromDevFmt(srcType);
-    converter->mDstTypeSize = BytesFromDevFmt(dstType);
-
-    converter->mSrcPrepCount = 0;
-    converter->mFracOffset = 0;
-
-    /* Have to set the mixer FPU mode since that's what the resampler code expects. */
-    FPUCtl mixer_mode{};
-    auto step = static_cast<ALuint>(
-        mind(srcRate*double{FRACTIONONE}/dstRate + 0.5, MAX_PITCH*FRACTIONONE));
-    converter->mIncrement = maxu(step, 1);
-    if(converter->mIncrement == FRACTIONONE)
-        converter->mResample = Resample_<CopyTag,CTag>;
-    else
-        converter->mResample = PrepareResampler(resampler, converter->mIncrement,
-            &converter->mState);
-
-    return converter;
-}
-
-ALuint SampleConverter::availableOut(ALuint srcframes) const
-{
-    ALint prepcount{mSrcPrepCount};
-    if(prepcount < 0)
-    {
-        /* Negative prepcount means we need to skip that many input samples. */
-        if(static_cast<ALuint>(-prepcount) >= srcframes)
-            return 0;
-        srcframes -= static_cast<ALuint>(-prepcount);
-        prepcount = 0;
-    }
-
-    if(srcframes < 1)
-    {
-        /* No output samples if there's no input samples. */
-        return 0;
-    }
-
-    if(prepcount < MAX_RESAMPLER_PADDING
-        && static_cast<ALuint>(MAX_RESAMPLER_PADDING - prepcount) >= srcframes)
-    {
-        /* Not enough input samples to generate an output sample. */
-        return 0;
-    }
-
-    auto DataSize64 = static_cast<uint64_t>(prepcount);
-    DataSize64 += srcframes;
-    DataSize64 -= MAX_RESAMPLER_PADDING;
-    DataSize64 <<= FRACTIONBITS;
-    DataSize64 -= mFracOffset;
-
-    /* If we have a full prep, we can generate at least one sample. */
-    return static_cast<ALuint>(clampu64((DataSize64 + mIncrement-1)/mIncrement, 1, BUFFERSIZE));
-}
-
-ALuint SampleConverter::convert(const ALvoid **src, ALuint *srcframes, ALvoid *dst, ALuint dstframes)
-{
-    const ALuint SrcFrameSize{static_cast<ALuint>(mChan.size()) * mSrcTypeSize};
-    const ALuint DstFrameSize{static_cast<ALuint>(mChan.size()) * mDstTypeSize};
-    const ALuint increment{mIncrement};
-    auto SamplesIn = static_cast<const al::byte*>(*src);
-    ALuint NumSrcSamples{*srcframes};
-
-    FPUCtl mixer_mode{};
-    ALuint pos{0};
-    while(pos < dstframes && NumSrcSamples > 0)
-    {
-        ALint prepcount{mSrcPrepCount};
-        if(prepcount < 0)
-        {
-            /* Negative prepcount means we need to skip that many input samples. */
-            if(static_cast<ALuint>(-prepcount) >= NumSrcSamples)
-            {
-                mSrcPrepCount = static_cast<ALint>(NumSrcSamples) + prepcount;
-                NumSrcSamples = 0;
-                break;
-            }
-            SamplesIn += SrcFrameSize*static_cast<ALuint>(-prepcount);
-            NumSrcSamples -= static_cast<ALuint>(-prepcount);
-            mSrcPrepCount = 0;
-            continue;
-        }
-        ALuint toread{minu(NumSrcSamples, BUFFERSIZE - MAX_RESAMPLER_PADDING)};
-
-        if(prepcount < MAX_RESAMPLER_PADDING
-            && static_cast<ALuint>(MAX_RESAMPLER_PADDING - prepcount) >= toread)
-        {
-            /* Not enough input samples to generate an output sample. Store
-             * what we're given for later.
-             */
-            for(size_t chan{0u};chan < mChan.size();chan++)
-                LoadSamples(&mChan[chan].PrevSamples[prepcount], SamplesIn + mSrcTypeSize*chan,
-                    mChan.size(), mSrcType, toread);
-
-            mSrcPrepCount = prepcount + static_cast<ALint>(toread);
-            NumSrcSamples = 0;
-            break;
-        }
-
-        ALfloat *RESTRICT SrcData{mSrcSamples};
-        ALfloat *RESTRICT DstData{mDstSamples};
-        ALuint DataPosFrac{mFracOffset};
-        auto DataSize64 = static_cast<uint64_t>(prepcount);
-        DataSize64 += toread;
-        DataSize64 -= MAX_RESAMPLER_PADDING;
-        DataSize64 <<= FRACTIONBITS;
-        DataSize64 -= DataPosFrac;
-
-        /* If we have a full prep, we can generate at least one sample. */
-        auto DstSize = static_cast<ALuint>(
-            clampu64((DataSize64 + increment-1)/increment, 1, BUFFERSIZE));
-        DstSize = minu(DstSize, dstframes-pos);
-
-        for(size_t chan{0u};chan < mChan.size();chan++)
-        {
-            const al::byte *SrcSamples{SamplesIn + mSrcTypeSize*chan};
-            al::byte *DstSamples = static_cast<al::byte*>(dst) + mDstTypeSize*chan;
-
-            /* Load the previous samples into the source data first, then the
-             * new samples from the input buffer.
-             */
-            std::copy_n(mChan[chan].PrevSamples, prepcount, SrcData);
-            LoadSamples(SrcData + prepcount, SrcSamples, mChan.size(), mSrcType, toread);
-
-            /* Store as many prep samples for next time as possible, given the
-             * number of output samples being generated.
-             */
-            ALuint SrcDataEnd{(DstSize*increment + DataPosFrac)>>FRACTIONBITS};
-            if(SrcDataEnd >= static_cast<ALuint>(prepcount)+toread)
-                std::fill(std::begin(mChan[chan].PrevSamples),
-                    std::end(mChan[chan].PrevSamples), 0.0f);
-            else
-            {
-                const size_t len{minz(al::size(mChan[chan].PrevSamples),
-                    static_cast<ALuint>(prepcount)+toread-SrcDataEnd)};
-                std::copy_n(SrcData+SrcDataEnd, len, mChan[chan].PrevSamples);
-                std::fill(std::begin(mChan[chan].PrevSamples)+len,
-                    std::end(mChan[chan].PrevSamples), 0.0f);
-            }
-
-            /* Now resample, and store the result in the output buffer. */
-            const ALfloat *ResampledData{mResample(&mState, SrcData+(MAX_RESAMPLER_PADDING>>1),
-                DataPosFrac, increment, {DstData, DstSize})};
-
-            StoreSamples(DstSamples, ResampledData, mChan.size(), mDstType, DstSize);
-        }
-
-        /* Update the number of prep samples still available, as well as the
-         * fractional offset.
-         */
-        DataPosFrac += increment*DstSize;
-        mSrcPrepCount = mini(prepcount + static_cast<ALint>(toread - (DataPosFrac>>FRACTIONBITS)),
-            MAX_RESAMPLER_PADDING);
-        mFracOffset = DataPosFrac & FRACTIONMASK;
-
-        /* Update the src and dst pointers in case there's still more to do. */
-        SamplesIn += SrcFrameSize*(DataPosFrac>>FRACTIONBITS);
-        NumSrcSamples -= minu(NumSrcSamples, (DataPosFrac>>FRACTIONBITS));
-
-        dst = static_cast<al::byte*>(dst) + DstFrameSize*DstSize;
-        pos += DstSize;
-    }
-
-    *src = SamplesIn;
-    *srcframes = NumSrcSamples;
-
-    return pos;
-}
-
-
-void ChannelConverter::convert(const ALvoid *src, ALfloat *dst, ALuint frames) const
-{
-    if(mSrcChans == DevFmtStereo && mDstChans == DevFmtMono)
-    {
-        switch(mSrcType)
-        {
-#define HANDLE_FMT(T) case T: Stereo2Mono<T>(dst, src, frames); break
-        HANDLE_FMT(DevFmtByte);
-        HANDLE_FMT(DevFmtUByte);
-        HANDLE_FMT(DevFmtShort);
-        HANDLE_FMT(DevFmtUShort);
-        HANDLE_FMT(DevFmtInt);
-        HANDLE_FMT(DevFmtUInt);
-        HANDLE_FMT(DevFmtFloat);
-#undef HANDLE_FMT
-        }
-    }
-    else if(mSrcChans == DevFmtMono && mDstChans == DevFmtStereo)
-    {
-        switch(mSrcType)
-        {
-#define HANDLE_FMT(T) case T: Mono2Stereo<T>(dst, src, frames); break
-        HANDLE_FMT(DevFmtByte);
-        HANDLE_FMT(DevFmtUByte);
-        HANDLE_FMT(DevFmtShort);
-        HANDLE_FMT(DevFmtUShort);
-        HANDLE_FMT(DevFmtInt);
-        HANDLE_FMT(DevFmtUInt);
-        HANDLE_FMT(DevFmtFloat);
-#undef HANDLE_FMT
-        }
-    }
-    else
-        LoadSamples(dst, src, 1u, mSrcType, frames * ChannelsFromDevFmt(mSrcChans, 0));
-}
diff --git a/alc/converter.h b/alc/converter.h
deleted file mode 100644
index 5842df07..00000000
--- a/alc/converter.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef CONVERTER_H
-#define CONVERTER_H
-
-#include <cstddef>
-#include <memory>
-
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "almalloc.h"
-#include "alnumeric.h"
-#include "alu.h"
-#include "devformat.h"
-#include "voice.h"
-
-
-struct SampleConverter {
-    DevFmtType mSrcType{};
-    DevFmtType mDstType{};
-    ALuint mSrcTypeSize{};
-    ALuint mDstTypeSize{};
-
-    ALint mSrcPrepCount{};
-
-    ALuint mFracOffset{};
-    ALuint mIncrement{};
-    InterpState mState{};
-    ResamplerFunc mResample{};
-
-    alignas(16) ALfloat mSrcSamples[BUFFERSIZE]{};
-    alignas(16) ALfloat mDstSamples[BUFFERSIZE]{};
-
-    struct ChanSamples {
-        alignas(16) ALfloat PrevSamples[MAX_RESAMPLER_PADDING];
-    };
-    al::FlexArray<ChanSamples> mChan;
-
-    SampleConverter(size_t numchans) : mChan{numchans} { }
-
-    ALuint convert(const ALvoid **src, ALuint *srcframes, ALvoid *dst, ALuint dstframes);
-    ALuint availableOut(ALuint srcframes) const;
-
-    DEF_FAM_NEWDEL(SampleConverter, mChan)
-};
-using SampleConverterPtr = std::unique_ptr<SampleConverter>;
-
-SampleConverterPtr CreateSampleConverter(DevFmtType srcType, DevFmtType dstType, size_t numchans,
-    ALuint srcRate, ALuint dstRate, Resampler resampler);
-
-
-struct ChannelConverter {
-    DevFmtType mSrcType;
-    DevFmtChannels mSrcChans;
-    DevFmtChannels mDstChans;
-
-    bool is_active() const noexcept { return mSrcChans != mDstChans; }
-
-    void convert(const ALvoid *src, ALfloat *dst, ALuint frames) const;
-};
-
-#endif /* CONVERTER_H */
diff --git a/alc/cpu_caps.h b/alc/cpu_caps.h
deleted file mode 100644
index 64a4ee45..00000000
--- a/alc/cpu_caps.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef CPU_CAPS_H
-#define CPU_CAPS_H
-
-
-extern int CPUCapFlags;
-enum {
-    CPU_CAP_SSE    = 1<<0,
-    CPU_CAP_SSE2   = 1<<1,
-    CPU_CAP_SSE3   = 1<<2,
-    CPU_CAP_SSE4_1 = 1<<3,
-    CPU_CAP_NEON   = 1<<4,
-};
-
-void FillCPUCaps(int capfilter);
-
-#endif /* CPU_CAPS_H */
diff --git a/alc/devformat.h b/alc/devformat.h
deleted file mode 100644
index 402fb8bd..00000000
--- a/alc/devformat.h
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef ALC_DEVFORMAT_H
-#define ALC_DEVFORMAT_H
-
-#include <cstdint>
-
-#include "AL/al.h"
-#include "AL/alext.h"
-
-#include "inprogext.h"
-
-
-enum Channel {
-    FrontLeft = 0,
-    FrontRight,
-    FrontCenter,
-    LFE,
-    BackLeft,
-    BackRight,
-    BackCenter,
-    SideLeft,
-    SideRight,
-
-    UpperFrontLeft,
-    UpperFrontRight,
-    UpperBackLeft,
-    UpperBackRight,
-    LowerFrontLeft,
-    LowerFrontRight,
-    LowerBackLeft,
-    LowerBackRight,
-
-    Aux0,
-    Aux1,
-    Aux2,
-    Aux3,
-    Aux4,
-    Aux5,
-    Aux6,
-    Aux7,
-    Aux8,
-    Aux9,
-    Aux10,
-    Aux11,
-    Aux12,
-    Aux13,
-    Aux14,
-    Aux15,
-
-    MaxChannels
-};
-
-
-/* Device formats */
-enum DevFmtType : ALenum {
-    DevFmtByte   = ALC_BYTE_SOFT,
-    DevFmtUByte  = ALC_UNSIGNED_BYTE_SOFT,
-    DevFmtShort  = ALC_SHORT_SOFT,
-    DevFmtUShort = ALC_UNSIGNED_SHORT_SOFT,
-    DevFmtInt    = ALC_INT_SOFT,
-    DevFmtUInt   = ALC_UNSIGNED_INT_SOFT,
-    DevFmtFloat  = ALC_FLOAT_SOFT,
-
-    DevFmtTypeDefault = DevFmtFloat
-};
-enum DevFmtChannels : ALenum {
-    DevFmtMono   = ALC_MONO_SOFT,
-    DevFmtStereo = ALC_STEREO_SOFT,
-    DevFmtQuad   = ALC_QUAD_SOFT,
-    DevFmtX51    = ALC_5POINT1_SOFT,
-    DevFmtX61    = ALC_6POINT1_SOFT,
-    DevFmtX71    = ALC_7POINT1_SOFT,
-    DevFmtAmbi3D = ALC_BFORMAT3D_SOFT,
-
-    /* Similar to 5.1, except using rear channels instead of sides */
-    DevFmtX51Rear = 0x70000000,
-
-    DevFmtChannelsDefault = DevFmtStereo
-};
-#define MAX_OUTPUT_CHANNELS  (16)
-
-/* DevFmtType traits, providing the type, etc given a DevFmtType. */
-template<DevFmtType T>
-struct DevFmtTypeTraits { };
-
-template<>
-struct DevFmtTypeTraits<DevFmtByte> { using Type = int8_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtUByte> { using Type = uint8_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtShort> { using Type = int16_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtUShort> { using Type = uint16_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtInt> { using Type = int32_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtUInt> { using Type = uint32_t; };
-template<>
-struct DevFmtTypeTraits<DevFmtFloat> { using Type = float; };
-
-
-ALuint BytesFromDevFmt(DevFmtType type) noexcept;
-ALuint ChannelsFromDevFmt(DevFmtChannels chans, ALuint ambiorder) noexcept;
-inline ALuint FrameSizeFromDevFmt(DevFmtChannels chans, DevFmtType type, ALuint ambiorder) noexcept
-{ return ChannelsFromDevFmt(chans, ambiorder) * BytesFromDevFmt(type); }
-
-enum class AmbiLayout {
-    FuMa = ALC_FUMA_SOFT, /* FuMa channel order */
-    ACN = ALC_ACN_SOFT,   /* ACN channel order */
-
-    Default = ACN
-};
-
-enum class AmbiNorm {
-    FuMa = ALC_FUMA_SOFT, /* FuMa normalization */
-    SN3D = ALC_SN3D_SOFT, /* SN3D normalization */
-    N3D = ALC_N3D_SOFT,   /* N3D normalization */
-
-    Default = SN3D
-};
-
-#endif /* ALC_DEVFORMAT_H */
diff --git a/alc/device.cpp b/alc/device.cpp
new file mode 100644
index 00000000..66b13c5e
--- /dev/null
+++ b/alc/device.cpp
@@ -0,0 +1,93 @@
+
+#include "config.h"
+
+#include "device.h"
+
+#include <numeric>
+#include <stddef.h>
+
+#include "albit.h"
+#include "alconfig.h"
+#include "backends/base.h"
+#include "core/bformatdec.h"
+#include "core/bs2b.h"
+#include "core/front_stablizer.h"
+#include "core/hrtf.h"
+#include "core/logging.h"
+#include "core/mastering.h"
+#include "core/uhjfilter.h"
+
+
+namespace {
+
+using voidp = void*;
+
+} // namespace
+
+
+ALCdevice::ALCdevice(DeviceType type) : DeviceBase{type}
+{ }
+
+ALCdevice::~ALCdevice()
+{
+    TRACE("Freeing device %p\n", voidp{this});
+
+    Backend = nullptr;
+
+    size_t count{std::accumulate(BufferList.cbegin(), BufferList.cend(), size_t{0u},
+        [](size_t cur, const BufferSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); })};
+    if(count > 0)
+        WARN("%zu Buffer%s not deleted\n", count, (count==1)?"":"s");
+
+    count = std::accumulate(EffectList.cbegin(), EffectList.cend(), size_t{0u},
+        [](size_t cur, const EffectSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); });
+    if(count > 0)
+        WARN("%zu Effect%s not deleted\n", count, (count==1)?"":"s");
+
+    count = std::accumulate(FilterList.cbegin(), FilterList.cend(), size_t{0u},
+        [](size_t cur, const FilterSubList &sublist) noexcept -> size_t
+        { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); });
+    if(count > 0)
+        WARN("%zu Filter%s not deleted\n", count, (count==1)?"":"s");
+}
+
+void ALCdevice::enumerateHrtfs()
+{
+    mHrtfList = EnumerateHrtf(configValue<std::string>(nullptr, "hrtf-paths"));
+    if(auto defhrtfopt = configValue<std::string>(nullptr, "default-hrtf"))
+    {
+        auto iter = std::find(mHrtfList.begin(), mHrtfList.end(), *defhrtfopt);
+        if(iter == mHrtfList.end())
+            WARN("Failed to find default HRTF \"%s\"\n", defhrtfopt->c_str());
+        else if(iter != mHrtfList.begin())
+            std::rotate(mHrtfList.begin(), iter, iter+1);
+    }
+}
+
+auto ALCdevice::getOutputMode1() const noexcept -> OutputMode1
+{
+    if(mContexts.load(std::memory_order_relaxed)->empty())
+        return OutputMode1::Any;
+
+    switch(FmtChans)
+    {
+    case DevFmtMono: return OutputMode1::Mono;
+    case DevFmtStereo:
+        if(mHrtf)
+            return OutputMode1::Hrtf;
+        else if(mUhjEncoder)
+            return OutputMode1::Uhj2;
+        return OutputMode1::StereoBasic;
+    case DevFmtQuad: return OutputMode1::Quad;
+    case DevFmtX51: return OutputMode1::X51;
+    case DevFmtX61: return OutputMode1::X61;
+    case DevFmtX71: return OutputMode1::X71;
+    case DevFmtX714:
+    case DevFmtX3D71:
+    case DevFmtAmbi3D:
+        break;
+    }
+    return OutputMode1::Any;
+}
diff --git a/alc/device.h b/alc/device.h
new file mode 100644
index 00000000..ef50f53e
--- /dev/null
+++ b/alc/device.h
@@ -0,0 +1,165 @@
+#ifndef ALC_DEVICE_H
+#define ALC_DEVICE_H
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <stdint.h>
+#include <string>
+#include <utility>
+
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "alconfig.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "core/device.h"
+#include "inprogext.h"
+#include "intrusive_ptr.h"
+#include "vector.h"
+
+#ifdef ALSOFT_EAX
+#include "al/eax/x_ram.h"
+#endif // ALSOFT_EAX
+
+struct ALbuffer;
+struct ALeffect;
+struct ALfilter;
+struct BackendBase;
+
+using uint = unsigned int;
+
+
+struct BufferSubList {
+    uint64_t FreeMask{~0_u64};
+    ALbuffer *Buffers{nullptr}; /* 64 */
+
+    BufferSubList() noexcept = default;
+    BufferSubList(const BufferSubList&) = delete;
+    BufferSubList(BufferSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Buffers{rhs.Buffers}
+    { rhs.FreeMask = ~0_u64; rhs.Buffers = nullptr; }
+    ~BufferSubList();
+
+    BufferSubList& operator=(const BufferSubList&) = delete;
+    BufferSubList& operator=(BufferSubList&& rhs) noexcept
+    { std::swap(FreeMask, rhs.FreeMask); std::swap(Buffers, rhs.Buffers); return *this; }
+};
+
+struct EffectSubList {
+    uint64_t FreeMask{~0_u64};
+    ALeffect *Effects{nullptr}; /* 64 */
+
+    EffectSubList() noexcept = default;
+    EffectSubList(const EffectSubList&) = delete;
+    EffectSubList(EffectSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Effects{rhs.Effects}
+    { rhs.FreeMask = ~0_u64; rhs.Effects = nullptr; }
+    ~EffectSubList();
+
+    EffectSubList& operator=(const EffectSubList&) = delete;
+    EffectSubList& operator=(EffectSubList&& rhs) noexcept
+    { std::swap(FreeMask, rhs.FreeMask); std::swap(Effects, rhs.Effects); return *this; }
+};
+
+struct FilterSubList {
+    uint64_t FreeMask{~0_u64};
+    ALfilter *Filters{nullptr}; /* 64 */
+
+    FilterSubList() noexcept = default;
+    FilterSubList(const FilterSubList&) = delete;
+    FilterSubList(FilterSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Filters{rhs.Filters}
+    { rhs.FreeMask = ~0_u64; rhs.Filters = nullptr; }
+    ~FilterSubList();
+
+    FilterSubList& operator=(const FilterSubList&) = delete;
+    FilterSubList& operator=(FilterSubList&& rhs) noexcept
+    { std::swap(FreeMask, rhs.FreeMask); std::swap(Filters, rhs.Filters); return *this; }
+};
+
+
+struct ALCdevice : public al::intrusive_ref<ALCdevice>, DeviceBase {
+    /* This lock protects the device state (format, update size, etc) from
+     * being from being changed in multiple threads, or being accessed while
+     * being changed. It's also used to serialize calls to the backend.
+     */
+    std::mutex StateLock;
+    std::unique_ptr<BackendBase> Backend;
+
+    ALCuint NumMonoSources{};
+    ALCuint NumStereoSources{};
+
+    // Maximum number of sources that can be created
+    uint SourcesMax{};
+    // Maximum number of slots that can be created
+    uint AuxiliaryEffectSlotMax{};
+
+    std::string mHrtfName;
+    al::vector<std::string> mHrtfList;
+    ALCenum mHrtfStatus{ALC_FALSE};
+
+    enum class OutputMode1 : ALCenum {
+        Any = ALC_ANY_SOFT,
+        Mono = ALC_MONO_SOFT,
+        Stereo = ALC_STEREO_SOFT,
+        StereoBasic = ALC_STEREO_BASIC_SOFT,
+        Uhj2 = ALC_STEREO_UHJ_SOFT,
+        Hrtf = ALC_STEREO_HRTF_SOFT,
+        Quad = ALC_QUAD_SOFT,
+        X51 = ALC_SURROUND_5_1_SOFT,
+        X61 = ALC_SURROUND_6_1_SOFT,
+        X71 = ALC_SURROUND_7_1_SOFT
+    };
+    OutputMode1 getOutputMode1() const noexcept;
+
+    using OutputMode = OutputMode1;
+
+    std::atomic<ALCenum> LastError{ALC_NO_ERROR};
+
+    // Map of Buffers for this device
+    std::mutex BufferLock;
+    al::vector<BufferSubList> BufferList;
+
+    // Map of Effects for this device
+    std::mutex EffectLock;
+    al::vector<EffectSubList> EffectList;
+
+    // Map of Filters for this device
+    std::mutex FilterLock;
+    al::vector<FilterSubList> FilterList;
+
+#ifdef ALSOFT_EAX
+    ALuint eax_x_ram_free_size{eax_x_ram_max_size};
+#endif // ALSOFT_EAX
+
+
+    ALCdevice(DeviceType type);
+    ~ALCdevice();
+
+    void enumerateHrtfs();
+
+    bool getConfigValueBool(const char *block, const char *key, bool def)
+    { return GetConfigValueBool(DeviceName.c_str(), block, key, def); }
+
+    template<typename T>
+    inline al::optional<T> configValue(const char *block, const char *key) = delete;
+
+    DEF_NEWDEL(ALCdevice)
+};
+
+template<>
+inline al::optional<std::string> ALCdevice::configValue(const char *block, const char *key)
+{ return ConfigValueStr(DeviceName.c_str(), block, key); }
+template<>
+inline al::optional<int> ALCdevice::configValue(const char *block, const char *key)
+{ return ConfigValueInt(DeviceName.c_str(), block, key); }
+template<>
+inline al::optional<uint> ALCdevice::configValue(const char *block, const char *key)
+{ return ConfigValueUInt(DeviceName.c_str(), block, key); }
+template<>
+inline al::optional<float> ALCdevice::configValue(const char *block, const char *key)
+{ return ConfigValueFloat(DeviceName.c_str(), block, key); }
+template<>
+inline al::optional<bool> ALCdevice::configValue(const char *block, const char *key)
+{ return ConfigValueBool(DeviceName.c_str(), block, key); }
+
+#endif
diff --git a/alc/effects/autowah.cpp b/alc/effects/autowah.cpp
index a79c21d9..4f874ef2 100644
--- a/alc/effects/autowah.cpp
+++ b/alc/effects/autowah.cpp
@@ -20,63 +20,77 @@
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
-
 #include <algorithm>
+#include <array>
+#include <cstdlib>
+#include <iterator>
+#include <utility>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "filters/biquad.h"
-#include "vecmat.h"
 
 namespace {
 
-#define MIN_FREQ 20.0f
-#define MAX_FREQ 2500.0f
-#define Q_FACTOR 5.0f
+constexpr float GainScale{31621.0f};
+constexpr float MinFreq{20.0f};
+constexpr float MaxFreq{2500.0f};
+constexpr float QFactor{5.0f};
 
 struct AutowahState final : public EffectState {
     /* Effect parameters */
-    ALfloat mAttackRate;
-    ALfloat mReleaseRate;
-    ALfloat mResonanceGain;
-    ALfloat mPeakGain;
-    ALfloat mFreqMinNorm;
-    ALfloat mBandwidthNorm;
-    ALfloat mEnvDelay;
+    float mAttackRate;
+    float mReleaseRate;
+    float mResonanceGain;
+    float mPeakGain;
+    float mFreqMinNorm;
+    float mBandwidthNorm;
+    float mEnvDelay;
 
     /* Filter components derived from the envelope. */
     struct {
-        ALfloat cos_w0;
-        ALfloat alpha;
-    } mEnv[BUFFERSIZE];
+        float cos_w0;
+        float alpha;
+    } mEnv[BufferLineSize];
 
     struct {
+        uint mTargetChannel{InvalidChannelIndex};
+
         /* Effect filters' history. */
         struct {
-            ALfloat z1, z2;
-        } Filter;
+            float z1, z2;
+        } mFilter;
 
         /* Effect gains for each output channel */
-        ALfloat CurrentGains[MAX_OUTPUT_CHANNELS];
-        ALfloat TargetGains[MAX_OUTPUT_CHANNELS];
-    } mChans[MAX_AMBI_CHANNELS];
+        float mCurrentGain;
+        float mTargetGain;
+    } mChans[MaxAmbiChannels];
 
     /* Effects buffers */
-    alignas(16) ALfloat mBufferOut[BUFFERSIZE];
+    alignas(16) float mBufferOut[BufferLineSize];
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(AutowahState)
 };
 
-ALboolean AutowahState::deviceUpdate(const ALCdevice*)
+void AutowahState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     /* (Re-)initializing parameters and clear the buffers. */
 
@@ -96,83 +110,92 @@ ALboolean AutowahState::deviceUpdate(const ALCdevice*)
 
     for(auto &chan : mChans)
     {
-        std::fill(std::begin(chan.CurrentGains), std::end(chan.CurrentGains), 0.0f);
-        chan.Filter.z1 = 0.0f;
-        chan.Filter.z2 = 0.0f;
+        chan.mTargetChannel = InvalidChannelIndex;
+        chan.mFilter.z1 = 0.0f;
+        chan.mFilter.z2 = 0.0f;
+        chan.mCurrentGain = 0.0f;
     }
-
-    return AL_TRUE;
 }
 
-void AutowahState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void AutowahState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
+    const DeviceBase *device{context->mDevice};
     const auto frequency = static_cast<float>(device->Frequency);
 
-    const ALfloat ReleaseTime{clampf(props->Autowah.ReleaseTime, 0.001f, 1.0f)};
+    const float ReleaseTime{clampf(props->Autowah.ReleaseTime, 0.001f, 1.0f)};
 
     mAttackRate    = std::exp(-1.0f / (props->Autowah.AttackTime*frequency));
     mReleaseRate   = std::exp(-1.0f / (ReleaseTime*frequency));
     /* 0-20dB Resonance Peak gain */
     mResonanceGain = std::sqrt(std::log10(props->Autowah.Resonance)*10.0f / 3.0f);
-    mPeakGain      = 1.0f - std::log10(props->Autowah.PeakGain/AL_AUTOWAH_MAX_PEAK_GAIN);
-    mFreqMinNorm   = MIN_FREQ / frequency;
-    mBandwidthNorm = (MAX_FREQ-MIN_FREQ) / frequency;
+    mPeakGain      = 1.0f - std::log10(props->Autowah.PeakGain / GainScale);
+    mFreqMinNorm   = MinFreq / frequency;
+    mBandwidthNorm = (MaxFreq-MinFreq) / frequency;
 
     mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
+    auto set_channel = [this](size_t idx, uint outchan, float outgain)
     {
-        auto coeffs = GetAmbiIdentityRow(i);
-        ComputePanGains(target.Main, coeffs.data(), slot->Params.Gain, mChans[i].TargetGains);
-    }
+        mChans[idx].mTargetChannel = outchan;
+        mChans[idx].mTargetGain = outgain;
+    };
+    target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 }
 
-void AutowahState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
+void AutowahState::process(const size_t samplesToDo,
+    const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    const ALfloat attack_rate = mAttackRate;
-    const ALfloat release_rate = mReleaseRate;
-    const ALfloat res_gain = mResonanceGain;
-    const ALfloat peak_gain = mPeakGain;
-    const ALfloat freq_min = mFreqMinNorm;
-    const ALfloat bandwidth = mBandwidthNorm;
-
-    ALfloat env_delay{mEnvDelay};
+    const float attack_rate{mAttackRate};
+    const float release_rate{mReleaseRate};
+    const float res_gain{mResonanceGain};
+    const float peak_gain{mPeakGain};
+    const float freq_min{mFreqMinNorm};
+    const float bandwidth{mBandwidthNorm};
+
+    float env_delay{mEnvDelay};
     for(size_t i{0u};i < samplesToDo;i++)
     {
-        ALfloat w0, sample, a;
+        float w0, sample, a;
 
         /* Envelope follower described on the book: Audio Effects, Theory,
          * Implementation and Application.
          */
         sample = peak_gain * std::fabs(samplesIn[0][i]);
         a = (sample > env_delay) ? attack_rate : release_rate;
-        env_delay = lerp(sample, env_delay, a);
+        env_delay = lerpf(sample, env_delay, a);
 
         /* Calculate the cos and alpha components for this sample's filter. */
-        w0 = minf((bandwidth*env_delay + freq_min), 0.46f) * al::MathDefs<float>::Tau();
-        mEnv[i].cos_w0 = cosf(w0);
-        mEnv[i].alpha = sinf(w0)/(2.0f * Q_FACTOR);
+        w0 = minf((bandwidth*env_delay + freq_min), 0.46f) * (al::numbers::pi_v<float>*2.0f);
+        mEnv[i].cos_w0 = std::cos(w0);
+        mEnv[i].alpha = std::sin(w0)/(2.0f * QFactor);
     }
     mEnvDelay = env_delay;
 
-    auto chandata = std::addressof(mChans[0]);
+    auto chandata = std::begin(mChans);
     for(const auto &insamples : samplesIn)
     {
+        const size_t outidx{chandata->mTargetChannel};
+        if(outidx == InvalidChannelIndex)
+        {
+            ++chandata;
+            continue;
+        }
+
         /* This effectively inlines BiquadFilter_setParams for a peaking
          * filter and BiquadFilter_processC. The alpha and cosine components
          * for the filter coefficients were previously calculated with the
          * envelope. Because the filter changes for each sample, the
          * coefficients are transient and don't need to be held.
          */
-        ALfloat z1{chandata->Filter.z1};
-        ALfloat z2{chandata->Filter.z2};
+        float z1{chandata->mFilter.z1};
+        float z2{chandata->mFilter.z2};
 
         for(size_t i{0u};i < samplesToDo;i++)
         {
-            const ALfloat alpha = mEnv[i].alpha;
-            const ALfloat cos_w0 = mEnv[i].cos_w0;
-            ALfloat input, output;
-            ALfloat a[3], b[3];
+            const float alpha{mEnv[i].alpha};
+            const float cos_w0{mEnv[i].cos_w0};
+            float input, output;
+            float a[3], b[3];
 
             b[0] =  1.0f + alpha*res_gain;
             b[1] = -2.0f * cos_w0;
@@ -187,109 +210,22 @@ void AutowahState::process(const size_t samplesToDo, const al::span<const FloatB
             z2 = input*(b[2]/a[0]) - output*(a[2]/a[0]);
             mBufferOut[i] = output;
         }
-        chandata->Filter.z1 = z1;
-        chandata->Filter.z2 = z2;
+        chandata->mFilter.z1 = z1;
+        chandata->mFilter.z2 = z2;
 
         /* Now, mix the processed sound data to the output. */
-        MixSamples({mBufferOut, samplesToDo}, samplesOut, chandata->CurrentGains,
-            chandata->TargetGains, samplesToDo, 0);
+        MixSamples({mBufferOut, samplesToDo}, samplesOut[outidx].data(), chandata->mCurrentGain,
+            chandata->mTargetGain, samplesToDo);
         ++chandata;
     }
 }
 
 
-void Autowah_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_AUTOWAH_ATTACK_TIME:
-            if(!(val >= AL_AUTOWAH_MIN_ATTACK_TIME && val <= AL_AUTOWAH_MAX_ATTACK_TIME))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,,"Autowah peak gain out of range");
-            props->Autowah.PeakGain = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param);
-    }
-}
-void Autowah_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Autowah_setParamf(props, context, param, vals[0]); }
-
-void Autowah_setParami(EffectProps*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param); }
-void Autowah_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x", param); }
-
-void Autowah_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param);
-    }
-
-}
-void Autowah_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Autowah_getParamf(props, context, param, vals); }
-
-void Autowah_getParami(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param); }
-void Autowah_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x", param); }
-
-DEFINE_ALEFFECT_VTABLE(Autowah);
-
-
 struct AutowahStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new AutowahState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Autowah_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new AutowahState{}}; }
 };
 
-EffectProps AutowahStateFactory::getDefaultProps() const 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
 
 EffectStateFactory *AutowahStateFactory_getFactory()
diff --git a/alc/effects/base.h b/alc/effects/base.h
index 6889308d..95695857 100644
--- a/alc/effects/base.h
+++ b/alc/effects/base.h
@@ -1,175 +1,7 @@
 #ifndef EFFECTS_BASE_H
 #define EFFECTS_BASE_H
 
-#include <cstddef>
-
-#include "alcmain.h"
-#include "almalloc.h"
-#include "alspan.h"
-#include "atomic.h"
-#include "intrusive_ptr.h"
-
-struct ALeffectslot;
-
-
-union EffectProps {
-    struct {
-        // Shared Reverb Properties
-        ALfloat Density;
-        ALfloat Diffusion;
-        ALfloat Gain;
-        ALfloat GainHF;
-        ALfloat DecayTime;
-        ALfloat DecayHFRatio;
-        ALfloat ReflectionsGain;
-        ALfloat ReflectionsDelay;
-        ALfloat LateReverbGain;
-        ALfloat LateReverbDelay;
-        ALfloat AirAbsorptionGainHF;
-        ALfloat RoomRolloffFactor;
-        bool DecayHFLimit;
-
-        // Additional EAX Reverb Properties
-        ALfloat GainLF;
-        ALfloat DecayLFRatio;
-        ALfloat ReflectionsPan[3];
-        ALfloat LateReverbPan[3];
-        ALfloat EchoTime;
-        ALfloat EchoDepth;
-        ALfloat ModulationTime;
-        ALfloat ModulationDepth;
-        ALfloat HFReference;
-        ALfloat LFReference;
-    } Reverb;
-
-    struct {
-        ALfloat AttackTime;
-        ALfloat ReleaseTime;
-        ALfloat Resonance;
-        ALfloat PeakGain;
-    } Autowah;
-
-    struct {
-        ALint Waveform;
-        ALint Phase;
-        ALfloat Rate;
-        ALfloat Depth;
-        ALfloat Feedback;
-        ALfloat Delay;
-    } Chorus; /* Also Flanger */
-
-    struct {
-        bool OnOff;
-    } Compressor;
-
-    struct {
-        ALfloat Edge;
-        ALfloat Gain;
-        ALfloat LowpassCutoff;
-        ALfloat EQCenter;
-        ALfloat EQBandwidth;
-    } Distortion;
-
-    struct {
-        ALfloat Delay;
-        ALfloat LRDelay;
-
-        ALfloat Damping;
-        ALfloat Feedback;
-
-        ALfloat Spread;
-    } Echo;
-
-    struct {
-        ALfloat LowCutoff;
-        ALfloat LowGain;
-        ALfloat Mid1Center;
-        ALfloat Mid1Gain;
-        ALfloat Mid1Width;
-        ALfloat Mid2Center;
-        ALfloat Mid2Gain;
-        ALfloat Mid2Width;
-        ALfloat HighCutoff;
-        ALfloat HighGain;
-    } Equalizer;
-
-    struct {
-        ALfloat Frequency;
-        ALint LeftDirection;
-        ALint RightDirection;
-    } Fshifter;
-
-    struct {
-        ALfloat Frequency;
-        ALfloat HighPassCutoff;
-        ALint Waveform;
-    } Modulator;
-
-    struct {
-        ALint CoarseTune;
-        ALint FineTune;
-    } Pshifter;
-
-    struct {
-        ALfloat Rate;
-        ALint PhonemeA;
-        ALint PhonemeB;
-        ALint PhonemeACoarseTuning;
-        ALint PhonemeBCoarseTuning;
-        ALint Waveform;
-    } Vmorpher;
-
-    struct {
-        ALfloat Gain;
-    } Dedicated;
-};
-
-
-struct EffectVtable {
-    void (*const setParami)(EffectProps *props, ALCcontext *context, ALenum param, ALint val);
-    void (*const setParamiv)(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals);
-    void (*const setParamf)(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val);
-    void (*const setParamfv)(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals);
-
-    void (*const getParami)(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val);
-    void (*const getParamiv)(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals);
-    void (*const getParamf)(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val);
-    void (*const getParamfv)(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals);
-};
-
-#define DEFINE_ALEFFECT_VTABLE(T)           \
-const EffectVtable T##_vtable = {           \
-    T##_setParami, T##_setParamiv,          \
-    T##_setParamf, T##_setParamfv,          \
-    T##_getParami, T##_getParamiv,          \
-    T##_getParamf, T##_getParamfv,          \
-}
-
-
-struct EffectTarget {
-    MixParams *Main;
-    RealMixParams *RealOut;
-};
-
-struct EffectState : public al::intrusive_ref<EffectState> {
-    al::span<FloatBufferLine> mOutTarget;
-
-
-    virtual ~EffectState() = default;
-
-    virtual ALboolean deviceUpdate(const ALCdevice *device) = 0;
-    virtual void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) = 0;
-    virtual void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) = 0;
-};
-
-
-struct EffectStateFactory {
-    virtual ~EffectStateFactory() { }
-
-    virtual EffectState *create() = 0;
-    virtual EffectProps getDefaultProps() const noexcept = 0;
-    virtual const EffectVtable *getEffectVtable() const noexcept = 0;
-};
+#include "core/effects/base.h"
 
 
 EffectStateFactory *NullStateFactory_getFactory(void);
@@ -189,5 +21,6 @@ EffectStateFactory* VmorpherStateFactory_getFactory(void);
 
 EffectStateFactory *DedicatedStateFactory_getFactory(void);
 
+EffectStateFactory *ConvolutionStateFactory_getFactory(void);
 
 #endif /* EFFECTS_BASE_H */
diff --git a/alc/effects/chorus.cpp b/alc/effects/chorus.cpp
index 59e05be0..10ccf9f6 100644
--- a/alc/effects/chorus.cpp
+++ b/alc/effects/chorus.cpp
@@ -21,158 +21,122 @@
 #include "config.h"
 
 #include <algorithm>
+#include <array>
 #include <climits>
-#include <cmath>
 #include <cstdlib>
 #include <iterator>
 
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "AL/efx.h"
-
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
+#include "alc/effects/base.h"
 #include "almalloc.h"
+#include "alnumbers.h"
 #include "alnumeric.h"
 #include "alspan.h"
-#include "alu.h"
-#include "ambidefs.h"
-#include "effects/base.h"
-#include "math_defs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "core/resampler_limits.h"
+#include "intrusive_ptr.h"
 #include "opthelpers.h"
 #include "vector.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");
-
-enum class WaveForm {
-    Sinusoid,
-    Triangle
-};
+using uint = unsigned int;
 
-void GetTriangleDelays(ALuint *delays, const ALuint start_offset, const ALuint lfo_range,
-    const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const size_t todo)
-{
-    ASSUME(lfo_range > 0);
-    ASSUME(todo > 0);
-
-    ALuint offset{start_offset};
-    auto gen_lfo = [&offset,lfo_range,lfo_scale,depth,delay]() -> ALuint
-    {
-        offset = (offset+1)%lfo_range;
-        const float offset_norm{static_cast<float>(offset) * lfo_scale};
-        return static_cast<ALuint>(fastf2i((1.0f-std::abs(2.0f-offset_norm)) * depth) + delay);
-    };
-    std::generate_n(delays, todo, gen_lfo);
-}
-
-void GetSinusoidDelays(ALuint *delays, const ALuint start_offset, const ALuint lfo_range,
-    const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const size_t todo)
-{
-    ASSUME(lfo_range > 0);
-    ASSUME(todo > 0);
+struct ChorusState final : public EffectState {
+    al::vector<float,16> mDelayBuffer;
+    uint mOffset{0};
 
-    ALuint offset{start_offset};
-    auto gen_lfo = [&offset,lfo_range,lfo_scale,depth,delay]() -> ALuint
-    {
-        offset = (offset+1)%lfo_range;
-        const float offset_norm{static_cast<float>(offset) * lfo_scale};
-        return static_cast<ALuint>(fastf2i(std::sin(offset_norm)*depth) + delay);
-    };
-    std::generate_n(delays, todo, gen_lfo);
-}
+    uint mLfoOffset{0};
+    uint mLfoRange{1};
+    float mLfoScale{0.0f};
+    uint mLfoDisp{0};
 
-struct ChorusState final : public EffectState {
-    al::vector<ALfloat,16> mSampleBuffer;
-    ALuint mOffset{0};
+    /* Calculated delays to apply to the left and right outputs. */
+    uint mModDelays[2][BufferLineSize];
 
-    ALuint mLfoOffset{0};
-    ALuint mLfoRange{1};
-    ALfloat mLfoScale{0.0f};
-    ALuint mLfoDisp{0};
+    /* Temp storage for the modulated left and right outputs. */
+    alignas(16) float mBuffer[2][BufferLineSize];
 
-    /* Gains for left and right sides */
+    /* Gains for left and right outputs. */
     struct {
-        ALfloat Current[MAX_OUTPUT_CHANNELS]{};
-        ALfloat Target[MAX_OUTPUT_CHANNELS]{};
+        float Current[MaxAmbiChannels]{};
+        float Target[MaxAmbiChannels]{};
     } mGains[2];
 
     /* effect parameters */
-    WaveForm mWaveform{};
-    ALint mDelay{0};
-    ALfloat mDepth{0.0f};
-    ALfloat mFeedback{0.0f};
+    ChorusWaveform mWaveform{};
+    int mDelay{0};
+    float mDepth{0.0f};
+    float mFeedback{0.0f};
 
+    void calcTriangleDelays(const size_t todo);
+    void calcSinusoidDelays(const size_t todo);
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(ChorusState)
 };
 
-ALboolean ChorusState::deviceUpdate(const ALCdevice *Device)
+void ChorusState::deviceUpdate(const DeviceBase *Device, const BufferStorage*)
 {
-    constexpr ALfloat max_delay{maxf(AL_CHORUS_MAX_DELAY, AL_FLANGER_MAX_DELAY)};
+    constexpr float max_delay{maxf(ChorusMaxDelay, FlangerMaxDelay)};
 
     const auto frequency = static_cast<float>(Device->Frequency);
     const size_t maxlen{NextPowerOf2(float2uint(max_delay*2.0f*frequency) + 1u)};
-    if(maxlen != mSampleBuffer.size())
-    {
-        mSampleBuffer.resize(maxlen);
-        mSampleBuffer.shrink_to_fit();
-    }
+    if(maxlen != mDelayBuffer.size())
+        decltype(mDelayBuffer)(maxlen).swap(mDelayBuffer);
 
-    std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), 0.0f);
+    std::fill(mDelayBuffer.begin(), mDelayBuffer.end(), 0.0f);
     for(auto &e : mGains)
     {
         std::fill(std::begin(e.Current), std::end(e.Current), 0.0f);
         std::fill(std::begin(e.Target), std::end(e.Target), 0.0f);
     }
-
-    return AL_TRUE;
 }
 
-void ChorusState::update(const ALCcontext *Context, const ALeffectslot *Slot, const EffectProps *props, const EffectTarget target)
+void ChorusState::update(const ContextBase *Context, const EffectSlot *Slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    constexpr ALsizei mindelay{(MAX_RESAMPLER_PADDING>>1) << FRACTIONBITS};
-
-    switch(props->Chorus.Waveform)
-    {
-        case AL_CHORUS_WAVEFORM_TRIANGLE:
-            mWaveform = WaveForm::Triangle;
-            break;
-        case AL_CHORUS_WAVEFORM_SINUSOID:
-            mWaveform = WaveForm::Sinusoid;
-            break;
-    }
+    constexpr int mindelay{(MaxResamplerPadding>>1) << MixerFracBits};
 
     /* The LFO depth is scaled to be relative to the sample delay. Clamp the
      * delay and depth to allow enough padding for resampling.
      */
-    const ALCdevice *device{Context->mDevice.get()};
+    const DeviceBase *device{Context->mDevice};
     const auto frequency = static_cast<float>(device->Frequency);
 
-    mDelay = maxi(float2int(props->Chorus.Delay*frequency*FRACTIONONE + 0.5f), mindelay);
+    mWaveform = props->Chorus.Waveform;
+
+    mDelay = maxi(float2int(props->Chorus.Delay*frequency*MixerFracOne + 0.5f), mindelay);
     mDepth = minf(props->Chorus.Depth * static_cast<float>(mDelay),
         static_cast<float>(mDelay - mindelay));
 
     mFeedback = props->Chorus.Feedback;
 
     /* Gains for left and right sides */
-    ALfloat coeffs[2][MAX_AMBI_CHANNELS];
-    CalcDirectionCoeffs({-1.0f, 0.0f, 0.0f}, 0.0f, coeffs[0]);
-    CalcDirectionCoeffs({ 1.0f, 0.0f, 0.0f}, 0.0f, coeffs[1]);
+    static constexpr auto inv_sqrt2 = static_cast<float>(1.0 / al::numbers::sqrt2);
+    static constexpr auto lcoeffs_pw = CalcDirectionCoeffs({-1.0f, 0.0f, 0.0f});
+    static constexpr auto rcoeffs_pw = CalcDirectionCoeffs({ 1.0f, 0.0f, 0.0f});
+    static constexpr auto lcoeffs_nrml = CalcDirectionCoeffs({-inv_sqrt2, 0.0f, inv_sqrt2});
+    static constexpr auto rcoeffs_nrml = CalcDirectionCoeffs({ inv_sqrt2, 0.0f, inv_sqrt2});
+    auto &lcoeffs = (device->mRenderMode != RenderMode::Pairwise) ? lcoeffs_nrml : lcoeffs_pw;
+    auto &rcoeffs = (device->mRenderMode != RenderMode::Pairwise) ? rcoeffs_nrml : rcoeffs_pw;
 
     mOutTarget = target.Main->Buffer;
-    ComputePanGains(target.Main, coeffs[0], Slot->Params.Gain, mGains[0].Target);
-    ComputePanGains(target.Main, coeffs[1], Slot->Params.Gain, mGains[1].Target);
+    ComputePanGains(target.Main, lcoeffs.data(), Slot->Gain, mGains[0].Target);
+    ComputePanGains(target.Main, rcoeffs.data(), Slot->Gain, mGains[1].Target);
 
-    ALfloat rate{props->Chorus.Rate};
+    float rate{props->Chorus.Rate};
     if(!(rate > 0.0f))
     {
         mLfoOffset = 0;
@@ -185,340 +149,172 @@ void ChorusState::update(const ALCcontext *Context, const ALeffectslot *Slot, co
         /* Calculate LFO coefficient (number of samples per cycle). Limit the
          * max range to avoid overflow when calculating the displacement.
          */
-        ALuint lfo_range{float2uint(minf(frequency/rate + 0.5f, ALfloat{INT_MAX/360 - 180}))};
+        uint lfo_range{float2uint(minf(frequency/rate + 0.5f, float{INT_MAX/360 - 180}))};
 
         mLfoOffset = mLfoOffset * lfo_range / mLfoRange;
         mLfoRange = lfo_range;
         switch(mWaveform)
         {
-            case WaveForm::Triangle:
-                mLfoScale = 4.0f / static_cast<float>(mLfoRange);
-                break;
-            case WaveForm::Sinusoid:
-                mLfoScale = al::MathDefs<float>::Tau() / static_cast<float>(mLfoRange);
-                break;
+        case ChorusWaveform::Triangle:
+            mLfoScale = 4.0f / static_cast<float>(mLfoRange);
+            break;
+        case ChorusWaveform::Sinusoid:
+            mLfoScale = al::numbers::pi_v<float>*2.0f / static_cast<float>(mLfoRange);
+            break;
         }
 
         /* Calculate lfo phase displacement */
-        ALint phase{props->Chorus.Phase};
+        int phase{props->Chorus.Phase};
         if(phase < 0) phase = 360 + phase;
-        mLfoDisp = (mLfoRange*static_cast<ALuint>(phase) + 180) / 360;
-    }
-}
-
-void ChorusState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
-{
-    const size_t bufmask{mSampleBuffer.size()-1};
-    const ALfloat feedback{mFeedback};
-    const ALuint avgdelay{(static_cast<ALuint>(mDelay) + (FRACTIONONE>>1)) >> FRACTIONBITS};
-    ALfloat *RESTRICT delaybuf{mSampleBuffer.data()};
-    ALuint offset{mOffset};
-
-    for(size_t base{0u};base < samplesToDo;)
-    {
-        const size_t todo{minz(256, samplesToDo-base)};
-
-        ALuint moddelays[2][256];
-        if(mWaveform == WaveForm::Sinusoid)
-        {
-            GetSinusoidDelays(moddelays[0], mLfoOffset, mLfoRange, mLfoScale, mDepth, mDelay,
-                              todo);
-            GetSinusoidDelays(moddelays[1], (mLfoOffset+mLfoDisp)%mLfoRange, mLfoRange, mLfoScale,
-                              mDepth, mDelay, todo);
-        }
-        else /*if(mWaveform == WaveForm::Triangle)*/
-        {
-            GetTriangleDelays(moddelays[0], mLfoOffset, mLfoRange, mLfoScale, mDepth, mDelay,
-                              todo);
-            GetTriangleDelays(moddelays[1], (mLfoOffset+mLfoDisp)%mLfoRange, mLfoRange, mLfoScale,
-                              mDepth, mDelay, todo);
-        }
-        mLfoOffset = (mLfoOffset+static_cast<ALuint>(todo)) % mLfoRange;
-
-        alignas(16) ALfloat temps[2][256];
-        for(size_t i{0u};i < todo;i++)
-        {
-            // Feed the buffer's input first (necessary for delays < 1).
-            delaybuf[offset&bufmask] = samplesIn[0][base+i];
-
-            // Tap for the left output.
-            ALuint delay{offset - (moddelays[0][i]>>FRACTIONBITS)};
-            ALfloat mu{static_cast<float>(moddelays[0][i]&FRACTIONMASK) * (1.0f/FRACTIONONE)};
-            temps[0][i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay  ) & bufmask],
-                delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask], mu);
-
-            // Tap for the right output.
-            delay = offset - (moddelays[1][i]>>FRACTIONBITS);
-            mu = static_cast<float>(moddelays[1][i]&FRACTIONMASK) * (1.0f/FRACTIONONE);
-            temps[1][i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay  ) & bufmask],
-                delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask], mu);
-
-            // Accumulate feedback from the average delay of the taps.
-            delaybuf[offset&bufmask] += delaybuf[(offset-avgdelay) & bufmask] * feedback;
-            ++offset;
-        }
-
-        for(ALsizei c{0};c < 2;c++)
-            MixSamples({temps[c], todo}, samplesOut, mGains[c].Current, mGains[c].Target,
-                samplesToDo-base, base);
-
-        base += todo;
+        mLfoDisp = (mLfoRange*static_cast<uint>(phase) + 180) / 360;
     }
-
-    mOffset = offset;
 }
 
 
-void Chorus_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
+void ChorusState::calcTriangleDelays(const size_t todo)
 {
-    switch(param)
-    {
-        case AL_CHORUS_WAVEFORM:
-            if(!(val >= AL_CHORUS_MIN_WAVEFORM && val <= AL_CHORUS_MAX_WAVEFORM))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid chorus waveform");
-            props->Chorus.Waveform = val;
-            break;
+    const uint lfo_range{mLfoRange};
+    const float lfo_scale{mLfoScale};
+    const float depth{mDepth};
+    const int delay{mDelay};
 
-        case AL_CHORUS_PHASE:
-            if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus phase out of range");
-            props->Chorus.Phase = val;
-            break;
+    ASSUME(lfo_range > 0);
+    ASSUME(todo > 0);
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param);
-    }
-}
-void Chorus_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Chorus_setParami(props, context, param, vals[0]); }
-void Chorus_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
+    auto gen_lfo = [lfo_scale,depth,delay](const uint offset) -> uint
     {
-        case AL_CHORUS_RATE:
-            if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus rate out of range");
-            props->Chorus.Rate = val;
-            break;
-
-        case AL_CHORUS_DEPTH:
-            if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus depth out of range");
-            props->Chorus.Depth = val;
-            break;
-
-        case AL_CHORUS_FEEDBACK:
-            if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus feedback out of range");
-            props->Chorus.Feedback = val;
-            break;
-
-        case AL_CHORUS_DELAY:
-            if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Chorus delay out of range");
-            props->Chorus.Delay = val;
-            break;
+        const float offset_norm{static_cast<float>(offset) * lfo_scale};
+        return static_cast<uint>(fastf2i((1.0f-std::abs(2.0f-offset_norm)) * depth) + delay);
+    };
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param);
+    uint offset{mLfoOffset};
+    for(size_t i{0};i < todo;)
+    {
+        size_t rem{minz(todo-i, lfo_range-offset)};
+        do {
+            mModDelays[0][i++] = gen_lfo(offset++);
+        } while(--rem);
+        if(offset == lfo_range)
+            offset = 0;
     }
-}
-void Chorus_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Chorus_setParamf(props, context, param, vals[0]); }
 
-void Chorus_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
+    offset = (mLfoOffset+mLfoDisp) % lfo_range;
+    for(size_t i{0};i < todo;)
     {
-        case AL_CHORUS_WAVEFORM:
-            *val = props->Chorus.Waveform;
-            break;
-
-        case AL_CHORUS_PHASE:
-            *val = props->Chorus.Phase;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param);
+        size_t rem{minz(todo-i, lfo_range-offset)};
+        do {
+            mModDelays[1][i++] = gen_lfo(offset++);
+        } while(--rem);
+        if(offset == lfo_range)
+            offset = 0;
     }
-}
-void Chorus_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Chorus_getParami(props, context, param, vals); }
-void Chorus_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param);
-    }
+    mLfoOffset = static_cast<uint>(mLfoOffset+todo) % lfo_range;
 }
-void Chorus_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Chorus_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Chorus);
 
-
-struct ChorusStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new ChorusState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Chorus_vtable; }
-};
-
-EffectProps ChorusStateFactory::getDefaultProps() const noexcept
+void ChorusState::calcSinusoidDelays(const size_t todo)
 {
-    EffectProps props{};
-    props.Chorus.Waveform = 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;
-}
+    const uint lfo_range{mLfoRange};
+    const float lfo_scale{mLfoScale};
+    const float depth{mDepth};
+    const int delay{mDelay};
 
+    ASSUME(lfo_range > 0);
+    ASSUME(todo > 0);
 
-void Flanger_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
+    auto gen_lfo = [lfo_scale,depth,delay](const uint offset) -> uint
     {
-        case AL_FLANGER_WAVEFORM:
-            if(!(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid flanger waveform");
-            props->Chorus.Waveform = val;
-            break;
-
-        case AL_FLANGER_PHASE:
-            if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger phase out of range");
-            props->Chorus.Phase = val;
-            break;
+        const float offset_norm{static_cast<float>(offset) * lfo_scale};
+        return static_cast<uint>(fastf2i(std::sin(offset_norm)*depth) + delay);
+    };
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param);
-    }
-}
-void Flanger_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Flanger_setParami(props, context, param, vals[0]); }
-void Flanger_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
+    uint offset{mLfoOffset};
+    for(size_t i{0};i < todo;)
     {
-        case AL_FLANGER_RATE:
-            if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger rate out of range");
-            props->Chorus.Rate = val;
-            break;
-
-        case AL_FLANGER_DEPTH:
-            if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger depth out of range");
-            props->Chorus.Depth = val;
-            break;
-
-        case AL_FLANGER_FEEDBACK:
-            if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger feedback out of range");
-            props->Chorus.Feedback = val;
-            break;
-
-        case AL_FLANGER_DELAY:
-            if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Flanger delay out of range");
-            props->Chorus.Delay = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param);
+        size_t rem{minz(todo-i, lfo_range-offset)};
+        do {
+            mModDelays[0][i++] = gen_lfo(offset++);
+        } while(--rem);
+        if(offset == lfo_range)
+            offset = 0;
     }
-}
-void Flanger_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Flanger_setParamf(props, context, param, vals[0]); }
 
-void Flanger_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
+    offset = (mLfoOffset+mLfoDisp) % lfo_range;
+    for(size_t i{0};i < todo;)
     {
-        case AL_FLANGER_WAVEFORM:
-            *val = props->Chorus.Waveform;
-            break;
-
-        case AL_FLANGER_PHASE:
-            *val = props->Chorus.Phase;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param);
+        size_t rem{minz(todo-i, lfo_range-offset)};
+        do {
+            mModDelays[1][i++] = gen_lfo(offset++);
+        } while(--rem);
+        if(offset == lfo_range)
+            offset = 0;
     }
+
+    mLfoOffset = static_cast<uint>(mLfoOffset+todo) % lfo_range;
 }
-void Flanger_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Flanger_getParami(props, context, param, vals); }
-void Flanger_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val)
+
+void ChorusState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    switch(param)
+    const size_t bufmask{mDelayBuffer.size()-1};
+    const float feedback{mFeedback};
+    const uint avgdelay{(static_cast<uint>(mDelay) + MixerFracHalf) >> MixerFracBits};
+    float *RESTRICT delaybuf{mDelayBuffer.data()};
+    uint offset{mOffset};
+
+    if(mWaveform == ChorusWaveform::Sinusoid)
+        calcSinusoidDelays(samplesToDo);
+    else /*if(mWaveform == ChorusWaveform::Triangle)*/
+        calcTriangleDelays(samplesToDo);
+
+    const uint *RESTRICT ldelays{mModDelays[0]};
+    const uint *RESTRICT rdelays{mModDelays[1]};
+    float *RESTRICT lbuffer{al::assume_aligned<16>(mBuffer[0])};
+    float *RESTRICT rbuffer{al::assume_aligned<16>(mBuffer[1])};
+    for(size_t i{0u};i < samplesToDo;++i)
     {
-        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;
+        // Feed the buffer's input first (necessary for delays < 1).
+        delaybuf[offset&bufmask] = samplesIn[0][i];
+
+        // Tap for the left output.
+        uint delay{offset - (ldelays[i]>>MixerFracBits)};
+        float mu{static_cast<float>(ldelays[i]&MixerFracMask) * (1.0f/MixerFracOne)};
+        lbuffer[i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay  ) & bufmask],
+            delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask], mu);
+
+        // Tap for the right output.
+        delay = offset - (rdelays[i]>>MixerFracBits);
+        mu = static_cast<float>(rdelays[i]&MixerFracMask) * (1.0f/MixerFracOne);
+        rbuffer[i] = cubic(delaybuf[(delay+1) & bufmask], delaybuf[(delay  ) & bufmask],
+            delaybuf[(delay-1) & bufmask], delaybuf[(delay-2) & bufmask], mu);
+
+        // Accumulate feedback from the average delay of the taps.
+        delaybuf[offset&bufmask] += delaybuf[(offset-avgdelay) & bufmask] * feedback;
+        ++offset;
+    }
 
-        case AL_FLANGER_DELAY:
-            *val = props->Chorus.Delay;
-            break;
+    MixSamples({lbuffer, samplesToDo}, samplesOut, mGains[0].Current, mGains[0].Target,
+        samplesToDo, 0);
+    MixSamples({rbuffer, samplesToDo}, samplesOut, mGains[1].Current, mGains[1].Target,
+        samplesToDo, 0);
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param);
-    }
+    mOffset = offset;
 }
-void Flanger_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Flanger_getParamf(props, context, param, vals); }
 
-DEFINE_ALEFFECT_VTABLE(Flanger);
+
+struct ChorusStateFactory final : public EffectStateFactory {
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ChorusState{}}; }
+};
 
 
 /* Flanger is basically a chorus with a really short delay. They can both use
  * the same processing functions, so piggyback flanger on the chorus functions.
  */
 struct FlangerStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new ChorusState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Flanger_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ChorusState{}}; }
 };
 
-EffectProps FlangerStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Chorus.Waveform = 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
 
 EffectStateFactory *ChorusStateFactory_getFactory()
diff --git a/alc/effects/compressor.cpp b/alc/effects/compressor.cpp
index 44ffaaef..0a7ed67a 100644
--- a/alc/effects/compressor.cpp
+++ b/alc/effects/compressor.cpp
@@ -1,32 +1,56 @@
 /**
- * OpenAL cross platform audio library
+ * This file is part of the OpenAL Soft cross platform audio library
+ *
  * Copyright (C) 2013 by Anis A. Hireche
- * 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.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
  *
- * 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
+ * * Neither the name of Spherical-Harmonic-Transform nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
+#include <array>
 #include <cstdlib>
+#include <iterator>
+#include <utility>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "intrusive_ptr.h"
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "vecmat.h"
+struct ContextBase;
 
 
 namespace {
@@ -40,60 +64,66 @@ namespace {
 
 struct CompressorState final : public EffectState {
     /* Effect gains for each channel */
-    ALfloat mGain[MAX_AMBI_CHANNELS][MAX_OUTPUT_CHANNELS]{};
+    struct {
+        uint mTarget{InvalidChannelIndex};
+        float mGain{1.0f};
+    } mChans[MaxAmbiChannels];
 
     /* Effect parameters */
-    ALboolean mEnabled{AL_TRUE};
-    ALfloat mAttackMult{1.0f};
-    ALfloat mReleaseMult{1.0f};
-    ALfloat mEnvFollower{1.0f};
+    bool mEnabled{true};
+    float mAttackMult{1.0f};
+    float mReleaseMult{1.0f};
+    float mEnvFollower{1.0f};
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(CompressorState)
 };
 
-ALboolean CompressorState::deviceUpdate(const ALCdevice *device)
+void CompressorState::deviceUpdate(const DeviceBase *device, const BufferStorage*)
 {
     /* Number of samples to do a full attack and release (non-integer sample
      * counts are okay).
      */
-    const ALfloat attackCount  = static_cast<ALfloat>(device->Frequency) * ATTACK_TIME;
-    const ALfloat releaseCount = static_cast<ALfloat>(device->Frequency) * RELEASE_TIME;
+    const float attackCount{static_cast<float>(device->Frequency) * ATTACK_TIME};
+    const float releaseCount{static_cast<float>(device->Frequency) * RELEASE_TIME};
 
     /* Calculate per-sample multipliers to attack and release at the desired
      * rates.
      */
     mAttackMult  = std::pow(AMP_ENVELOPE_MAX/AMP_ENVELOPE_MIN, 1.0f/attackCount);
     mReleaseMult = std::pow(AMP_ENVELOPE_MIN/AMP_ENVELOPE_MAX, 1.0f/releaseCount);
-
-    return AL_TRUE;
 }
 
-void CompressorState::update(const ALCcontext*, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void CompressorState::update(const ContextBase*, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
     mEnabled = props->Compressor.OnOff;
 
     mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
+    auto set_channel = [this](size_t idx, uint outchan, float outgain)
     {
-        auto coeffs = GetAmbiIdentityRow(i);
-        ComputePanGains(target.Main, coeffs.data(), slot->Params.Gain, mGain[i]);
-    }
+        mChans[idx].mTarget = outchan;
+        mChans[idx].mGain = outgain;
+    };
+    target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 }
 
-void CompressorState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
+void CompressorState::process(const size_t samplesToDo,
+    const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
     for(size_t base{0u};base < samplesToDo;)
     {
-        ALfloat gains[256];
+        float gains[256];
         const size_t td{minz(256, samplesToDo-base)};
 
         /* Generate the per-sample gains from the signal envelope. */
-        ALfloat env{mEnvFollower};
+        float env{mEnvFollower};
         if(mEnabled)
         {
             for(size_t i{0u};i < td;++i)
@@ -101,7 +131,7 @@ void CompressorState::process(const size_t samplesToDo, const al::span<const Flo
                 /* Clamp the absolute amplitude to the defined envelope limits,
                  * then attack or release the envelope to reach it.
                  */
-                const ALfloat amplitude{clampf(std::fabs(samplesIn[0][base+i]), AMP_ENVELOPE_MIN,
+                const float amplitude{clampf(std::fabs(samplesIn[0][base+i]), AMP_ENVELOPE_MIN,
                     AMP_ENVELOPE_MAX)};
                 if(amplitude > env)
                     env = minf(env*mAttackMult, amplitude);
@@ -122,7 +152,7 @@ void CompressorState::process(const size_t samplesToDo, const al::span<const Flo
              */
             for(size_t i{0u};i < td;++i)
             {
-                const ALfloat amplitude{1.0f};
+                const float amplitude{1.0f};
                 if(amplitude > env)
                     env = minf(env*mAttackMult, amplitude);
                 else if(amplitude < env)
@@ -134,19 +164,22 @@ void CompressorState::process(const size_t samplesToDo, const al::span<const Flo
         mEnvFollower = env;
 
         /* Now compress the signal amplitude to output. */
-        auto changains = std::addressof(mGain[0]);
+        auto chan = std::cbegin(mChans);
         for(const auto &input : samplesIn)
         {
-            const ALfloat *outgains{*(changains++)};
-            for(FloatBufferLine &output : samplesOut)
+            const size_t outidx{chan->mTarget};
+            if(outidx != InvalidChannelIndex)
             {
-                const ALfloat gain{*(outgains++)};
-                if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-                    continue;
-
-                for(size_t i{0u};i < td;i++)
-                    output[base+i] += input[base+i] * gains[i] * gain;
+                const float *RESTRICT src{input.data() + base};
+                float *RESTRICT dst{samplesOut[outidx].data() + base};
+                const float gain{chan->mGain};
+                if(!(std::fabs(gain) > GainSilenceThreshold))
+                {
+                    for(size_t i{0u};i < td;i++)
+                        dst[i] += src[i] * gains[i] * gain;
+                }
             }
+            ++chan;
         }
 
         base += td;
@@ -154,64 +187,11 @@ void CompressorState::process(const size_t samplesToDo, const al::span<const Flo
 }
 
 
-void Compressor_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_COMPRESSOR_ONOFF:
-            if(!(val >= AL_COMPRESSOR_MIN_ONOFF && val <= AL_COMPRESSOR_MAX_ONOFF))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Compressor state out of range");
-            props->Compressor.OnOff = val != AL_FALSE;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
-                param);
-    }
-}
-void Compressor_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Compressor_setParami(props, context, param, vals[0]); }
-void Compressor_setParamf(EffectProps*, ALCcontext *context, ALenum param, ALfloat)
-{ context->setError(AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param); }
-void Compressor_setParamfv(EffectProps*, ALCcontext *context, ALenum param, const ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x", param); }
-
-void Compressor_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{ 
-    switch(param)
-    {
-        case AL_COMPRESSOR_ONOFF:
-            *val = props->Compressor.OnOff;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid compressor integer property 0x%04x",
-                param);
-    }
-}
-void Compressor_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Compressor_getParami(props, context, param, vals); }
-void Compressor_getParamf(const EffectProps*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid compressor float property 0x%04x", param); }
-void Compressor_getParamfv(const EffectProps*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid compressor float-vector property 0x%04x", param); }
-
-DEFINE_ALEFFECT_VTABLE(Compressor);
-
-
 struct CompressorStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new CompressorState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Compressor_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new CompressorState{}}; }
 };
 
-EffectProps CompressorStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Compressor.OnOff = AL_COMPRESSOR_DEFAULT_ONOFF;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *CompressorStateFactory_getFactory()
diff --git a/alc/effects/convolution.cpp b/alc/effects/convolution.cpp
new file mode 100644
index 00000000..7f36c415
--- /dev/null
+++ b/alc/effects/convolution.cpp
@@ -0,0 +1,636 @@
+
+#include "config.h"
+
+#include <algorithm>
+#include <array>
+#include <complex>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <stdint.h>
+#include <utility>
+
+#ifdef HAVE_SSE_INTRINSICS
+#include <xmmintrin.h>
+#elif defined(HAVE_NEON)
+#include <arm_neon.h>
+#endif
+
+#include "albyte.h"
+#include "alcomplex.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "base.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/buffer_storage.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/splitter.h"
+#include "core/fmt_traits.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
+#include "polyphase_resampler.h"
+#include "vector.h"
+
+
+namespace {
+
+/* Convolution reverb is implemented using a segmented overlap-add method. The
+ * impulse response is broken up into multiple segments of 128 samples, and
+ * each segment has an FFT applied with a 256-sample buffer (the latter half
+ * left silent) to get its frequency-domain response. The resulting response
+ * has its positive/non-mirrored frequencies saved (129 bins) in each segment.
+ *
+ * Input samples are similarly broken up into 128-sample segments, with an FFT
+ * applied to each new incoming segment to get its 129 bins. A history of FFT'd
+ * input segments is maintained, equal to the length of the impulse response.
+ *
+ * To apply the reverberation, each impulse response segment is convolved with
+ * its paired input segment (using complex multiplies, far cheaper than FIRs),
+ * accumulating into a 256-bin FFT buffer. The input history is then shifted to
+ * align with later impulse response segments for next time.
+ *
+ * An inverse FFT is then applied to the accumulated FFT buffer to get a 256-
+ * sample time-domain response for output, which is split in two halves. The
+ * first half is the 128-sample output, and the second half is a 128-sample
+ * (really, 127) delayed extension, which gets added to the output next time.
+ * Convolving two time-domain responses of lengths N and M results in a time-
+ * domain signal of length N+M-1, and this holds true regardless of the
+ * convolution being applied in the frequency domain, so these "overflow"
+ * samples need to be accounted for.
+ *
+ * To avoid a delay with gathering enough input samples to apply an FFT with,
+ * the first segment is applied directly in the time-domain as the samples come
+ * in. Once enough have been retrieved, the FFT is applied on the input and
+ * it's paired with the remaining (FFT'd) filter segments for processing.
+ */
+
+
+void LoadSamples(float *RESTRICT dst, const al::byte *src, const size_t srcstep, FmtType srctype,
+    const size_t samples) noexcept
+{
+#define HANDLE_FMT(T)  case T: al::LoadSampleArray<T>(dst, src, srcstep, samples); break
+    switch(srctype)
+    {
+    HANDLE_FMT(FmtUByte);
+    HANDLE_FMT(FmtShort);
+    HANDLE_FMT(FmtFloat);
+    HANDLE_FMT(FmtDouble);
+    HANDLE_FMT(FmtMulaw);
+    HANDLE_FMT(FmtAlaw);
+    /* FIXME: Handle ADPCM decoding here. */
+    case FmtIMA4:
+    case FmtMSADPCM:
+        std::fill_n(dst, samples, 0.0f);
+        break;
+    }
+#undef HANDLE_FMT
+}
+
+
+inline auto& GetAmbiScales(AmbiScaling scaletype) noexcept
+{
+    switch(scaletype)
+    {
+    case AmbiScaling::FuMa: return AmbiScale::FromFuMa();
+    case AmbiScaling::SN3D: return AmbiScale::FromSN3D();
+    case AmbiScaling::UHJ: return AmbiScale::FromUHJ();
+    case AmbiScaling::N3D: break;
+    }
+    return AmbiScale::FromN3D();
+}
+
+inline auto& GetAmbiLayout(AmbiLayout layouttype) noexcept
+{
+    if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa();
+    return AmbiIndex::FromACN();
+}
+
+inline auto& GetAmbi2DLayout(AmbiLayout layouttype) noexcept
+{
+    if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D();
+    return AmbiIndex::FromACN2D();
+}
+
+
+struct ChanMap {
+    Channel channel;
+    float angle;
+    float elevation;
+};
+
+constexpr float Deg2Rad(float x) noexcept
+{ return static_cast<float>(al::numbers::pi / 180.0 * x); }
+
+
+using complex_f = std::complex<float>;
+
+constexpr size_t ConvolveUpdateSize{256};
+constexpr size_t ConvolveUpdateSamples{ConvolveUpdateSize / 2};
+
+
+void apply_fir(al::span<float> dst, const float *RESTRICT src, const float *RESTRICT filter)
+{
+#ifdef HAVE_SSE_INTRINSICS
+    for(float &output : dst)
+    {
+        __m128 r4{_mm_setzero_ps()};
+        for(size_t j{0};j < ConvolveUpdateSamples;j+=4)
+        {
+            const __m128 coeffs{_mm_load_ps(&filter[j])};
+            const __m128 s{_mm_loadu_ps(&src[j])};
+
+            r4 = _mm_add_ps(r4, _mm_mul_ps(s, coeffs));
+        }
+        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
+        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+        output = _mm_cvtss_f32(r4);
+
+        ++src;
+    }
+
+#elif defined(HAVE_NEON)
+
+    for(float &output : dst)
+    {
+        float32x4_t r4{vdupq_n_f32(0.0f)};
+        for(size_t j{0};j < ConvolveUpdateSamples;j+=4)
+            r4 = vmlaq_f32(r4, vld1q_f32(&src[j]), vld1q_f32(&filter[j]));
+        r4 = vaddq_f32(r4, vrev64q_f32(r4));
+        output = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
+
+        ++src;
+    }
+
+#else
+
+    for(float &output : dst)
+    {
+        float ret{0.0f};
+        for(size_t j{0};j < ConvolveUpdateSamples;++j)
+            ret += src[j] * filter[j];
+        output = ret;
+        ++src;
+    }
+#endif
+}
+
+struct ConvolutionState final : public EffectState {
+    FmtChannels mChannels{};
+    AmbiLayout mAmbiLayout{};
+    AmbiScaling mAmbiScaling{};
+    uint mAmbiOrder{};
+
+    size_t mFifoPos{0};
+    std::array<float,ConvolveUpdateSamples*2> mInput{};
+    al::vector<std::array<float,ConvolveUpdateSamples>,16> mFilter;
+    al::vector<std::array<float,ConvolveUpdateSamples*2>,16> mOutput;
+
+    alignas(16) std::array<complex_f,ConvolveUpdateSize> mFftBuffer{};
+
+    size_t mCurrentSegment{0};
+    size_t mNumConvolveSegs{0};
+
+    struct ChannelData {
+        alignas(16) FloatBufferLine mBuffer{};
+        float mHfScale{}, mLfScale{};
+        BandSplitter mFilter{};
+        float Current[MAX_OUTPUT_CHANNELS]{};
+        float Target[MAX_OUTPUT_CHANNELS]{};
+    };
+    using ChannelDataArray = al::FlexArray<ChannelData>;
+    std::unique_ptr<ChannelDataArray> mChans;
+    std::unique_ptr<complex_f[]> mComplexData;
+
+
+    ConvolutionState() = default;
+    ~ConvolutionState() override = default;
+
+    void NormalMix(const al::span<FloatBufferLine> samplesOut, const size_t samplesToDo);
+    void UpsampleMix(const al::span<FloatBufferLine> samplesOut, const size_t samplesToDo);
+    void (ConvolutionState::*mMix)(const al::span<FloatBufferLine>,const size_t)
+    {&ConvolutionState::NormalMix};
+
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
+
+    DEF_NEWDEL(ConvolutionState)
+};
+
+void ConvolutionState::NormalMix(const al::span<FloatBufferLine> samplesOut,
+    const size_t samplesToDo)
+{
+    for(auto &chan : *mChans)
+        MixSamples({chan.mBuffer.data(), samplesToDo}, samplesOut, chan.Current, chan.Target,
+            samplesToDo, 0);
+}
+
+void ConvolutionState::UpsampleMix(const al::span<FloatBufferLine> samplesOut,
+    const size_t samplesToDo)
+{
+    for(auto &chan : *mChans)
+    {
+        const al::span<float> src{chan.mBuffer.data(), samplesToDo};
+        chan.mFilter.processScale(src, chan.mHfScale, chan.mLfScale);
+        MixSamples(src, samplesOut, chan.Current, chan.Target, samplesToDo, 0);
+    }
+}
+
+
+void ConvolutionState::deviceUpdate(const DeviceBase *device, const BufferStorage *buffer)
+{
+    using UhjDecoderType = UhjDecoder<512>;
+    static constexpr auto DecoderPadding = UhjDecoderType::sInputPadding;
+
+    constexpr uint MaxConvolveAmbiOrder{1u};
+
+    mFifoPos = 0;
+    mInput.fill(0.0f);
+    decltype(mFilter){}.swap(mFilter);
+    decltype(mOutput){}.swap(mOutput);
+    mFftBuffer.fill(complex_f{});
+
+    mCurrentSegment = 0;
+    mNumConvolveSegs = 0;
+
+    mChans = nullptr;
+    mComplexData = nullptr;
+
+    /* An empty buffer doesn't need a convolution filter. */
+    if(!buffer || buffer->mSampleLen < 1) return;
+
+    mChannels = buffer->mChannels;
+    mAmbiLayout = IsUHJ(mChannels) ? AmbiLayout::FuMa : buffer->mAmbiLayout;
+    mAmbiScaling = IsUHJ(mChannels) ? AmbiScaling::UHJ : buffer->mAmbiScaling;
+    mAmbiOrder = minu(buffer->mAmbiOrder, MaxConvolveAmbiOrder);
+
+    constexpr size_t m{ConvolveUpdateSize/2 + 1};
+    const auto bytesPerSample = BytesFromFmt(buffer->mType);
+    const auto realChannels = buffer->channelsFromFmt();
+    const auto numChannels = (mChannels == FmtUHJ2) ? 3u : ChannelsFromFmt(mChannels, mAmbiOrder);
+
+    mChans = ChannelDataArray::Create(numChannels);
+
+    /* The impulse response needs to have the same sample rate as the input and
+     * output. The bsinc24 resampler is decent, but there is high-frequency
+     * attenuation that some people may be able to pick up on. Since this is
+     * called very infrequently, go ahead and use the polyphase resampler.
+     */
+    PPhaseResampler resampler;
+    if(device->Frequency != buffer->mSampleRate)
+        resampler.init(buffer->mSampleRate, device->Frequency);
+    const auto resampledCount = static_cast<uint>(
+        (uint64_t{buffer->mSampleLen}*device->Frequency+(buffer->mSampleRate-1)) /
+        buffer->mSampleRate);
+
+    const BandSplitter splitter{device->mXOverFreq / static_cast<float>(device->Frequency)};
+    for(auto &e : *mChans)
+        e.mFilter = splitter;
+
+    mFilter.resize(numChannels, {});
+    mOutput.resize(numChannels, {});
+
+    /* Calculate the number of segments needed to hold the impulse response and
+     * the input history (rounded up), and allocate them. Exclude one segment
+     * which gets applied as a time-domain FIR filter. Make sure at least one
+     * segment is allocated to simplify handling.
+     */
+    mNumConvolveSegs = (resampledCount+(ConvolveUpdateSamples-1)) / ConvolveUpdateSamples;
+    mNumConvolveSegs = maxz(mNumConvolveSegs, 2) - 1;
+
+    const size_t complex_length{mNumConvolveSegs * m * (numChannels+1)};
+    mComplexData = std::make_unique<complex_f[]>(complex_length);
+    std::fill_n(mComplexData.get(), complex_length, complex_f{});
+
+    /* Load the samples from the buffer. */
+    const size_t srclinelength{RoundUp(buffer->mSampleLen+DecoderPadding, 16)};
+    auto srcsamples = std::make_unique<float[]>(srclinelength * numChannels);
+    std::fill_n(srcsamples.get(), srclinelength * numChannels, 0.0f);
+    for(size_t c{0};c < numChannels && c < realChannels;++c)
+        LoadSamples(srcsamples.get() + srclinelength*c, buffer->mData.data() + bytesPerSample*c,
+            realChannels, buffer->mType, buffer->mSampleLen);
+
+    if(IsUHJ(mChannels))
+    {
+        auto decoder = std::make_unique<UhjDecoderType>();
+        std::array<float*,4> samples{};
+        for(size_t c{0};c < numChannels;++c)
+            samples[c] = srcsamples.get() + srclinelength*c;
+        decoder->decode({samples.data(), numChannels}, buffer->mSampleLen, buffer->mSampleLen);
+    }
+
+    auto ressamples = std::make_unique<double[]>(buffer->mSampleLen +
+        (resampler ? resampledCount : 0));
+    complex_f *filteriter = mComplexData.get() + mNumConvolveSegs*m;
+    for(size_t c{0};c < numChannels;++c)
+    {
+        /* Resample to match the device. */
+        if(resampler)
+        {
+            std::copy_n(srcsamples.get() + srclinelength*c, buffer->mSampleLen,
+                ressamples.get() + resampledCount);
+            resampler.process(buffer->mSampleLen, ressamples.get()+resampledCount,
+                resampledCount, ressamples.get());
+        }
+        else
+            std::copy_n(srcsamples.get() + srclinelength*c, buffer->mSampleLen, ressamples.get());
+
+        /* Store the first segment's samples in reverse in the time-domain, to
+         * apply as a FIR filter.
+         */
+        const size_t first_size{minz(resampledCount, ConvolveUpdateSamples)};
+        std::transform(ressamples.get(), ressamples.get()+first_size, mFilter[c].rbegin(),
+            [](const double d) noexcept -> float { return static_cast<float>(d); });
+
+        auto fftbuffer = std::vector<std::complex<double>>(ConvolveUpdateSize);
+        size_t done{first_size};
+        for(size_t s{0};s < mNumConvolveSegs;++s)
+        {
+            const size_t todo{minz(resampledCount-done, ConvolveUpdateSamples)};
+
+            auto iter = std::copy_n(&ressamples[done], todo, fftbuffer.begin());
+            done += todo;
+            std::fill(iter, fftbuffer.end(), std::complex<double>{});
+
+            forward_fft(al::as_span(fftbuffer));
+            filteriter = std::copy_n(fftbuffer.cbegin(), m, filteriter);
+        }
+    }
+}
+
+
+void ConvolutionState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps* /*props*/, const EffectTarget target)
+{
+    /* NOTE: Stereo and Rear are slightly different from normal mixing (as
+     * defined in alu.cpp). These are 45 degrees from center, rather than the
+     * 30 degrees used there.
+     *
+     * TODO: LFE is not mixed to output. This will require each buffer channel
+     * to have its own output target since the main mixing buffer won't have an
+     * LFE channel (due to being B-Format).
+     */
+    static constexpr ChanMap MonoMap[1]{
+        { FrontCenter, 0.0f, 0.0f }
+    }, StereoMap[2]{
+        { FrontLeft,  Deg2Rad(-45.0f), Deg2Rad(0.0f) },
+        { FrontRight, Deg2Rad( 45.0f), Deg2Rad(0.0f) }
+    }, RearMap[2]{
+        { BackLeft,  Deg2Rad(-135.0f), Deg2Rad(0.0f) },
+        { BackRight, Deg2Rad( 135.0f), Deg2Rad(0.0f) }
+    }, QuadMap[4]{
+        { FrontLeft,  Deg2Rad( -45.0f), Deg2Rad(0.0f) },
+        { FrontRight, Deg2Rad(  45.0f), Deg2Rad(0.0f) },
+        { BackLeft,   Deg2Rad(-135.0f), Deg2Rad(0.0f) },
+        { BackRight,  Deg2Rad( 135.0f), Deg2Rad(0.0f) }
+    }, X51Map[6]{
+        { FrontLeft,   Deg2Rad( -30.0f), Deg2Rad(0.0f) },
+        { FrontRight,  Deg2Rad(  30.0f), Deg2Rad(0.0f) },
+        { FrontCenter, Deg2Rad(   0.0f), Deg2Rad(0.0f) },
+        { LFE, 0.0f, 0.0f },
+        { SideLeft,    Deg2Rad(-110.0f), Deg2Rad(0.0f) },
+        { SideRight,   Deg2Rad( 110.0f), Deg2Rad(0.0f) }
+    }, X61Map[7]{
+        { FrontLeft,   Deg2Rad(-30.0f), Deg2Rad(0.0f) },
+        { FrontRight,  Deg2Rad( 30.0f), Deg2Rad(0.0f) },
+        { FrontCenter, Deg2Rad(  0.0f), Deg2Rad(0.0f) },
+        { LFE, 0.0f, 0.0f },
+        { BackCenter,  Deg2Rad(180.0f), Deg2Rad(0.0f) },
+        { SideLeft,    Deg2Rad(-90.0f), Deg2Rad(0.0f) },
+        { SideRight,   Deg2Rad( 90.0f), Deg2Rad(0.0f) }
+    }, X71Map[8]{
+        { FrontLeft,   Deg2Rad( -30.0f), Deg2Rad(0.0f) },
+        { FrontRight,  Deg2Rad(  30.0f), Deg2Rad(0.0f) },
+        { FrontCenter, Deg2Rad(   0.0f), Deg2Rad(0.0f) },
+        { LFE, 0.0f, 0.0f },
+        { BackLeft,    Deg2Rad(-150.0f), Deg2Rad(0.0f) },
+        { BackRight,   Deg2Rad( 150.0f), Deg2Rad(0.0f) },
+        { SideLeft,    Deg2Rad( -90.0f), Deg2Rad(0.0f) },
+        { SideRight,   Deg2Rad(  90.0f), Deg2Rad(0.0f) }
+    };
+
+    if(mNumConvolveSegs < 1) UNLIKELY
+        return;
+
+    mMix = &ConvolutionState::NormalMix;
+
+    for(auto &chan : *mChans)
+        std::fill(std::begin(chan.Target), std::end(chan.Target), 0.0f);
+    const float gain{slot->Gain};
+    if(IsAmbisonic(mChannels))
+    {
+        DeviceBase *device{context->mDevice};
+        if(mChannels == FmtUHJ2 && !device->mUhjEncoder)
+        {
+            mMix = &ConvolutionState::UpsampleMix;
+            (*mChans)[0].mHfScale = 1.0f;
+            (*mChans)[0].mLfScale = DecoderBase::sWLFScale;
+            (*mChans)[1].mHfScale = 1.0f;
+            (*mChans)[1].mLfScale = DecoderBase::sXYLFScale;
+            (*mChans)[2].mHfScale = 1.0f;
+            (*mChans)[2].mLfScale = DecoderBase::sXYLFScale;
+        }
+        else if(device->mAmbiOrder > mAmbiOrder)
+        {
+            mMix = &ConvolutionState::UpsampleMix;
+            const auto scales = AmbiScale::GetHFOrderScales(mAmbiOrder, device->mAmbiOrder,
+                device->m2DMixing);
+            (*mChans)[0].mHfScale = scales[0];
+            (*mChans)[0].mLfScale = 1.0f;
+            for(size_t i{1};i < mChans->size();++i)
+            {
+                (*mChans)[i].mHfScale = scales[1];
+                (*mChans)[i].mLfScale = 1.0f;
+            }
+        }
+        mOutTarget = target.Main->Buffer;
+
+        auto&& scales = GetAmbiScales(mAmbiScaling);
+        const uint8_t *index_map{Is2DAmbisonic(mChannels) ?
+            GetAmbi2DLayout(mAmbiLayout).data() :
+            GetAmbiLayout(mAmbiLayout).data()};
+
+        std::array<float,MaxAmbiChannels> coeffs{};
+        for(size_t c{0u};c < mChans->size();++c)
+        {
+            const size_t acn{index_map[c]};
+            coeffs[acn] = scales[acn];
+            ComputePanGains(target.Main, coeffs.data(), gain, (*mChans)[c].Target);
+            coeffs[acn] = 0.0f;
+        }
+    }
+    else
+    {
+        DeviceBase *device{context->mDevice};
+        al::span<const ChanMap> chanmap{};
+        switch(mChannels)
+        {
+        case FmtMono: chanmap = MonoMap; break;
+        case FmtSuperStereo:
+        case FmtStereo: chanmap = StereoMap; break;
+        case FmtRear: chanmap = RearMap; break;
+        case FmtQuad: chanmap = QuadMap; break;
+        case FmtX51: chanmap = X51Map; break;
+        case FmtX61: chanmap = X61Map; break;
+        case FmtX71: chanmap = X71Map; break;
+        case FmtBFormat2D:
+        case FmtBFormat3D:
+        case FmtUHJ2:
+        case FmtUHJ3:
+        case FmtUHJ4:
+            break;
+        }
+
+        mOutTarget = target.Main->Buffer;
+        if(device->mRenderMode == RenderMode::Pairwise)
+        {
+            auto ScaleAzimuthFront = [](float azimuth, float scale) -> float
+            {
+                constexpr float half_pi{al::numbers::pi_v<float>*0.5f};
+                const float abs_azi{std::fabs(azimuth)};
+                if(!(abs_azi >= half_pi))
+                    return std::copysign(minf(abs_azi*scale, half_pi), azimuth);
+                return azimuth;
+            };
+
+            for(size_t i{0};i < chanmap.size();++i)
+            {
+                if(chanmap[i].channel == LFE) continue;
+                const auto coeffs = CalcAngleCoeffs(ScaleAzimuthFront(chanmap[i].angle, 2.0f),
+                    chanmap[i].elevation, 0.0f);
+                ComputePanGains(target.Main, coeffs.data(), gain, (*mChans)[i].Target);
+            }
+        }
+        else for(size_t i{0};i < chanmap.size();++i)
+        {
+            if(chanmap[i].channel == LFE) continue;
+            const auto coeffs = CalcAngleCoeffs(chanmap[i].angle, chanmap[i].elevation, 0.0f);
+            ComputePanGains(target.Main, coeffs.data(), gain, (*mChans)[i].Target);
+        }
+    }
+}
+
+void ConvolutionState::process(const size_t samplesToDo,
+    const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
+{
+    if(mNumConvolveSegs < 1) UNLIKELY
+        return;
+
+    constexpr size_t m{ConvolveUpdateSize/2 + 1};
+    size_t curseg{mCurrentSegment};
+    auto &chans = *mChans;
+
+    for(size_t base{0u};base < samplesToDo;)
+    {
+        const size_t todo{minz(ConvolveUpdateSamples-mFifoPos, samplesToDo-base)};
+
+        std::copy_n(samplesIn[0].begin() + base, todo,
+            mInput.begin()+ConvolveUpdateSamples+mFifoPos);
+
+        /* Apply the FIR for the newly retrieved input samples, and combine it
+         * with the inverse FFT'd output samples.
+         */
+        for(size_t c{0};c < chans.size();++c)
+        {
+            auto buf_iter = chans[c].mBuffer.begin() + base;
+            apply_fir({buf_iter, todo}, mInput.data()+1 + mFifoPos, mFilter[c].data());
+
+            auto fifo_iter = mOutput[c].begin() + mFifoPos;
+            std::transform(fifo_iter, fifo_iter+todo, buf_iter, buf_iter, std::plus<>{});
+        }
+
+        mFifoPos += todo;
+        base += todo;
+
+        /* Check whether the input buffer is filled with new samples. */
+        if(mFifoPos < ConvolveUpdateSamples) break;
+        mFifoPos = 0;
+
+        /* Move the newest input to the front for the next iteration's history. */
+        std::copy(mInput.cbegin()+ConvolveUpdateSamples, mInput.cend(), mInput.begin());
+
+        /* Calculate the frequency domain response and add the relevant
+         * frequency bins to the FFT history.
+         */
+        auto fftiter = std::copy_n(mInput.cbegin(), ConvolveUpdateSamples, mFftBuffer.begin());
+        std::fill(fftiter, mFftBuffer.end(), complex_f{});
+        forward_fft(al::as_span(mFftBuffer));
+
+        std::copy_n(mFftBuffer.cbegin(), m, &mComplexData[curseg*m]);
+
+        const complex_f *RESTRICT filter{mComplexData.get() + mNumConvolveSegs*m};
+        for(size_t c{0};c < chans.size();++c)
+        {
+            std::fill_n(mFftBuffer.begin(), m, complex_f{});
+
+            /* Convolve each input segment with its IR filter counterpart
+             * (aligned in time).
+             */
+            const complex_f *RESTRICT input{&mComplexData[curseg*m]};
+            for(size_t s{curseg};s < mNumConvolveSegs;++s)
+            {
+                for(size_t i{0};i < m;++i,++input,++filter)
+                    mFftBuffer[i] += *input * *filter;
+            }
+            input = mComplexData.get();
+            for(size_t s{0};s < curseg;++s)
+            {
+                for(size_t i{0};i < m;++i,++input,++filter)
+                    mFftBuffer[i] += *input * *filter;
+            }
+
+            /* Reconstruct the mirrored/negative frequencies to do a proper
+             * inverse FFT.
+             */
+            for(size_t i{m};i < ConvolveUpdateSize;++i)
+                mFftBuffer[i] = std::conj(mFftBuffer[ConvolveUpdateSize-i]);
+
+            /* Apply iFFT to get the 256 (really 255) samples for output. The
+             * 128 output samples are combined with the last output's 127
+             * second-half samples (and this output's second half is
+             * subsequently saved for next time).
+             */
+            inverse_fft(al::as_span(mFftBuffer));
+
+            /* The iFFT'd response is scaled up by the number of bins, so apply
+             * the inverse to normalize the output.
+             */
+            for(size_t i{0};i < ConvolveUpdateSamples;++i)
+                mOutput[c][i] =
+                    (mFftBuffer[i].real()+mOutput[c][ConvolveUpdateSamples+i]) *
+                    (1.0f/float{ConvolveUpdateSize});
+            for(size_t i{0};i < ConvolveUpdateSamples;++i)
+                mOutput[c][ConvolveUpdateSamples+i] = mFftBuffer[ConvolveUpdateSamples+i].real();
+        }
+
+        /* Shift the input history. */
+        curseg = curseg ? (curseg-1) : (mNumConvolveSegs-1);
+    }
+    mCurrentSegment = curseg;
+
+    /* Finally, mix to the output. */
+    (this->*mMix)(samplesOut, samplesToDo);
+}
+
+
+struct ConvolutionStateFactory final : public EffectStateFactory {
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ConvolutionState{}}; }
+};
+
+} // namespace
+
+EffectStateFactory *ConvolutionStateFactory_getFactory()
+{
+    static ConvolutionStateFactory ConvolutionFactory{};
+    return &ConvolutionFactory;
+}
diff --git a/alc/effects/dedicated.cpp b/alc/effects/dedicated.cpp
index aa81e13b..047e6761 100644
--- a/alc/effects/dedicated.cpp
+++ b/alc/effects/dedicated.cpp
@@ -20,70 +20,84 @@
 
 #include "config.h"
 
-#include <cstdlib>
-#include <cmath>
 #include <algorithm>
+#include <array>
+#include <cstdlib>
+#include <iterator>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
+struct ContextBase;
 
 
 namespace {
 
+using uint = unsigned int;
+
 struct DedicatedState final : public EffectState {
-    ALfloat mCurrentGains[MAX_OUTPUT_CHANNELS];
-    ALfloat mTargetGains[MAX_OUTPUT_CHANNELS];
+    /* The "dedicated" effect can output to the real output, so should have
+     * gains for all possible output channels and not just the main ambisonic
+     * buffer.
+     */
+    float mCurrentGains[MAX_OUTPUT_CHANNELS];
+    float mTargetGains[MAX_OUTPUT_CHANNELS];
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(DedicatedState)
 };
 
-ALboolean DedicatedState::deviceUpdate(const ALCdevice*)
+void DedicatedState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     std::fill(std::begin(mCurrentGains), std::end(mCurrentGains), 0.0f);
-    return AL_TRUE;
 }
 
-void DedicatedState::update(const ALCcontext*, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void DedicatedState::update(const ContextBase*, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
     std::fill(std::begin(mTargetGains), std::end(mTargetGains), 0.0f);
 
-    const ALfloat Gain{slot->Params.Gain * props->Dedicated.Gain};
+    const float Gain{slot->Gain * props->Dedicated.Gain};
 
-    if(slot->Params.EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
+    if(slot->EffectType == EffectSlotType::DedicatedLFE)
     {
-        const ALuint idx{!target.RealOut ? INVALID_CHANNEL_INDEX :
-            GetChannelIdxByName(*target.RealOut, LFE)};
-        if(idx != INVALID_CHANNEL_INDEX)
+        const uint idx{target.RealOut ? target.RealOut->ChannelIndex[LFE] : InvalidChannelIndex};
+        if(idx != InvalidChannelIndex)
         {
             mOutTarget = target.RealOut->Buffer;
             mTargetGains[idx] = Gain;
         }
     }
-    else if(slot->Params.EffectType == AL_EFFECT_DEDICATED_DIALOGUE)
+    else if(slot->EffectType == EffectSlotType::DedicatedDialog)
     {
         /* Dialog goes to the front-center speaker if it exists, otherwise it
          * plays from the front-center location. */
-        const ALuint idx{!target.RealOut ? INVALID_CHANNEL_INDEX :
-            GetChannelIdxByName(*target.RealOut, FrontCenter)};
-        if(idx != INVALID_CHANNEL_INDEX)
+        const uint idx{target.RealOut ? target.RealOut->ChannelIndex[FrontCenter]
+            : InvalidChannelIndex};
+        if(idx != InvalidChannelIndex)
         {
             mOutTarget = target.RealOut->Buffer;
             mTargetGains[idx] = Gain;
         }
         else
         {
-            ALfloat coeffs[MAX_AMBI_CHANNELS];
-            CalcDirectionCoeffs({0.0f, 0.0f, -1.0f}, 0.0f, coeffs);
+            static constexpr auto coeffs = CalcDirectionCoeffs({0.0f, 0.0f, -1.0f});
 
             mOutTarget = target.Main->Buffer;
-            ComputePanGains(target.Main, coeffs, Gain, mTargetGains);
+            ComputePanGains(target.Main, coeffs.data(), Gain, mTargetGains);
         }
     }
 }
@@ -95,62 +109,11 @@ void DedicatedState::process(const size_t samplesToDo, const al::span<const Floa
 }
 
 
-void Dedicated_setParami(EffectProps*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param); }
-void Dedicated_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x", param); }
-void Dedicated_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_DEDICATED_GAIN:
-            if(!(val >= 0.0f && std::isfinite(val)))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Dedicated gain out of range");
-            props->Dedicated.Gain = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param);
-    }
-}
-void Dedicated_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Dedicated_setParamf(props, context, param, vals[0]); }
-
-void Dedicated_getParami(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param); }
-void Dedicated_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x", param); }
-void Dedicated_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val)
-{
-    switch(param)
-    {
-        case AL_DEDICATED_GAIN:
-            *val = props->Dedicated.Gain;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param);
-    }
-}
-void Dedicated_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Dedicated_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Dedicated);
-
-
 struct DedicatedStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new DedicatedState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Dedicated_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new DedicatedState{}}; }
 };
 
-EffectProps DedicatedStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Dedicated.Gain = 1.0f;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *DedicatedStateFactory_getFactory()
diff --git a/alc/effects/distortion.cpp b/alc/effects/distortion.cpp
index 7dd43008..b4e2167e 100644
--- a/alc/effects/distortion.cpp
+++ b/alc/effects/distortion.cpp
@@ -20,82 +20,90 @@
 
 #include "config.h"
 
-#include <cmath>
+#include <algorithm>
+#include <array>
 #include <cstdlib>
-
-#include <cmath>
-
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "filters/biquad.h"
+#include <iterator>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "intrusive_ptr.h"
 
 
 namespace {
 
 struct DistortionState final : public EffectState {
     /* Effect gains for each channel */
-    ALfloat mGain[MAX_OUTPUT_CHANNELS]{};
+    float mGain[MaxAmbiChannels]{};
 
     /* Effect parameters */
     BiquadFilter mLowpass;
     BiquadFilter mBandpass;
-    ALfloat mAttenuation{};
-    ALfloat mEdgeCoeff{};
+    float mAttenuation{};
+    float mEdgeCoeff{};
 
-    ALfloat mBuffer[2][BUFFERSIZE]{};
+    alignas(16) float mBuffer[2][BufferLineSize]{};
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(DistortionState)
 };
 
-ALboolean DistortionState::deviceUpdate(const ALCdevice*)
+void DistortionState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     mLowpass.clear();
     mBandpass.clear();
-    return AL_TRUE;
 }
 
-void DistortionState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void DistortionState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
+    const DeviceBase *device{context->mDevice};
 
     /* Store waveshaper edge settings. */
-    const ALfloat edge{
-        minf(std::sin(al::MathDefs<float>::Pi()*0.5f * props->Distortion.Edge), 0.99f)};
+    const float edge{minf(std::sin(al::numbers::pi_v<float>*0.5f * props->Distortion.Edge),
+        0.99f)};
     mEdgeCoeff = 2.0f * edge / (1.0f-edge);
 
-    ALfloat cutoff{props->Distortion.LowpassCutoff};
+    float cutoff{props->Distortion.LowpassCutoff};
     /* Bandwidth value is constant in octaves. */
-    ALfloat bandwidth{(cutoff / 2.0f) / (cutoff * 0.67f)};
-    /* Multiply sampling frequency by the amount of oversampling done during
+    float bandwidth{(cutoff / 2.0f) / (cutoff * 0.67f)};
+    /* Divide normalized frequency by the amount of oversampling done during
      * processing.
      */
-    auto frequency = static_cast<ALfloat>(device->Frequency);
-    mLowpass.setParams(BiquadType::LowPass, 1.0f, cutoff / (frequency*4.0f),
-        mLowpass.rcpQFromBandwidth(cutoff / (frequency*4.0f), bandwidth));
+    auto frequency = static_cast<float>(device->Frequency);
+    mLowpass.setParamsFromBandwidth(BiquadType::LowPass, cutoff/frequency/4.0f, 1.0f, bandwidth);
 
     cutoff = props->Distortion.EQCenter;
     /* Convert bandwidth in Hz to octaves. */
     bandwidth = props->Distortion.EQBandwidth / (cutoff * 0.67f);
-    mBandpass.setParams(BiquadType::BandPass, 1.0f, cutoff / (frequency*4.0f),
-        mBandpass.rcpQFromBandwidth(cutoff / (frequency*4.0f), bandwidth));
+    mBandpass.setParamsFromBandwidth(BiquadType::BandPass, cutoff/frequency/4.0f, 1.0f, bandwidth);
 
-    ALfloat coeffs[MAX_AMBI_CHANNELS];
-    CalcDirectionCoeffs({0.0f, 0.0f, -1.0f}, 0.0f, coeffs);
+    static constexpr auto coeffs = CalcDirectionCoeffs({0.0f, 0.0f, -1.0f});
 
     mOutTarget = target.Main->Buffer;
-    ComputePanGains(target.Main, coeffs, slot->Params.Gain*props->Distortion.Gain, mGain);
+    ComputePanGains(target.Main, coeffs.data(), slot->Gain*props->Distortion.Gain, mGain);
 }
 
 void DistortionState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    const ALfloat fc{mEdgeCoeff};
+    const float fc{mEdgeCoeff};
     for(size_t base{0u};base < samplesToDo;)
     {
         /* Perform 4x oversampling to avoid aliasing. Oversampling greatly
@@ -103,7 +111,7 @@ void DistortionState::process(const size_t samplesToDo, const al::span<const Flo
          * bandpass filters using high frequencies, at which classic IIR
          * filters became unstable.
          */
-        size_t todo{minz(BUFFERSIZE, (samplesToDo-base) * 4)};
+        size_t todo{minz(BufferLineSize, (samplesToDo-base) * 4)};
 
         /* Fill oversample buffer using zero stuffing. Multiply the sample by
          * the amount of oversampling to maintain the signal's power.
@@ -116,36 +124,35 @@ void DistortionState::process(const size_t samplesToDo, const al::span<const Flo
          * (which is fortunately first step of distortion). So combine three
          * operations into the one.
          */
-        mLowpass.process(mBuffer[1], mBuffer[0], todo);
+        mLowpass.process({mBuffer[0], todo}, mBuffer[1]);
 
         /* Second step, do distortion using waveshaper function to emulate
          * signal processing during tube overdriving. Three steps of
          * waveshaping are intended to modify waveform without boost/clipping/
          * attenuation process.
          */
-        for(size_t i{0u};i < todo;i++)
+        auto proc_sample = [fc](float smp) -> float
         {
-            ALfloat smp{mBuffer[1][i]};
-
-            smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
-            smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp)) * -1.0f;
-            smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
-
-            mBuffer[0][i] = smp;
-        }
+            smp = (1.0f + fc) * smp/(1.0f + fc*std::abs(smp));
+            smp = (1.0f + fc) * smp/(1.0f + fc*std::abs(smp)) * -1.0f;
+            smp = (1.0f + fc) * smp/(1.0f + fc*std::abs(smp));
+            return smp;
+        };
+        std::transform(std::begin(mBuffer[1]), std::begin(mBuffer[1])+todo, std::begin(mBuffer[0]),
+            proc_sample);
 
         /* Third step, do bandpass filtering of distorted signal. */
-        mBandpass.process(mBuffer[1], mBuffer[0], todo);
+        mBandpass.process({mBuffer[0], todo}, mBuffer[1]);
 
         todo >>= 2;
-        const ALfloat *outgains{mGain};
+        const float *outgains{mGain};
         for(FloatBufferLine &output : samplesOut)
         {
             /* Fourth step, final, do attenuation and perform decimation,
              * storing only one sample out of four.
              */
-            const ALfloat gain{*(outgains++)};
-            if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
+            const float gain{*(outgains++)};
+            if(!(std::fabs(gain) > GainSilenceThreshold))
                 continue;
 
             for(size_t i{0u};i < todo;i++)
@@ -157,106 +164,11 @@ void DistortionState::process(const size_t samplesToDo, const al::span<const Flo
 }
 
 
-void Distortion_setParami(EffectProps*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param); }
-void Distortion_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x", param); }
-void Distortion_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_DISTORTION_EDGE:
-            if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Distortion EQ bandwidth out of range");
-            props->Distortion.EQBandwidth = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param);
-    }
-}
-void Distortion_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Distortion_setParamf(props, context, param, vals[0]); }
-
-void Distortion_getParami(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param); }
-void Distortion_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x", param); }
-void Distortion_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param);
-    }
-}
-void Distortion_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Distortion_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Distortion);
-
-
 struct DistortionStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new DistortionState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Distortion_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new DistortionState{}}; }
 };
 
-EffectProps DistortionStateFactory::getDefaultProps() const 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
 
 EffectStateFactory *DistortionStateFactory_getFactory()
diff --git a/alc/effects/echo.cpp b/alc/effects/echo.cpp
index a9213df5..a69529dc 100644
--- a/alc/effects/echo.cpp
+++ b/alc/effects/echo.cpp
@@ -20,24 +20,36 @@
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
-
 #include <algorithm>
-
-#include "al/auxeffectslot.h"
-#include "al/filter.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "filters/biquad.h"
+#include <array>
+#include <cstdlib>
+#include <iterator>
+#include <tuple>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
+#include "opthelpers.h"
 #include "vector.h"
 
 
 namespace {
 
+using uint = unsigned int;
+
+constexpr float LowpassFreqRef{5000.0f};
+
 struct EchoState final : public EffectState {
-    al::vector<ALfloat,16> mSampleBuffer;
+    al::vector<float,16> mSampleBuffer;
 
     // The echo is two tap. The delay is the number of samples from before the
     // current offset
@@ -48,35 +60,34 @@ struct EchoState final : public EffectState {
 
     /* The panning gains for the two taps */
     struct {
-        ALfloat Current[MAX_OUTPUT_CHANNELS]{};
-        ALfloat Target[MAX_OUTPUT_CHANNELS]{};
+        float Current[MaxAmbiChannels]{};
+        float Target[MaxAmbiChannels]{};
     } mGains[2];
 
     BiquadFilter mFilter;
-    ALfloat mFeedGain{0.0f};
+    float mFeedGain{0.0f};
 
-    alignas(16) ALfloat mTempBuffer[2][BUFFERSIZE];
+    alignas(16) float mTempBuffer[2][BufferLineSize];
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(EchoState)
 };
 
-ALboolean EchoState::deviceUpdate(const ALCdevice *Device)
+void EchoState::deviceUpdate(const DeviceBase *Device, const BufferStorage*)
 {
     const auto frequency = static_cast<float>(Device->Frequency);
 
     // Use the next power of 2 for the buffer length, so the tap offsets can be
     // wrapped using a mask instead of a modulo
-    const ALuint maxlen{NextPowerOf2(float2uint(AL_ECHO_MAX_DELAY*frequency + 0.5f) +
-        float2uint(AL_ECHO_MAX_LRDELAY*frequency + 0.5f))};
+    const uint maxlen{NextPowerOf2(float2uint(EchoMaxDelay*frequency + 0.5f) +
+        float2uint(EchoMaxLRDelay*frequency + 0.5f))};
     if(maxlen != mSampleBuffer.size())
-    {
-        mSampleBuffer.resize(maxlen);
-        mSampleBuffer.shrink_to_fit();
-    }
+        al::vector<float,16>(maxlen).swap(mSampleBuffer);
 
     std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), 0.0f);
     for(auto &e : mGains)
@@ -84,44 +95,41 @@ ALboolean EchoState::deviceUpdate(const ALCdevice *Device)
         std::fill(std::begin(e.Current), std::end(e.Current), 0.0f);
         std::fill(std::begin(e.Target), std::end(e.Target), 0.0f);
     }
-
-    return AL_TRUE;
 }
 
-void EchoState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void EchoState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
-    const auto frequency = static_cast<ALfloat>(device->Frequency);
+    const DeviceBase *device{context->mDevice};
+    const auto frequency = static_cast<float>(device->Frequency);
 
     mTap[0].delay = maxu(float2uint(props->Echo.Delay*frequency + 0.5f), 1);
     mTap[1].delay = float2uint(props->Echo.LRDelay*frequency + 0.5f) + mTap[0].delay;
 
-    const ALfloat gainhf{maxf(1.0f - props->Echo.Damping, 0.0625f)}; /* Limit -24dB */
-    mFilter.setParams(BiquadType::HighShelf, gainhf, LOWPASSFREQREF/frequency,
-        mFilter.rcpQFromSlope(gainhf, 1.0f));
+    const float gainhf{maxf(1.0f - props->Echo.Damping, 0.0625f)}; /* Limit -24dB */
+    mFilter.setParamsFromSlope(BiquadType::HighShelf, LowpassFreqRef/frequency, gainhf, 1.0f);
 
     mFeedGain = props->Echo.Feedback;
 
     /* Convert echo spread (where 0 = center, +/-1 = sides) to angle. */
-    const ALfloat angle{std::asin(props->Echo.Spread)};
+    const float angle{std::asin(props->Echo.Spread)};
 
-    ALfloat coeffs[2][MAX_AMBI_CHANNELS];
-    CalcAngleCoeffs(-angle, 0.0f, 0.0f, coeffs[0]);
-    CalcAngleCoeffs( angle, 0.0f, 0.0f, coeffs[1]);
+    const auto coeffs0 = CalcAngleCoeffs(-angle, 0.0f, 0.0f);
+    const auto coeffs1 = CalcAngleCoeffs( angle, 0.0f, 0.0f);
 
     mOutTarget = target.Main->Buffer;
-    ComputePanGains(target.Main, coeffs[0], slot->Params.Gain, mGains[0].Target);
-    ComputePanGains(target.Main, coeffs[1], slot->Params.Gain, mGains[1].Target);
+    ComputePanGains(target.Main, coeffs0.data(), slot->Gain, mGains[0].Target);
+    ComputePanGains(target.Main, coeffs1.data(), slot->Gain, mGains[1].Target);
 }
 
 void EchoState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
     const size_t mask{mSampleBuffer.size()-1};
-    ALfloat *RESTRICT delaybuf{mSampleBuffer.data()};
+    float *RESTRICT delaybuf{mSampleBuffer.data()};
     size_t offset{mOffset};
     size_t tap1{offset - mTap[0].delay};
     size_t tap2{offset - mTap[1].delay};
-    ALfloat z1, z2;
+    float z1, z2;
 
     ASSUME(samplesToDo > 0);
 
@@ -152,112 +160,17 @@ void EchoState::process(const size_t samplesToDo, const al::span<const FloatBuff
     mFilter.setComponents(z1, z2);
     mOffset = offset;
 
-    for(ALsizei c{0};c < 2;c++)
+    for(size_t c{0};c < 2;c++)
         MixSamples({mTempBuffer[c], samplesToDo}, samplesOut, mGains[c].Current, mGains[c].Target,
             samplesToDo, 0);
 }
 
 
-void Echo_setParami(EffectProps*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param); }
-void Echo_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param); }
-void Echo_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_ECHO_DELAY:
-            if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Echo spread out of range");
-            props->Echo.Spread = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param);
-    }
-}
-void Echo_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Echo_setParamf(props, context, param, vals[0]); }
-
-void Echo_getParami(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param); }
-void Echo_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param); }
-void Echo_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param);
-    }
-}
-void Echo_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Echo_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Echo);
-
-
 struct EchoStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new EchoState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Echo_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new EchoState{}}; }
 };
 
-EffectProps EchoStateFactory::getDefaultProps() const 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
 
 EffectStateFactory *EchoStateFactory_getFactory()
diff --git a/alc/effects/equalizer.cpp b/alc/effects/equalizer.cpp
index 929bff14..50bec4ad 100644
--- a/alc/effects/equalizer.cpp
+++ b/alc/effects/equalizer.cpp
@@ -20,18 +20,25 @@
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
-
 #include <algorithm>
+#include <array>
+#include <cstdlib>
 #include <functional>
-
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "filters/biquad.h"
-#include "vecmat.h"
+#include <iterator>
+#include <utility>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
 
 
 namespace {
@@ -80,255 +87,114 @@ namespace {
 
 struct EqualizerState final : public EffectState {
     struct {
+        uint mTargetChannel{InvalidChannelIndex};
+
         /* Effect parameters */
-        BiquadFilter filter[4];
+        BiquadFilter mFilter[4];
 
         /* Effect gains for each channel */
-        ALfloat CurrentGains[MAX_OUTPUT_CHANNELS]{};
-        ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
-    } mChans[MAX_AMBI_CHANNELS];
+        float mCurrentGain{};
+        float mTargetGain{};
+    } mChans[MaxAmbiChannels];
 
-    ALfloat mSampleBuffer[BUFFERSIZE]{};
+    alignas(16) FloatBufferLine mSampleBuffer{};
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(EqualizerState)
 };
 
-ALboolean EqualizerState::deviceUpdate(const ALCdevice*)
+void EqualizerState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     for(auto &e : mChans)
     {
-        std::for_each(std::begin(e.filter), std::end(e.filter),
-                      std::mem_fn(&BiquadFilter::clear));
-        std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
+        e.mTargetChannel = InvalidChannelIndex;
+        std::for_each(std::begin(e.mFilter), std::end(e.mFilter),
+            std::mem_fn(&BiquadFilter::clear));
+        e.mCurrentGain = 0.0f;
     }
-    return AL_TRUE;
 }
 
-void EqualizerState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void EqualizerState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
-    auto frequency = static_cast<ALfloat>(device->Frequency);
-    ALfloat gain, f0norm;
+    const DeviceBase *device{context->mDevice};
+    auto frequency = static_cast<float>(device->Frequency);
+    float gain, f0norm;
 
     /* Calculate coefficients for the each type of filter. Note that the shelf
      * and peaking filters' gain is for the centerpoint of the transition band,
-     * meaning its dB needs to be doubled for the shelf or peak to reach the
-     * provided gain.
+     * while the effect property gains are for the shelf/peak itself. So the
+     * property gains need their dB halved (sqrt of linear gain) for the
+     * shelf/peak to reach the provided gain.
      */
-    gain = maxf(std::sqrt(props->Equalizer.LowGain), 0.0625f); /* Limit -24dB */
-    f0norm = props->Equalizer.LowCutoff/frequency;
-    mChans[0].filter[0].setParams(BiquadType::LowShelf, gain, f0norm,
-        BiquadFilter::rcpQFromSlope(gain, 0.75f));
+    gain = std::sqrt(props->Equalizer.LowGain);
+    f0norm = props->Equalizer.LowCutoff / frequency;
+    mChans[0].mFilter[0].setParamsFromSlope(BiquadType::LowShelf, f0norm, gain, 0.75f);
 
-    gain = maxf(std::sqrt(props->Equalizer.Mid1Gain), 0.0625f);
-    f0norm = props->Equalizer.Mid1Center/frequency;
-    mChans[0].filter[1].setParams(BiquadType::Peaking, gain, f0norm,
-        BiquadFilter::rcpQFromBandwidth(f0norm, props->Equalizer.Mid1Width));
+    gain = std::sqrt(props->Equalizer.Mid1Gain);
+    f0norm = props->Equalizer.Mid1Center / frequency;
+    mChans[0].mFilter[1].setParamsFromBandwidth(BiquadType::Peaking, f0norm, gain,
+        props->Equalizer.Mid1Width);
 
-    gain = maxf(std::sqrt(props->Equalizer.Mid2Gain), 0.0625f);
-    f0norm = props->Equalizer.Mid2Center/frequency;
-    mChans[0].filter[2].setParams(BiquadType::Peaking, gain, f0norm,
-        BiquadFilter::rcpQFromBandwidth(f0norm, props->Equalizer.Mid2Width));
+    gain = std::sqrt(props->Equalizer.Mid2Gain);
+    f0norm = props->Equalizer.Mid2Center / frequency;
+    mChans[0].mFilter[2].setParamsFromBandwidth(BiquadType::Peaking, f0norm, gain,
+        props->Equalizer.Mid2Width);
 
-    gain = maxf(std::sqrt(props->Equalizer.HighGain), 0.0625f);
-    f0norm = props->Equalizer.HighCutoff/frequency;
-    mChans[0].filter[3].setParams(BiquadType::HighShelf, gain, f0norm,
-        BiquadFilter::rcpQFromSlope(gain, 0.75f));
+    gain = std::sqrt(props->Equalizer.HighGain);
+    f0norm = props->Equalizer.HighCutoff / frequency;
+    mChans[0].mFilter[3].setParamsFromSlope(BiquadType::HighShelf, f0norm, gain, 0.75f);
 
     /* Copy the filter coefficients for the other input channels. */
     for(size_t i{1u};i < slot->Wet.Buffer.size();++i)
     {
-        mChans[i].filter[0].copyParamsFrom(mChans[0].filter[0]);
-        mChans[i].filter[1].copyParamsFrom(mChans[0].filter[1]);
-        mChans[i].filter[2].copyParamsFrom(mChans[0].filter[2]);
-        mChans[i].filter[3].copyParamsFrom(mChans[0].filter[3]);
+        mChans[i].mFilter[0].copyParamsFrom(mChans[0].mFilter[0]);
+        mChans[i].mFilter[1].copyParamsFrom(mChans[0].mFilter[1]);
+        mChans[i].mFilter[2].copyParamsFrom(mChans[0].mFilter[2]);
+        mChans[i].mFilter[3].copyParamsFrom(mChans[0].mFilter[3]);
     }
 
     mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
+    auto set_channel = [this](size_t idx, uint outchan, float outgain)
     {
-        auto coeffs = GetAmbiIdentityRow(i);
-        ComputePanGains(target.Main, coeffs.data(), slot->Params.Gain, mChans[i].TargetGains);
-    }
+        mChans[idx].mTargetChannel = outchan;
+        mChans[idx].mTargetGain = outgain;
+    };
+    target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 }
 
 void EqualizerState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    auto chandata = std::addressof(mChans[0]);
+    const al::span<float> buffer{mSampleBuffer.data(), samplesToDo};
+    auto chan = std::begin(mChans);
     for(const auto &input : samplesIn)
     {
-        chandata->filter[0].process(mSampleBuffer, input.data(), samplesToDo);
-        chandata->filter[1].process(mSampleBuffer, mSampleBuffer, samplesToDo);
-        chandata->filter[2].process(mSampleBuffer, mSampleBuffer, samplesToDo);
-        chandata->filter[3].process(mSampleBuffer, mSampleBuffer, samplesToDo);
-
-        MixSamples({mSampleBuffer, samplesToDo}, samplesOut, chandata->CurrentGains,
-            chandata->TargetGains, samplesToDo, 0);
-        ++chandata;
-    }
-}
-
-
-void Equalizer_setParami(EffectProps*, ALCcontext *context, ALenum param, ALint)
-{ context->setError(AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param); }
-void Equalizer_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x", param); }
-void Equalizer_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_EQUALIZER_LOW_GAIN:
-            if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Equalizer high-band cutoff out of range");
-            props->Equalizer.HighCutoff = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param);
-    }
-}
-void Equalizer_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Equalizer_setParamf(props, context, param, vals[0]); }
-
-void Equalizer_getParami(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param); }
-void Equalizer_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x", param); }
-void Equalizer_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param);
+        const size_t outidx{chan->mTargetChannel};
+        if(outidx != InvalidChannelIndex)
+        {
+            const al::span<const float> inbuf{input.data(), samplesToDo};
+            DualBiquad{chan->mFilter[0], chan->mFilter[1]}.process(inbuf, buffer.begin());
+            DualBiquad{chan->mFilter[2], chan->mFilter[3]}.process(buffer, buffer.begin());
+
+            MixSamples(buffer, samplesOut[outidx].data(), chan->mCurrentGain, chan->mTargetGain,
+                samplesToDo);
+        }
+        ++chan;
     }
 }
-void Equalizer_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Equalizer_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Equalizer);
 
 
 struct EqualizerStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new EqualizerState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Equalizer_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new EqualizerState{}}; }
 };
 
-EffectProps EqualizerStateFactory::getDefaultProps() const 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
 
 EffectStateFactory *EqualizerStateFactory_getFactory()
diff --git a/alc/effects/fshifter.cpp b/alc/effects/fshifter.cpp
index 1b935047..3e6a7385 100644
--- a/alc/effects/fshifter.cpp
+++ b/alc/effects/fshifter.cpp
@@ -20,207 +20,219 @@
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
+#include <algorithm>
 #include <array>
+#include <cmath>
 #include <complex>
-#include <algorithm>
-
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
+#include <cstdlib>
+#include <iterator>
 
+#include "alc/effects/base.h"
 #include "alcomplex.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "intrusive_ptr.h"
+
 
 namespace {
 
+using uint = unsigned int;
 using complex_d = std::complex<double>;
 
-#define HIL_SIZE 1024
-#define OVERSAMP (1<<2)
+constexpr size_t HilSize{1024};
+constexpr size_t HilHalfSize{HilSize >> 1};
+constexpr size_t OversampleFactor{4};
 
-#define HIL_STEP     (HIL_SIZE / OVERSAMP)
-#define FIFO_LATENCY (HIL_STEP * (OVERSAMP-1))
+static_assert(HilSize%OversampleFactor == 0, "Factor must be a clean divisor of the size");
+constexpr size_t HilStep{HilSize / OversampleFactor};
 
 /* Define a Hann window, used to filter the HIL input and output. */
-/* Making this constexpr seems to require C++14. */
-std::array<ALdouble,HIL_SIZE> InitHannWindow()
-{
-    std::array<ALdouble,HIL_SIZE> ret;
-    /* Create lookup table of the Hann window for the desired size, i.e. HIL_SIZE */
-    for(size_t i{0};i < HIL_SIZE>>1;i++)
+struct Windower {
+    alignas(16) std::array<double,HilSize> mData;
+
+    Windower()
     {
-        constexpr double scale{al::MathDefs<double>::Pi() / double{HIL_SIZE-1}};
-        const double val{std::sin(static_cast<double>(i) * scale)};
-        ret[i] = ret[HIL_SIZE-1-i] = val * val;
+        /* Create lookup table of the Hann window for the desired size. */
+        for(size_t i{0};i < HilHalfSize;i++)
+        {
+            constexpr double scale{al::numbers::pi / double{HilSize}};
+            const double val{std::sin((static_cast<double>(i)+0.5) * scale)};
+            mData[i] = mData[HilSize-1-i] = val * val;
+        }
     }
-    return ret;
-}
-alignas(16) const std::array<ALdouble,HIL_SIZE> HannWindow = InitHannWindow();
+};
+const Windower gWindow{};
 
 
 struct FshifterState final : public EffectState {
     /* Effect parameters */
-    size_t   mCount{};
-    ALsizei  mPhaseStep[2]{};
-    ALsizei  mPhase[2]{};
-    ALdouble mSign[2]{};
-
+    size_t mCount{};
+    size_t mPos{};
+    std::array<uint,2> mPhaseStep{};
+    std::array<uint,2> mPhase{};
+    std::array<double,2> mSign{};
 
-    /*Effects buffers*/ 
-    ALfloat   mInFIFO[HIL_SIZE]{};
-    complex_d mOutFIFO[HIL_SIZE]{};
-    complex_d mOutputAccum[HIL_SIZE]{};
-    complex_d mAnalytic[HIL_SIZE]{};
-    complex_d mOutdata[BUFFERSIZE]{};
+    /* Effects buffers */
+    std::array<double,HilSize> mInFIFO{};
+    std::array<complex_d,HilStep> mOutFIFO{};
+    std::array<complex_d,HilSize> mOutputAccum{};
+    std::array<complex_d,HilSize> mAnalytic{};
+    std::array<complex_d,BufferLineSize> mOutdata{};
 
-    alignas(16) ALfloat mBufferOut[BUFFERSIZE]{};
+    alignas(16) FloatBufferLine mBufferOut{};
 
     /* Effect gains for each output channel */
     struct {
-        ALfloat Current[MAX_OUTPUT_CHANNELS]{};
-        ALfloat Target[MAX_OUTPUT_CHANNELS]{};
+        float Current[MaxAmbiChannels]{};
+        float Target[MaxAmbiChannels]{};
     } mGains[2];
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(FshifterState)
 };
 
-ALboolean FshifterState::deviceUpdate(const ALCdevice*)
+void FshifterState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     /* (Re-)initializing parameters and clear the buffers. */
-    mCount = FIFO_LATENCY;
+    mCount = 0;
+    mPos = HilSize - HilStep;
 
-    std::fill(std::begin(mPhaseStep),   std::end(mPhaseStep),   0);
-    std::fill(std::begin(mPhase),       std::end(mPhase),       0);
-    std::fill(std::begin(mSign),        std::end(mSign),        1.0);
-    std::fill(std::begin(mInFIFO),      std::end(mInFIFO),      0.0f);
-    std::fill(std::begin(mOutFIFO),     std::end(mOutFIFO),     complex_d{});
-    std::fill(std::begin(mOutputAccum), std::end(mOutputAccum), complex_d{});
-    std::fill(std::begin(mAnalytic),    std::end(mAnalytic),    complex_d{});
+    mPhaseStep.fill(0u);
+    mPhase.fill(0u);
+    mSign.fill(1.0);
+    mInFIFO.fill(0.0);
+    mOutFIFO.fill(complex_d{});
+    mOutputAccum.fill(complex_d{});
+    mAnalytic.fill(complex_d{});
 
     for(auto &gain : mGains)
     {
         std::fill(std::begin(gain.Current), std::end(gain.Current), 0.0f);
         std::fill(std::begin(gain.Target), std::end(gain.Target), 0.0f);
     }
-
-    return AL_TRUE;
 }
 
-void FshifterState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void FshifterState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
+    const DeviceBase *device{context->mDevice};
 
-    ALfloat step{props->Fshifter.Frequency / static_cast<ALfloat>(device->Frequency)};
-    mPhaseStep[0] = mPhaseStep[1] = fastf2i(minf(step, 0.5f) * FRACTIONONE);
+    const float step{props->Fshifter.Frequency / static_cast<float>(device->Frequency)};
+    mPhaseStep[0] = mPhaseStep[1] = fastf2u(minf(step, 1.0f) * MixerFracOne);
 
     switch(props->Fshifter.LeftDirection)
     {
-    case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN:
+    case FShifterDirection::Down:
         mSign[0] = -1.0;
         break;
-
-    case AL_FREQUENCY_SHIFTER_DIRECTION_UP:
+    case FShifterDirection::Up:
         mSign[0] = 1.0;
         break;
-
-    case AL_FREQUENCY_SHIFTER_DIRECTION_OFF:
+    case FShifterDirection::Off:
         mPhase[0]     = 0;
         mPhaseStep[0] = 0;
         break;
     }
 
-    switch (props->Fshifter.RightDirection)
+    switch(props->Fshifter.RightDirection)
     {
-    case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN:
+    case FShifterDirection::Down:
         mSign[1] = -1.0;
         break;
-
-    case AL_FREQUENCY_SHIFTER_DIRECTION_UP:
+    case FShifterDirection::Up:
         mSign[1] = 1.0;
         break;
-
-    case AL_FREQUENCY_SHIFTER_DIRECTION_OFF:
+    case FShifterDirection::Off:
         mPhase[1]     = 0;
         mPhaseStep[1] = 0;
         break;
     }
 
-    ALfloat coeffs[2][MAX_AMBI_CHANNELS];
-    CalcDirectionCoeffs({-1.0f, 0.0f, -1.0f}, 0.0f, coeffs[0]);
-    CalcDirectionCoeffs({ 1.0f, 0.0f, -1.0f}, 0.0f, coeffs[1]);
+    static constexpr auto inv_sqrt2 = static_cast<float>(1.0 / al::numbers::sqrt2);
+    static constexpr auto lcoeffs_pw = CalcDirectionCoeffs({-1.0f, 0.0f, 0.0f});
+    static constexpr auto rcoeffs_pw = CalcDirectionCoeffs({ 1.0f, 0.0f, 0.0f});
+    static constexpr auto lcoeffs_nrml = CalcDirectionCoeffs({-inv_sqrt2, 0.0f, inv_sqrt2});
+    static constexpr auto rcoeffs_nrml = CalcDirectionCoeffs({ inv_sqrt2, 0.0f, inv_sqrt2});
+    auto &lcoeffs = (device->mRenderMode != RenderMode::Pairwise) ? lcoeffs_nrml : lcoeffs_pw;
+    auto &rcoeffs = (device->mRenderMode != RenderMode::Pairwise) ? rcoeffs_nrml : rcoeffs_pw;
 
     mOutTarget = target.Main->Buffer;
-    ComputePanGains(target.Main, coeffs[0], slot->Params.Gain, mGains[0].Target);
-    ComputePanGains(target.Main, coeffs[1], slot->Params.Gain, mGains[1].Target);
+    ComputePanGains(target.Main, lcoeffs.data(), slot->Gain, mGains[0].Target);
+    ComputePanGains(target.Main, rcoeffs.data(), slot->Gain, mGains[1].Target);
 }
 
 void FshifterState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    static constexpr complex_d complex_zero{0.0, 0.0};
-    ALfloat *RESTRICT BufferOut = mBufferOut;
-    size_t j, k;
-
     for(size_t base{0u};base < samplesToDo;)
     {
-        const size_t todo{minz(HIL_SIZE-mCount, samplesToDo-base)};
-
-        ASSUME(todo > 0);
+        size_t todo{minz(HilStep-mCount, samplesToDo-base)};
 
         /* Fill FIFO buffer with samples data */
-        k = mCount;
-        for(j = 0;j < todo;j++,k++)
-        {
-            mInFIFO[k] = samplesIn[0][base+j];
-            mOutdata[base+j] = mOutFIFO[k-FIFO_LATENCY];
-        }
-        mCount += todo;
-        base += todo;
+        const size_t pos{mPos};
+        size_t count{mCount};
+        do {
+            mInFIFO[pos+count] = samplesIn[0][base];
+            mOutdata[base] = mOutFIFO[count];
+            ++base; ++count;
+        } while(--todo);
+        mCount = count;
 
         /* Check whether FIFO buffer is filled */
-        if(mCount < HIL_SIZE) continue;
-        mCount = FIFO_LATENCY;
+        if(mCount < HilStep) break;
+        mCount = 0;
+        mPos = (mPos+HilStep) & (HilSize-1);
 
         /* Real signal windowing and store in Analytic buffer */
-        for(k = 0;k < HIL_SIZE;k++)
-        {
-            mAnalytic[k].real(mInFIFO[k] * HannWindow[k]);
-            mAnalytic[k].imag(0.0);
-        }
+        for(size_t src{mPos}, k{0u};src < HilSize;++src,++k)
+            mAnalytic[k] = mInFIFO[src]*gWindow.mData[k];
+        for(size_t src{0u}, k{HilSize-mPos};src < mPos;++src,++k)
+            mAnalytic[k] = mInFIFO[src]*gWindow.mData[k];
 
         /* Processing signal by Discrete Hilbert Transform (analytical signal). */
         complex_hilbert(mAnalytic);
 
         /* Windowing and add to output accumulator */
-        for(k = 0;k < HIL_SIZE;k++)
-            mOutputAccum[k] += 2.0/OVERSAMP*HannWindow[k]*mAnalytic[k];
-
-        /* Shift accumulator, input & output FIFO */
-        for(k = 0;k < HIL_STEP;k++) mOutFIFO[k] = mOutputAccum[k];
-        for(j = 0;k < HIL_SIZE;k++,j++) mOutputAccum[j] = mOutputAccum[k];
-        for(;j < HIL_SIZE;j++) mOutputAccum[j] = complex_zero;
-        for(k = 0;k < FIFO_LATENCY;k++)
-            mInFIFO[k] = mInFIFO[k+HIL_STEP];
+        for(size_t dst{mPos}, k{0u};dst < HilSize;++dst,++k)
+            mOutputAccum[dst] += 2.0/OversampleFactor*gWindow.mData[k]*mAnalytic[k];
+        for(size_t dst{0u}, k{HilSize-mPos};dst < mPos;++dst,++k)
+            mOutputAccum[dst] += 2.0/OversampleFactor*gWindow.mData[k]*mAnalytic[k];
+
+        /* Copy out the accumulated result, then clear for the next iteration. */
+        std::copy_n(mOutputAccum.cbegin() + mPos, HilStep, mOutFIFO.begin());
+        std::fill_n(mOutputAccum.begin() + mPos, HilStep, complex_d{});
     }
 
     /* Process frequency shifter using the analytic signal obtained. */
-    for(ALsizei c{0};c < 2;++c)
+    float *RESTRICT BufferOut{al::assume_aligned<16>(mBufferOut.data())};
+    for(size_t c{0};c < 2;++c)
     {
-        for(k = 0;k < samplesToDo;++k)
+        const uint phase_step{mPhaseStep[c]};
+        uint phase_idx{mPhase[c]};
+        for(size_t k{0};k < samplesToDo;++k)
         {
-            double phase = mPhase[c] * ((1.0 / FRACTIONONE) * al::MathDefs<double>::Tau());
+            const double phase{phase_idx * (al::numbers::pi*2.0 / MixerFracOne)};
             BufferOut[k] = static_cast<float>(mOutdata[k].real()*std::cos(phase) +
                 mOutdata[k].imag()*std::sin(phase)*mSign[c]);
 
-            mPhase[c] += mPhaseStep[c];
-            mPhase[c] &= FRACTIONMASK;
+            phase_idx += phase_step;
+            phase_idx &= MixerFracMask;
         }
+        mPhase[c] = phase_idx;
 
         /* Now, mix the processed sound data to the output. */
         MixSamples({BufferOut, samplesToDo}, samplesOut, mGains[c].Current, mGains[c].Target,
@@ -229,100 +241,11 @@ void FshifterState::process(const size_t samplesToDo, const al::span<const Float
 }
 
 
-void Fshifter_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_FREQUENCY_SHIFTER_FREQUENCY:
-            if(!(val >= AL_FREQUENCY_SHIFTER_MIN_FREQUENCY && val <= AL_FREQUENCY_SHIFTER_MAX_FREQUENCY))
-                SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter frequency out of range");
-            props->Fshifter.Frequency = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x",
-                param);
-    }
-}
-void Fshifter_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Fshifter_setParamf(props, context, param, vals[0]); }
-
-void Fshifter_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
-            if(!(val >= AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION && val <= AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION))
-                SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter left direction out of range");
-            props->Fshifter.LeftDirection = val;
-            break;
-
-        case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
-            if(!(val >= AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION && val <= AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION))
-                SETERR_RETURN(context, AL_INVALID_VALUE,,"Frequency shifter right direction out of range");
-            props->Fshifter.RightDirection = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid frequency shifter integer property 0x%04x",
-                param);
-    }
-}
-void Fshifter_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Fshifter_setParami(props, context, param, vals[0]); }
-
-void Fshifter_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
-    {
-        case AL_FREQUENCY_SHIFTER_LEFT_DIRECTION:
-            *val = props->Fshifter.LeftDirection;
-            break;
-        case AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION:
-            *val = props->Fshifter.RightDirection;
-            break;
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid frequency shifter integer property 0x%04x",
-                param);
-    }
-}
-void Fshifter_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Fshifter_getParami(props, context, param, vals); }
-
-void Fshifter_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val)
-{
-    switch(param)
-    {
-        case AL_FREQUENCY_SHIFTER_FREQUENCY:
-            *val = props->Fshifter.Frequency;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid frequency shifter float property 0x%04x",
-                param);
-    }
-}
-void Fshifter_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Fshifter_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Fshifter);
-
-
 struct FshifterStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new FshifterState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Fshifter_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new FshifterState{}}; }
 };
 
-EffectProps FshifterStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Fshifter.Frequency      = AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY;
-    props.Fshifter.LeftDirection  = AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION;
-    props.Fshifter.RightDirection = AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *FshifterStateFactory_getFactory()
diff --git a/alc/effects/modulator.cpp b/alc/effects/modulator.cpp
index aee896fb..14ee5004 100644
--- a/alc/effects/modulator.cpp
+++ b/alc/effects/modulator.cpp
@@ -20,44 +20,53 @@
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
-
-#include <cmath>
 #include <algorithm>
-
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "filters/biquad.h"
-#include "vecmat.h"
+#include <array>
+#include <cstdlib>
+#include <iterator>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
 
 
 namespace {
 
+using uint = unsigned int;
+
 #define MAX_UPDATE_SAMPLES 128
 
 #define WAVEFORM_FRACBITS  24
 #define WAVEFORM_FRACONE   (1<<WAVEFORM_FRACBITS)
 #define WAVEFORM_FRACMASK  (WAVEFORM_FRACONE-1)
 
-inline float Sin(ALuint index)
+inline float Sin(uint index)
 {
-    constexpr float scale{al::MathDefs<float>::Tau() / WAVEFORM_FRACONE};
+    constexpr float scale{al::numbers::pi_v<float>*2.0f / WAVEFORM_FRACONE};
     return std::sin(static_cast<float>(index) * scale);
 }
 
-inline float Saw(ALuint index)
+inline float Saw(uint index)
 { return static_cast<float>(index)*(2.0f/WAVEFORM_FRACONE) - 1.0f; }
 
-inline float Square(ALuint index)
+inline float Square(uint index)
 { return static_cast<float>(static_cast<int>((index>>(WAVEFORM_FRACBITS-2))&2) - 1); }
 
-inline float One(ALuint) { return 1.0f; }
+inline float One(uint) { return 1.0f; }
 
-template<float (&func)(ALuint)>
-void Modulate(float *RESTRICT dst, ALuint index, const ALuint step, size_t todo)
+template<float (&func)(uint)>
+void Modulate(float *RESTRICT dst, uint index, const uint step, size_t todo)
 {
     for(size_t i{0u};i < todo;i++)
     {
@@ -69,90 +78,99 @@ void Modulate(float *RESTRICT dst, ALuint index, const ALuint step, size_t todo)
 
 
 struct ModulatorState final : public EffectState {
-    void (*mGetSamples)(float*RESTRICT, ALuint, const ALuint, size_t){};
+    void (*mGetSamples)(float*RESTRICT, uint, const uint, size_t){};
 
-    ALuint mIndex{0};
-    ALuint mStep{1};
+    uint mIndex{0};
+    uint mStep{1};
 
     struct {
-        BiquadFilter Filter;
+        uint mTargetChannel{InvalidChannelIndex};
+
+        BiquadFilter mFilter;
 
-        ALfloat CurrentGains[MAX_OUTPUT_CHANNELS]{};
-        ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
-    } mChans[MAX_AMBI_CHANNELS];
+        float mCurrentGain{};
+        float mTargetGain{};
+    } mChans[MaxAmbiChannels];
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(ModulatorState)
 };
 
-ALboolean ModulatorState::deviceUpdate(const ALCdevice*)
+void ModulatorState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     for(auto &e : mChans)
     {
-        e.Filter.clear();
-        std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
+        e.mTargetChannel = InvalidChannelIndex;
+        e.mFilter.clear();
+        e.mCurrentGain = 0.0f;
     }
-    return AL_TRUE;
 }
 
-void ModulatorState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void ModulatorState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
+    const DeviceBase *device{context->mDevice};
 
-    const float step{props->Modulator.Frequency / static_cast<ALfloat>(device->Frequency)};
-    mStep = fastf2u(clampf(step*WAVEFORM_FRACONE, 0.0f, ALfloat{WAVEFORM_FRACONE-1}));
+    const float step{props->Modulator.Frequency / static_cast<float>(device->Frequency)};
+    mStep = fastf2u(clampf(step*WAVEFORM_FRACONE, 0.0f, float{WAVEFORM_FRACONE-1}));
 
     if(mStep == 0)
         mGetSamples = Modulate<One>;
-    else if(props->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
+    else if(props->Modulator.Waveform == ModulatorWaveform::Sinusoid)
         mGetSamples = Modulate<Sin>;
-    else if(props->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
+    else if(props->Modulator.Waveform == ModulatorWaveform::Sawtooth)
         mGetSamples = Modulate<Saw>;
-    else /*if(props->Modulator.Waveform == AL_RING_MODULATOR_SQUARE)*/
+    else /*if(props->Modulator.Waveform == ModulatorWaveform::Square)*/
         mGetSamples = Modulate<Square>;
 
-    ALfloat f0norm{props->Modulator.HighPassCutoff / static_cast<ALfloat>(device->Frequency)};
+    float f0norm{props->Modulator.HighPassCutoff / static_cast<float>(device->Frequency)};
     f0norm = clampf(f0norm, 1.0f/512.0f, 0.49f);
     /* Bandwidth value is constant in octaves. */
-    mChans[0].Filter.setParams(BiquadType::HighPass, 1.0f, f0norm,
-        BiquadFilter::rcpQFromBandwidth(f0norm, 0.75f));
+    mChans[0].mFilter.setParamsFromBandwidth(BiquadType::HighPass, f0norm, 1.0f, 0.75f);
     for(size_t i{1u};i < slot->Wet.Buffer.size();++i)
-        mChans[i].Filter.copyParamsFrom(mChans[0].Filter);
+        mChans[i].mFilter.copyParamsFrom(mChans[0].mFilter);
 
     mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
+    auto set_channel = [this](size_t idx, uint outchan, float outgain)
     {
-        auto coeffs = GetAmbiIdentityRow(i);
-        ComputePanGains(target.Main, coeffs.data(), slot->Params.Gain, mChans[i].TargetGains);
-    }
+        mChans[idx].mTargetChannel = outchan;
+        mChans[idx].mTargetGain = outgain;
+    };
+    target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 }
 
 void ModulatorState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
     for(size_t base{0u};base < samplesToDo;)
     {
-        alignas(16) ALfloat modsamples[MAX_UPDATE_SAMPLES];
-        size_t td{minz(MAX_UPDATE_SAMPLES, samplesToDo-base)};
+        alignas(16) float modsamples[MAX_UPDATE_SAMPLES];
+        const size_t td{minz(MAX_UPDATE_SAMPLES, samplesToDo-base)};
 
         mGetSamples(modsamples, mIndex, mStep, td);
-        mIndex += static_cast<ALuint>(mStep * td);
+        mIndex += static_cast<uint>(mStep * td);
         mIndex &= WAVEFORM_FRACMASK;
 
-        auto chandata = std::addressof(mChans[0]);
+        auto chandata = std::begin(mChans);
         for(const auto &input : samplesIn)
         {
-            alignas(16) ALfloat temps[MAX_UPDATE_SAMPLES];
-
-            chandata->Filter.process(temps, &input[base], td);
-            for(size_t i{0u};i < td;i++)
-                temps[i] *= modsamples[i];
-
-            MixSamples({temps, td}, samplesOut, chandata->CurrentGains, chandata->TargetGains,
-                samplesToDo-base, base);
+            const size_t outidx{chandata->mTargetChannel};
+            if(outidx != InvalidChannelIndex)
+            {
+                alignas(16) float temps[MAX_UPDATE_SAMPLES];
+
+                chandata->mFilter.process({&input[base], td}, temps);
+                for(size_t i{0u};i < td;i++)
+                    temps[i] *= modsamples[i];
+
+                MixSamples({temps, td}, samplesOut[outidx].data()+base, chandata->mCurrentGain,
+                    chandata->mTargetGain, samplesToDo-base);
+            }
             ++chandata;
         }
 
@@ -161,106 +179,11 @@ void ModulatorState::process(const size_t samplesToDo, const al::span<const Floa
 }
 
 
-void Modulator_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_RING_MODULATOR_FREQUENCY:
-            if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator frequency out of range");
-            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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Modulator high-pass cutoff out of range");
-            props->Modulator.HighPassCutoff = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
-    }
-}
-void Modulator_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Modulator_setParamf(props, context, param, vals[0]); }
-void Modulator_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_RING_MODULATOR_FREQUENCY:
-        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
-            Modulator_setParamf(props, context, param, static_cast<ALfloat>(val));
-            break;
-
-        case AL_RING_MODULATOR_WAVEFORM:
-            if(!(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Invalid modulator waveform");
-            props->Modulator.Waveform = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
-    }
-}
-void Modulator_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Modulator_setParami(props, context, param, vals[0]); }
-
-void Modulator_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
-    {
-        case AL_RING_MODULATOR_FREQUENCY:
-            *val = static_cast<ALint>(props->Modulator.Frequency);
-            break;
-        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
-            *val = static_cast<ALint>(props->Modulator.HighPassCutoff);
-            break;
-        case AL_RING_MODULATOR_WAVEFORM:
-            *val = props->Modulator.Waveform;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x", param);
-    }
-}
-void Modulator_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Modulator_getParami(props, context, param, vals); }
-void Modulator_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param);
-    }
-}
-void Modulator_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Modulator_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Modulator);
-
-
 struct ModulatorStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new ModulatorState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Modulator_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ModulatorState{}}; }
 };
 
-EffectProps ModulatorStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Modulator.Frequency      = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
-    props.Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
-    props.Modulator.Waveform       = AL_RING_MODULATOR_DEFAULT_WAVEFORM;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *ModulatorStateFactory_getFactory()
diff --git a/alc/effects/null.cpp b/alc/effects/null.cpp
index e0497296..1f9ae67b 100644
--- a/alc/effects/null.cpp
+++ b/alc/effects/null.cpp
@@ -1,15 +1,17 @@
 
 #include "config.h"
 
-#include "AL/al.h"
-#include "AL/alc.h"
+#include <stddef.h>
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
 #include "almalloc.h"
 #include "alspan.h"
-#include "effects/base.h"
+#include "base.h"
+#include "core/bufferline.h"
+#include "intrusive_ptr.h"
+
+struct ContextBase;
+struct DeviceBase;
+struct EffectSlot;
 
 
 namespace {
@@ -18,9 +20,11 @@ struct NullState final : public EffectState {
     NullState();
     ~NullState() override;
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(NullState)
 };
@@ -40,15 +44,14 @@ NullState::~NullState() = default;
  * format) have been changed. Will always be followed by a call to the update
  * method, if successful.
  */
-ALboolean NullState::deviceUpdate(const ALCdevice* /*device*/)
+void NullState::deviceUpdate(const DeviceBase* /*device*/, const BufferStorage* /*buffer*/)
 {
-    return AL_TRUE;
 }
 
 /* This updates the effect state with new properties. This is called any time
  * the effect is (re)loaded into a slot.
  */
-void NullState::update(const ALCcontext* /*context*/, const ALeffectslot* /*slot*/,
+void NullState::update(const ContextBase* /*context*/, const EffectSlot* /*slot*/,
     const EffectProps* /*props*/, const EffectTarget /*target*/)
 {
 }
@@ -64,97 +67,13 @@ void NullState::process(const size_t/*samplesToDo*/,
 }
 
 
-void NullEffect_setParami(EffectProps* /*props*/, ALCcontext *context, ALenum param, ALint /*val*/)
-{
-    switch(param)
-    {
-    default:
-        context->setError(AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x", param);
-    }
-}
-void NullEffect_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{
-    switch(param)
-    {
-    default:
-        NullEffect_setParami(props, context, param, vals[0]);
-    }
-}
-void NullEffect_setParamf(EffectProps* /*props*/, ALCcontext *context, ALenum param, ALfloat /*val*/)
-{
-    switch(param)
-    {
-    default:
-        context->setError(AL_INVALID_ENUM, "Invalid null effect float property 0x%04x", param);
-    }
-}
-void NullEffect_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{
-    switch(param)
-    {
-    default:
-        NullEffect_setParamf(props, context, param, vals[0]);
-    }
-}
-
-void NullEffect_getParami(const EffectProps* /*props*/, ALCcontext *context, ALenum param, ALint* /*val*/)
-{
-    switch(param)
-    {
-    default:
-        context->setError(AL_INVALID_ENUM, "Invalid null effect integer property 0x%04x", param);
-    }
-}
-void NullEffect_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{
-    switch(param)
-    {
-    default:
-        NullEffect_getParami(props, context, param, vals);
-    }
-}
-void NullEffect_getParamf(const EffectProps* /*props*/, ALCcontext *context, ALenum param, ALfloat* /*val*/)
-{
-    switch(param)
-    {
-    default:
-        context->setError(AL_INVALID_ENUM, "Invalid null effect float property 0x%04x", param);
-    }
-}
-void NullEffect_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{
-    switch(param)
-    {
-    default:
-        NullEffect_getParamf(props, context, param, vals);
-    }
-}
-
-DEFINE_ALEFFECT_VTABLE(NullEffect);
-
-
 struct NullStateFactory final : public EffectStateFactory {
-    EffectState *create() override;
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override;
+    al::intrusive_ptr<EffectState> create() override;
 };
 
 /* Creates EffectState objects of the appropriate type. */
-EffectState *NullStateFactory::create()
-{ return new NullState{}; }
-
-/* Returns an ALeffectProps initialized with this effect type's default
- * property values.
- */
-EffectProps NullStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    return props;
-}
-
-/* Returns a pointer to this effect type's global set/get vtable. */
-const EffectVtable *NullStateFactory::getEffectVtable() const noexcept
-{ return &NullEffect_vtable; }
+al::intrusive_ptr<EffectState> NullStateFactory::create()
+{ return al::intrusive_ptr<EffectState>{new NullState{}}; }
 
 } // namespace
 
diff --git a/alc/effects/pshifter.cpp b/alc/effects/pshifter.cpp
index d7ba072e..426a2264 100644
--- a/alc/effects/pshifter.cpp
+++ b/alc/effects/pshifter.cpp
@@ -20,350 +20,284 @@
 
 #include "config.h"
 
-#ifdef HAVE_SSE_INTRINSICS
-#include <emmintrin.h>
-#endif
-
-#include <cmath>
-#include <cstdlib>
+#include <algorithm>
 #include <array>
+#include <cmath>
 #include <complex>
-#include <algorithm>
+#include <cstdlib>
+#include <iterator>
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
+#include "alc/effects/base.h"
 #include "alcomplex.h"
-#include "alcontext.h"
+#include "almalloc.h"
+#include "alnumbers.h"
 #include "alnumeric.h"
-#include "alu.h"
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "intrusive_ptr.h"
+
+struct ContextBase;
 
 
 namespace {
 
-using complex_d = std::complex<double>;
+using uint = unsigned int;
+using complex_f = std::complex<float>;
 
-#define STFT_SIZE      1024
-#define STFT_HALF_SIZE (STFT_SIZE>>1)
-#define OVERSAMP       (1<<2)
+constexpr size_t StftSize{1024};
+constexpr size_t StftHalfSize{StftSize >> 1};
+constexpr size_t OversampleFactor{8};
 
-#define STFT_STEP    (STFT_SIZE / OVERSAMP)
-#define FIFO_LATENCY (STFT_STEP * (OVERSAMP-1))
+static_assert(StftSize%OversampleFactor == 0, "Factor must be a clean divisor of the size");
+constexpr size_t StftStep{StftSize / OversampleFactor};
 
 /* Define a Hann window, used to filter the STFT input and output. */
-/* Making this constexpr seems to require C++14. */
-std::array<ALdouble,STFT_SIZE> InitHannWindow()
-{
-    std::array<ALdouble,STFT_SIZE> ret;
-    /* Create lookup table of the Hann window for the desired size, i.e. HIL_SIZE */
-    for(size_t i{0};i < STFT_SIZE>>1;i++)
+struct Windower {
+    alignas(16) std::array<float,StftSize> mData;
+
+    Windower()
     {
-        constexpr double scale{al::MathDefs<double>::Pi() / double{STFT_SIZE-1}};
-        const double val{std::sin(static_cast<double>(i) * scale)};
-        ret[i] = ret[STFT_SIZE-1-i] = val * val;
+        /* Create lookup table of the Hann window for the desired size. */
+        for(size_t i{0};i < StftHalfSize;i++)
+        {
+            constexpr double scale{al::numbers::pi / double{StftSize}};
+            const double val{std::sin((static_cast<double>(i)+0.5) * scale)};
+            mData[i] = mData[StftSize-1-i] = static_cast<float>(val * val);
+        }
     }
-    return ret;
-}
-alignas(16) const std::array<ALdouble,STFT_SIZE> HannWindow = InitHannWindow();
-
-
-struct ALphasor {
-    ALdouble Amplitude;
-    ALdouble Phase;
 };
+const Windower gWindow{};
 
-struct ALfrequencyDomain {
-    ALdouble Amplitude;
-    ALdouble Frequency;
-};
 
-
-/* Converts complex to ALphasor */
-inline ALphasor rect2polar(const complex_d &number)
-{
-    ALphasor polar;
-    polar.Amplitude = std::abs(number);
-    polar.Phase     = std::arg(number);
-    return polar;
-}
-
-/* Converts ALphasor to complex */
-inline complex_d polar2rect(const ALphasor &number)
-{ return std::polar<double>(number.Amplitude, number.Phase); }
+struct FrequencyBin {
+    float Magnitude;
+    float FreqBin;
+};
 
 
 struct PshifterState final : public EffectState {
     /* Effect parameters */
-    size_t  mCount;
-    ALuint  mPitchShiftI;
-    ALfloat mPitchShift;
-    ALfloat mFreqPerBin;
+    size_t mCount;
+    size_t mPos;
+    uint mPitchShiftI;
+    float mPitchShift;
 
     /* Effects buffers */
-    ALfloat mInFIFO[STFT_SIZE];
-    ALfloat mOutFIFO[STFT_STEP];
-    ALdouble mLastPhase[STFT_HALF_SIZE+1];
-    ALdouble mSumPhase[STFT_HALF_SIZE+1];
-    ALdouble mOutputAccum[STFT_SIZE];
+    std::array<float,StftSize> mFIFO;
+    std::array<float,StftHalfSize+1> mLastPhase;
+    std::array<float,StftHalfSize+1> mSumPhase;
+    std::array<float,StftSize> mOutputAccum;
 
-    complex_d mFFTbuffer[STFT_SIZE];
+    std::array<complex_f,StftSize> mFftBuffer;
 
-    ALfrequencyDomain mAnalysis_buffer[STFT_HALF_SIZE+1];
-    ALfrequencyDomain mSyntesis_buffer[STFT_HALF_SIZE+1];
+    std::array<FrequencyBin,StftHalfSize+1> mAnalysisBuffer;
+    std::array<FrequencyBin,StftHalfSize+1> mSynthesisBuffer;
 
-    alignas(16) ALfloat mBufferOut[BUFFERSIZE];
+    alignas(16) FloatBufferLine mBufferOut;
 
     /* Effect gains for each output channel */
-    ALfloat mCurrentGains[MAX_OUTPUT_CHANNELS];
-    ALfloat mTargetGains[MAX_OUTPUT_CHANNELS];
+    float mCurrentGains[MaxAmbiChannels];
+    float mTargetGains[MaxAmbiChannels];
 
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(PshifterState)
 };
 
-ALboolean PshifterState::deviceUpdate(const ALCdevice *device)
+void PshifterState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     /* (Re-)initializing parameters and clear the buffers. */
-    mCount       = FIFO_LATENCY;
-    mPitchShiftI = FRACTIONONE;
+    mCount       = 0;
+    mPos         = StftSize - StftStep;
+    mPitchShiftI = MixerFracOne;
     mPitchShift  = 1.0f;
-    mFreqPerBin  = static_cast<float>(device->Frequency) / float{STFT_SIZE};
 
-    std::fill(std::begin(mInFIFO),          std::end(mInFIFO),          0.0f);
-    std::fill(std::begin(mOutFIFO),         std::end(mOutFIFO),         0.0f);
-    std::fill(std::begin(mLastPhase),       std::end(mLastPhase),       0.0);
-    std::fill(std::begin(mSumPhase),        std::end(mSumPhase),        0.0);
-    std::fill(std::begin(mOutputAccum),     std::end(mOutputAccum),     0.0);
-    std::fill(std::begin(mFFTbuffer),       std::end(mFFTbuffer),       complex_d{});
-    std::fill(std::begin(mAnalysis_buffer), std::end(mAnalysis_buffer), ALfrequencyDomain{});
-    std::fill(std::begin(mSyntesis_buffer), std::end(mSyntesis_buffer), ALfrequencyDomain{});
+    mFIFO.fill(0.0f);
+    mLastPhase.fill(0.0f);
+    mSumPhase.fill(0.0f);
+    mOutputAccum.fill(0.0f);
+    mFftBuffer.fill(complex_f{});
+    mAnalysisBuffer.fill(FrequencyBin{});
+    mSynthesisBuffer.fill(FrequencyBin{});
 
     std::fill(std::begin(mCurrentGains), std::end(mCurrentGains), 0.0f);
     std::fill(std::begin(mTargetGains),  std::end(mTargetGains),  0.0f);
-
-    return AL_TRUE;
 }
 
-void PshifterState::update(const ALCcontext*, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void PshifterState::update(const ContextBase*, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const float pitch{std::pow(2.0f,
-        static_cast<ALfloat>(props->Pshifter.CoarseTune*100 + props->Pshifter.FineTune) / 1200.0f
-    )};
-    mPitchShiftI = fastf2u(pitch*FRACTIONONE);
-    mPitchShift  = static_cast<float>(mPitchShiftI) * (1.0f/FRACTIONONE);
+    const int tune{props->Pshifter.CoarseTune*100 + props->Pshifter.FineTune};
+    const float pitch{std::pow(2.0f, static_cast<float>(tune) / 1200.0f)};
+    mPitchShiftI = clampu(fastf2u(pitch*MixerFracOne), MixerFracHalf, MixerFracOne*2);
+    mPitchShift  = static_cast<float>(mPitchShiftI) * float{1.0f/MixerFracOne};
 
-    ALfloat coeffs[MAX_AMBI_CHANNELS];
-    CalcDirectionCoeffs({0.0f, 0.0f, -1.0f}, 0.0f, coeffs);
+    static constexpr auto coeffs = CalcDirectionCoeffs({0.0f, 0.0f, -1.0f});
 
     mOutTarget = target.Main->Buffer;
-    ComputePanGains(target.Main, coeffs, slot->Params.Gain, mTargetGains);
+    ComputePanGains(target.Main, coeffs.data(), slot->Gain, mTargetGains);
 }
 
-void PshifterState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
+void PshifterState::process(const size_t samplesToDo,
+    const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
     /* Pitch shifter engine based on the work of Stephan Bernsee.
      * http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
      */
 
-    static constexpr ALdouble expected{al::MathDefs<double>::Tau() / OVERSAMP};
-    const ALdouble freq_per_bin{mFreqPerBin};
-    ALfloat *RESTRICT bufferOut{mBufferOut};
-    size_t count{mCount};
+    /* Cycle offset per update expected of each frequency bin (bin 0 is none,
+     * bin 1 is x1, bin 2 is x2, etc).
+     */
+    constexpr float expected_cycles{al::numbers::pi_v<float>*2.0f / OversampleFactor};
 
-    for(size_t i{0u};i < samplesToDo;)
+    for(size_t base{0u};base < samplesToDo;)
     {
-        do {
-            /* Fill FIFO buffer with samples data */
-            mInFIFO[count] = samplesIn[0][i];
-            bufferOut[i] = mOutFIFO[count - FIFO_LATENCY];
+        const size_t todo{minz(StftStep-mCount, samplesToDo-base)};
 
-            count++;
-        } while(++i < samplesToDo && count < STFT_SIZE);
+        /* Retrieve the output samples from the FIFO and fill in the new input
+         * samples.
+         */
+        auto fifo_iter = mFIFO.begin()+mPos + mCount;
+        std::copy_n(fifo_iter, todo, mBufferOut.begin()+base);
 
-        /* Check whether FIFO buffer is filled */
-        if(count < STFT_SIZE) break;
-        count = FIFO_LATENCY;
+        std::copy_n(samplesIn[0].begin()+base, todo, fifo_iter);
+        mCount += todo;
+        base += todo;
 
-        /* Real signal windowing and store in FFTbuffer */
-        for(ALuint k{0u};k < STFT_SIZE;k++)
-        {
-            mFFTbuffer[k].real(mInFIFO[k] * HannWindow[k]);
-            mFFTbuffer[k].imag(0.0);
-        }
+        /* Check whether FIFO buffer is filled with new samples. */
+        if(mCount < StftStep) break;
+        mCount = 0;
+        mPos = (mPos+StftStep) & (mFIFO.size()-1);
 
-        /* ANALYSIS */
-        /* Apply FFT to FFTbuffer data */
-        complex_fft(mFFTbuffer, -1.0);
+        /* Time-domain signal windowing, store in FftBuffer, and apply a
+         * forward FFT to get the frequency-domain signal.
+         */
+        for(size_t src{mPos}, k{0u};src < StftSize;++src,++k)
+            mFftBuffer[k] = mFIFO[src] * gWindow.mData[k];
+        for(size_t src{0u}, k{StftSize-mPos};src < mPos;++src,++k)
+            mFftBuffer[k] = mFIFO[src] * gWindow.mData[k];
+        forward_fft(al::as_span(mFftBuffer));
 
         /* Analyze the obtained data. Since the real FFT is symmetric, only
-         * STFT_HALF_SIZE+1 samples are needed.
+         * StftHalfSize+1 samples are needed.
          */
-        for(ALuint k{0u};k < STFT_HALF_SIZE+1;k++)
+        for(size_t k{0u};k < StftHalfSize+1;k++)
         {
-            /* Compute amplitude and phase */
-            ALphasor component{rect2polar(mFFTbuffer[k])};
-
-            /* Compute phase difference and subtract expected phase difference */
-            double tmp{(component.Phase - mLastPhase[k]) - k*expected};
-
-            /* Map delta phase into +/- Pi interval */
-            int qpd{double2int(tmp / al::MathDefs<double>::Pi())};
-            tmp -= al::MathDefs<double>::Pi() * (qpd + (qpd%2));
-
-            /* Get deviation from bin frequency from the +/- Pi interval */
-            tmp /= expected;
-
-            /* Compute the k-th partials' true frequency, twice the amplitude
-             * for maintain the gain (because half of bins are used) and store
-             * amplitude and true frequency in analysis buffer.
+            const float magnitude{std::abs(mFftBuffer[k])};
+            const float phase{std::arg(mFftBuffer[k])};
+
+            /* Compute the phase difference from the last update and subtract
+             * the expected phase difference for this bin.
+             *
+             * When oversampling, the expected per-update offset increments by
+             * 1/OversampleFactor for every frequency bin. So, the offset wraps
+             * every 'OversampleFactor' bin.
              */
-            mAnalysis_buffer[k].Amplitude = 2.0 * component.Amplitude;
-            mAnalysis_buffer[k].Frequency = (k + tmp) * freq_per_bin;
+            const auto bin_offset = static_cast<float>(k % OversampleFactor);
+            float tmp{(phase - mLastPhase[k]) - bin_offset*expected_cycles};
+            /* Store the actual phase for the next update. */
+            mLastPhase[k] = phase;
+
+            /* Normalize from pi, and wrap the delta between -1 and +1. */
+            tmp *= al::numbers::inv_pi_v<float>;
+            int qpd{float2int(tmp)};
+            tmp -= static_cast<float>(qpd + (qpd%2));
+
+            /* Get deviation from bin frequency (-0.5 to +0.5), and account for
+             * oversampling.
+             */
+            tmp *= 0.5f * OversampleFactor;
 
-            /* Store actual phase[k] for the calculations in the next frame*/
-            mLastPhase[k] = component.Phase;
+            /* Compute the k-th partials' frequency bin target and store the
+             * magnitude and frequency bin in the analysis buffer. We don't
+             * need the "true frequency" since it's a linear relationship with
+             * the bin.
+             */
+            mAnalysisBuffer[k].Magnitude = magnitude;
+            mAnalysisBuffer[k].FreqBin = static_cast<float>(k) + tmp;
         }
 
-        /* PROCESSING */
-        /* pitch shifting */
-        for(ALuint k{0u};k < STFT_HALF_SIZE+1;k++)
-        {
-            mSyntesis_buffer[k].Amplitude = 0.0;
-            mSyntesis_buffer[k].Frequency = 0.0;
-        }
+        /* Shift the frequency bins according to the pitch adjustment,
+         * accumulating the magnitudes of overlapping frequency bins.
+         */
+        std::fill(mSynthesisBuffer.begin(), mSynthesisBuffer.end(), FrequencyBin{});
 
-        for(size_t k{0u};k < STFT_HALF_SIZE+1;k++)
+        constexpr size_t bin_limit{((StftHalfSize+1)<<MixerFracBits) - MixerFracHalf - 1};
+        const size_t bin_count{minz(StftHalfSize+1, bin_limit/mPitchShiftI + 1)};
+        for(size_t k{0u};k < bin_count;k++)
         {
-            size_t j{(k*mPitchShiftI) >> FRACTIONBITS};
-            if(j >= STFT_HALF_SIZE+1) break;
+            const size_t j{(k*mPitchShiftI + MixerFracHalf) >> MixerFracBits};
 
-            mSyntesis_buffer[j].Amplitude += mAnalysis_buffer[k].Amplitude;
-            mSyntesis_buffer[j].Frequency  = mAnalysis_buffer[k].Frequency * mPitchShift;
+            /* If more than two bins end up together, use the target frequency
+             * bin for the one with the dominant magnitude. There might be a
+             * better way to handle this, but it's better than last-index-wins.
+             */
+            if(mAnalysisBuffer[k].Magnitude > mSynthesisBuffer[j].Magnitude)
+                mSynthesisBuffer[j].FreqBin = mAnalysisBuffer[k].FreqBin * mPitchShift;
+            mSynthesisBuffer[j].Magnitude += mAnalysisBuffer[k].Magnitude;
         }
 
-        /* SYNTHESIS */
-        /* Synthesis the processing data */
-        for(ALuint k{0u};k < STFT_HALF_SIZE+1;k++)
+        /* Reconstruct the frequency-domain signal from the adjusted frequency
+         * bins.
+         */
+        for(size_t k{0u};k < StftHalfSize+1;k++)
         {
-            ALphasor component;
-            ALdouble tmp;
-
-            /* Compute bin deviation from scaled freq */
-            tmp = mSyntesis_buffer[k].Frequency/freq_per_bin - k;
-
-            /* Calculate actual delta phase and accumulate it to get bin phase */
-            mSumPhase[k] += (k + tmp) * expected;
+            /* Calculate the actual delta phase for this bin's target frequency
+             * bin, and accumulate it to get the actual bin phase.
+             */
+            float tmp{mSumPhase[k] + mSynthesisBuffer[k].FreqBin*expected_cycles};
 
-            component.Amplitude = mSyntesis_buffer[k].Amplitude;
-            component.Phase     = mSumPhase[k];
+            /* Wrap between -pi and +pi for the sum. If mSumPhase is left to
+             * grow indefinitely, it will lose precision and produce less exact
+             * phase over time.
+             */
+            tmp *= al::numbers::inv_pi_v<float>;
+            int qpd{float2int(tmp)};
+            tmp -= static_cast<float>(qpd + (qpd%2));
+            mSumPhase[k] = tmp * al::numbers::pi_v<float>;
 
-            /* Compute phasor component to cartesian complex number and storage it into FFTbuffer*/
-            mFFTbuffer[k] = polar2rect(component);
+            mFftBuffer[k] = std::polar(mSynthesisBuffer[k].Magnitude, mSumPhase[k]);
         }
-        /* zero negative frequencies for recontruct a real signal */
-        for(ALuint k{STFT_HALF_SIZE+1};k < STFT_SIZE;k++)
-            mFFTbuffer[k] = complex_d{};
-
-        /* Apply iFFT to buffer data */
-        complex_fft(mFFTbuffer, 1.0);
-
-        /* Windowing and add to output */
-        for(ALuint k{0u};k < STFT_SIZE;k++)
-            mOutputAccum[k] += HannWindow[k] * mFFTbuffer[k].real() /
-                               (0.5 * STFT_HALF_SIZE * OVERSAMP);
-
-        /* Shift accumulator, input & output FIFO */
-        size_t j, k;
-        for(k = 0;k < STFT_STEP;k++) mOutFIFO[k] = static_cast<ALfloat>(mOutputAccum[k]);
-        for(j = 0;k < STFT_SIZE;k++,j++) mOutputAccum[j] = mOutputAccum[k];
-        for(;j < STFT_SIZE;j++) mOutputAccum[j] = 0.0;
-        for(k = 0;k < FIFO_LATENCY;k++)
-            mInFIFO[k] = mInFIFO[k+STFT_STEP];
-    }
-    mCount = count;
-
-    /* Now, mix the processed sound data to the output. */
-    MixSamples({bufferOut, samplesToDo}, samplesOut, mCurrentGains, mTargetGains,
-        maxz(samplesToDo, 512), 0);
-}
+        for(size_t k{StftHalfSize+1};k < StftSize;++k)
+            mFftBuffer[k] = std::conj(mFftBuffer[StftSize-k]);
 
+        /* Apply an inverse FFT to get the time-domain signal, and accumulate
+         * for the output with windowing.
+         */
+        inverse_fft(al::as_span(mFftBuffer));
 
-void Pshifter_setParamf(EffectProps*, ALCcontext *context, ALenum param, ALfloat)
-{ context->setError(AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param); }
-void Pshifter_setParamfv(EffectProps*, ALCcontext *context, ALenum param, const ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid pitch shifter float-vector property 0x%04x", param); }
+        static constexpr float scale{3.0f / OversampleFactor / StftSize};
+        for(size_t dst{mPos}, k{0u};dst < StftSize;++dst,++k)
+            mOutputAccum[dst] += gWindow.mData[k]*mFftBuffer[k].real() * scale;
+        for(size_t dst{0u}, k{StftSize-mPos};dst < mPos;++dst,++k)
+            mOutputAccum[dst] += gWindow.mData[k]*mFftBuffer[k].real() * scale;
 
-void Pshifter_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_PITCH_SHIFTER_COARSE_TUNE:
-            if(!(val >= AL_PITCH_SHIFTER_MIN_COARSE_TUNE && val <= AL_PITCH_SHIFTER_MAX_COARSE_TUNE))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,,"Pitch shifter fine tune out of range");
-            props->Pshifter.FineTune = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
-                param);
+        /* Copy out the accumulated result, then clear for the next iteration. */
+        std::copy_n(mOutputAccum.begin() + mPos, StftStep, mFIFO.begin() + mPos);
+        std::fill_n(mOutputAccum.begin() + mPos, StftStep, 0.0f);
     }
-}
-void Pshifter_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ Pshifter_setParami(props, context, param, vals[0]); }
 
-void Pshifter_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *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:
-            context->setError(AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
-                param);
-    }
+    /* Now, mix the processed sound data to the output. */
+    MixSamples({mBufferOut.data(), samplesToDo}, samplesOut, mCurrentGains, mTargetGains,
+        maxz(samplesToDo, 512), 0);
 }
-void Pshifter_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ Pshifter_getParami(props, context, param, vals); }
-
-void Pshifter_getParamf(const EffectProps*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param); }
-void Pshifter_getParamfv(const EffectProps*, ALCcontext *context, ALenum param, ALfloat*)
-{ context->setError(AL_INVALID_ENUM, "Invalid pitch shifter float vector-property 0x%04x", param); }
-
-DEFINE_ALEFFECT_VTABLE(Pshifter);
 
 
 struct PshifterStateFactory final : public EffectStateFactory {
-    EffectState *create() override;
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Pshifter_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new PshifterState{}}; }
 };
 
-EffectState *PshifterStateFactory::create()
-{ return new PshifterState{}; }
-
-EffectProps PshifterStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Pshifter.CoarseTune = AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE;
-    props.Pshifter.FineTune   = AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *PshifterStateFactory_getFactory()
diff --git a/alc/effects/reverb.cpp b/alc/effects/reverb.cpp
index 6e56adf2..3875bedb 100644
--- a/alc/effects/reverb.cpp
+++ b/alc/effects/reverb.cpp
@@ -20,32 +20,84 @@
 
 #include "config.h"
 
-#include <cstdio>
-#include <cstdlib>
-#include <cmath>
-
-#include <array>
-#include <numeric>
 #include <algorithm>
+#include <array>
+#include <cstdio>
 #include <functional>
-
-#include "al/auxeffectslot.h"
-#include "al/listener.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
-#include "bformatdec.h"
-#include "filters/biquad.h"
-#include "vector.h"
+#include <iterator>
+#include <numeric>
+#include <stdint.h>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/filters/biquad.h"
+#include "core/filters/splitter.h"
+#include "core/mixer.h"
+#include "core/mixer/defs.h"
+#include "intrusive_ptr.h"
+#include "opthelpers.h"
 #include "vecmat.h"
+#include "vector.h"
 
 /* This is a user config option for modifying the overall output of the reverb
  * effect.
  */
-ALfloat ReverbBoost = 1.0f;
+float ReverbBoost = 1.0f;
 
 namespace {
 
+using uint = unsigned int;
+
+constexpr float MaxModulationTime{4.0f};
+constexpr float DefaultModulationTime{0.25f};
+
+#define MOD_FRACBITS 24
+#define MOD_FRACONE  (1<<MOD_FRACBITS)
+#define MOD_FRACMASK (MOD_FRACONE-1)
+
+
+struct CubicFilter {
+    static constexpr size_t sTableBits{8};
+    static constexpr size_t sTableSteps{1 << sTableBits};
+    static constexpr size_t sTableMask{sTableSteps - 1};
+
+    float mFilter[sTableSteps*2 + 1]{};
+
+    constexpr CubicFilter()
+    {
+        /* This creates a lookup table for a cubic spline filter, with 256
+         * steps between samples. Only half the coefficients are needed, since
+         * Coeff2 is just Coeff1 in reverse and Coeff3 is just Coeff0 in
+         * reverse.
+         */
+        for(size_t i{0};i < sTableSteps;++i)
+        {
+            const double mu{static_cast<double>(i) / double{sTableSteps}};
+            const double mu2{mu*mu}, mu3{mu2*mu};
+            const double a0{-0.5*mu3 +      mu2 + -0.5*mu};
+            const double a1{ 1.5*mu3 + -2.5*mu2           + 1.0f};
+            mFilter[i] = static_cast<float>(a1);
+            mFilter[sTableSteps+i] = static_cast<float>(a0);
+        }
+    }
+
+    constexpr float getCoeff0(size_t i) const noexcept { return mFilter[sTableSteps+i]; }
+    constexpr float getCoeff1(size_t i) const noexcept { return mFilter[i]; }
+    constexpr float getCoeff2(size_t i) const noexcept { return mFilter[sTableSteps-i]; }
+    constexpr float getCoeff3(size_t i) const noexcept { return mFilter[sTableSteps*2-i]; }
+};
+constexpr CubicFilter gCubicTable;
+
+
 using namespace std::placeholders;
 
 /* Max samples per process iteration. Used to limit the size needed for
@@ -61,6 +113,15 @@ constexpr size_t MAX_UPDATE_SAMPLES{256};
 constexpr size_t NUM_LINES{4u};
 
 
+/* This coefficient is used to define the maximum frequency range controlled by
+ * the modulation depth. The current value of 0.05 will allow it to swing from
+ * 0.95x to 1.05x. This value must be below 1. At 1 it will cause the sampler
+ * to stall on the downswing, and above 1 it will cause it to sample backwards.
+ * The value 0.05 seems be nearest to Creative hardware behavior.
+ */
+constexpr float MODULATION_DEPTH_COEFF{0.05f};
+
+
 /* The B-Format to A-Format conversion matrix. The arrangement of rows is
  * deliberately chosen to align the resulting lines to their spatial opposites
  * (0:above front left <-> 3:above back right, 1:below front right <-> 2:below
@@ -68,21 +129,29 @@ constexpr size_t NUM_LINES{4u};
  * tetrahedron, but it's close enough. Should the model be extended to 8-lines
  * in the future, true opposites can be used.
  */
-alignas(16) constexpr ALfloat B2A[NUM_LINES][MAX_AMBI_CHANNELS]{
-    { 0.288675134595f,  0.288675134595f,  0.288675134595f,  0.288675134595f },
-    { 0.288675134595f, -0.288675134595f, -0.288675134595f,  0.288675134595f },
-    { 0.288675134595f,  0.288675134595f, -0.288675134595f, -0.288675134595f },
-    { 0.288675134595f, -0.288675134595f,  0.288675134595f, -0.288675134595f }
+alignas(16) constexpr float B2A[NUM_LINES][NUM_LINES]{
+    { 0.5f,  0.5f,  0.5f,  0.5f },
+    { 0.5f, -0.5f, -0.5f,  0.5f },
+    { 0.5f,  0.5f, -0.5f, -0.5f },
+    { 0.5f, -0.5f,  0.5f, -0.5f }
 };
 
-/* Converts A-Format to B-Format. */
-alignas(16) constexpr ALfloat A2B[NUM_LINES][NUM_LINES]{
-    { 0.866025403785f,  0.866025403785f,  0.866025403785f,  0.866025403785f },
-    { 0.866025403785f, -0.866025403785f,  0.866025403785f, -0.866025403785f },
-    { 0.866025403785f, -0.866025403785f, -0.866025403785f,  0.866025403785f },
-    { 0.866025403785f,  0.866025403785f, -0.866025403785f, -0.866025403785f }
-};
+/* Converts A-Format to B-Format for early reflections. */
+alignas(16) constexpr std::array<std::array<float,NUM_LINES>,NUM_LINES> EarlyA2B{{
+    {{ 0.5f,  0.5f,  0.5f,  0.5f }},
+    {{ 0.5f, -0.5f,  0.5f, -0.5f }},
+    {{ 0.5f, -0.5f, -0.5f,  0.5f }},
+    {{ 0.5f,  0.5f, -0.5f, -0.5f }}
+}};
 
+/* Converts A-Format to B-Format for late reverb. */
+constexpr auto InvSqrt2 = static_cast<float>(1.0/al::numbers::sqrt2);
+alignas(16) constexpr std::array<std::array<float,NUM_LINES>,NUM_LINES> LateA2B{{
+    {{ 0.5f,  0.5f,  0.5f,  0.5f }},
+    {{ InvSqrt2, -InvSqrt2,  0.0f,  0.0f }},
+    {{ 0.0f,  0.0f,  InvSqrt2, -InvSqrt2 }},
+    {{ 0.5f,  0.5f, -0.5f, -0.5f }}
+}};
 
 /* The all-pass and delay lines have a variable length dependent on the
  * effect's density parameter, which helps alter the perceived environment
@@ -99,7 +168,7 @@ alignas(16) constexpr ALfloat A2B[NUM_LINES][NUM_LINES]{
  * The density scale below will result in a max line multiplier of 50, for an
  * effective size range of 5m to 50m.
  */
-constexpr ALfloat DENSITY_SCALE{125000.0f};
+constexpr float DENSITY_SCALE{125000.0f};
 
 /* All delay line lengths are specified in seconds.
  *
@@ -145,7 +214,7 @@ constexpr ALfloat DENSITY_SCALE{125000.0f};
  *
  * Assuming an average of 1m, we get the following taps:
  */
-constexpr std::array<ALfloat,NUM_LINES> EARLY_TAP_LENGTHS{{
+constexpr std::array<float,NUM_LINES> EARLY_TAP_LENGTHS{{
     0.0000000e+0f, 2.0213520e-4f, 4.2531060e-4f, 6.7171600e-4f
 }};
 
@@ -155,7 +224,7 @@ constexpr std::array<ALfloat,NUM_LINES> EARLY_TAP_LENGTHS{{
  *
  * Where a is the approximate maximum all-pass cycle limit (20).
  */
-constexpr std::array<ALfloat,NUM_LINES> EARLY_ALLPASS_LENGTHS{{
+constexpr std::array<float,NUM_LINES> EARLY_ALLPASS_LENGTHS{{
     9.7096800e-5f, 1.0720356e-4f, 1.1836234e-4f, 1.3068260e-4f
 }};
 
@@ -181,7 +250,7 @@ constexpr std::array<ALfloat,NUM_LINES> EARLY_ALLPASS_LENGTHS{{
  *
  * Using an average dimension of 1m, we get:
  */
-constexpr std::array<ALfloat,NUM_LINES> EARLY_LINE_LENGTHS{{
+constexpr std::array<float,NUM_LINES> EARLY_LINE_LENGTHS{{
     5.9850400e-4f, 1.0913150e-3f, 1.5376658e-3f, 1.9419362e-3f
 }};
 
@@ -189,7 +258,7 @@ constexpr std::array<ALfloat,NUM_LINES> EARLY_LINE_LENGTHS{{
  *
  *     A_i = (5 / 3) L_i / r_1
  */
-constexpr std::array<ALfloat,NUM_LINES> LATE_ALLPASS_LENGTHS{{
+constexpr std::array<float,NUM_LINES> LATE_ALLPASS_LENGTHS{{
     1.6182800e-4f, 2.0389060e-4f, 2.8159360e-4f, 3.2365600e-4f
 }};
 
@@ -208,7 +277,7 @@ constexpr std::array<ALfloat,NUM_LINES> LATE_ALLPASS_LENGTHS{{
  *
  * For our 1m average room, we get:
  */
-constexpr std::array<ALfloat,NUM_LINES> LATE_LINE_LENGTHS{{
+constexpr std::array<float,NUM_LINES> LATE_LINE_LENGTHS{{
     1.9419362e-3f, 2.4466860e-3f, 3.3791220e-3f, 3.8838720e-3f
 }};
 
@@ -232,13 +301,13 @@ struct DelayLineI {
     { Line = sampleBuffer + LineOffset; }
 
     /* Calculate the length of a delay line and store its mask and offset. */
-    ALuint calcLineLength(const ALfloat length, const uintptr_t offset, const ALfloat frequency,
-        const ALuint extra)
+    uint calcLineLength(const float length, const uintptr_t offset, const float frequency,
+        const uint extra)
     {
         /* All line lengths are powers of 2, calculated from their lengths in
          * seconds, rounded up.
          */
-        ALuint samples{float2uint(std::ceil(length*frequency))};
+        uint samples{float2uint(std::ceil(length*frequency))};
         samples = NextPowerOf2(samples + extra);
 
         /* All lines share a single sample buffer. */
@@ -249,7 +318,7 @@ struct DelayLineI {
         return samples;
     }
 
-    void write(size_t offset, const size_t c, const ALfloat *RESTRICT in, const size_t count) const noexcept
+    void write(size_t offset, const size_t c, const float *RESTRICT in, const size_t count) const noexcept
     {
         ASSUME(count > 0);
         for(size_t i{0u};i < count;)
@@ -265,32 +334,28 @@ struct DelayLineI {
 
 struct VecAllpass {
     DelayLineI Delay;
-    ALfloat Coeff{0.0f};
-    size_t  Offset[NUM_LINES][2]{};
-
-    void processFaded(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
-        const ALfloat xCoeff, const ALfloat yCoeff, ALfloat fadeCount, const ALfloat fadeStep,
-        const size_t todo);
-    void processUnfaded(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
-        const ALfloat xCoeff, const ALfloat yCoeff, const size_t todo);
+    float Coeff{0.0f};
+    size_t Offset[NUM_LINES]{};
+
+    void process(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
+        const float xCoeff, const float yCoeff, const size_t todo);
 };
 
 struct T60Filter {
     /* Two filters are used to adjust the signal. One to control the low
      * frequencies, and one to control the high frequencies.
      */
-    ALfloat MidGain[2]{0.0f, 0.0f};
+    float MidGain{0.0f};
     BiquadFilter HFFilter, LFFilter;
 
-    void calcCoeffs(const ALfloat length, const ALfloat lfDecayTime, const ALfloat mfDecayTime,
-        const ALfloat hfDecayTime, const ALfloat lf0norm, const ALfloat hf0norm);
+    void calcCoeffs(const float length, const float lfDecayTime, const float mfDecayTime,
+        const float hfDecayTime, const float lf0norm, const float hf0norm);
 
     /* Applies the two T60 damping filter sections. */
-    void process(ALfloat *samples, const size_t todo)
-    {
-        HFFilter.process(samples, samples, todo);
-        LFFilter.process(samples, samples, todo);
-    }
+    void process(const al::span<float> samples)
+    { DualBiquad{HFFilter, LFFilter}.process(samples, samples.data()); }
+
+    void clear() noexcept { HFFilter.clear(); LFFilter.clear(); }
 };
 
 struct EarlyReflections {
@@ -303,61 +368,68 @@ struct EarlyReflections {
      * reflections.
      */
     DelayLineI Delay;
-    size_t     Offset[NUM_LINES][2]{};
-    ALfloat    Coeff[NUM_LINES][2]{};
+    size_t Offset[NUM_LINES]{};
+    float Coeff[NUM_LINES]{};
 
     /* The gain for each output channel based on 3D panning. */
-    ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
-    ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
+    float CurrentGains[NUM_LINES][MaxAmbiChannels]{};
+    float TargetGains[NUM_LINES][MaxAmbiChannels]{};
 
-    void updateLines(const ALfloat density, const ALfloat diffusion, const ALfloat decayTime,
-        const ALfloat frequency);
+    void updateLines(const float density_mult, const float diffusion, const float decayTime,
+        const float frequency);
+};
+
+
+struct Modulation {
+    /* The vibrato time is tracked with an index over a (MOD_FRACONE)
+     * normalized range.
+     */
+    uint Index, Step;
+
+    /* The depth of frequency change, in samples. */
+    float Depth;
+
+    float ModDelays[MAX_UPDATE_SAMPLES];
+
+    void updateModulator(float modTime, float modDepth, float frequency);
+
+    void calcDelays(size_t todo);
 };
 
 struct LateReverb {
     /* A recursive delay line is used fill in the reverb tail. */
     DelayLineI Delay;
-    size_t     Offset[NUM_LINES][2]{};
+    size_t     Offset[NUM_LINES]{};
 
     /* Attenuation to compensate for the modal density and decay rate of the
      * late lines.
      */
-    ALfloat DensityGain[2]{0.0f, 0.0f};
+    float DensityGain{0.0f};
 
     /* T60 decay filters are used to simulate absorption. */
     T60Filter T60[NUM_LINES];
 
+    Modulation Mod;
+
     /* A Gerzon vector all-pass filter is used to simulate diffusion. */
     VecAllpass VecAp;
 
     /* The gain for each output channel based on 3D panning. */
-    ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
-    ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
+    float CurrentGains[NUM_LINES][MaxAmbiChannels]{};
+    float TargetGains[NUM_LINES][MaxAmbiChannels]{};
 
-    void updateLines(const ALfloat density, const ALfloat diffusion, const ALfloat lfDecayTime,
-        const ALfloat mfDecayTime, const ALfloat hfDecayTime, const ALfloat lf0norm,
-        const ALfloat hf0norm, const ALfloat frequency);
-};
-
-struct ReverbState final : public EffectState {
-    /* All delay lines are allocated as a single buffer to reduce memory
-     * fragmentation and management code.
-     */
-    al::vector<std::array<float,NUM_LINES>,16> mSampleBuffer;
+    void updateLines(const float density_mult, const float diffusion, const float lfDecayTime,
+        const float mfDecayTime, const float hfDecayTime, const float lf0norm,
+        const float hf0norm, const float frequency);
 
-    struct {
-        /* Calculated parameters which indicate if cross-fading is needed after
-         * an update.
-         */
-        ALfloat Density{AL_EAXREVERB_DEFAULT_DENSITY};
-        ALfloat Diffusion{AL_EAXREVERB_DEFAULT_DIFFUSION};
-        ALfloat DecayTime{AL_EAXREVERB_DEFAULT_DECAY_TIME};
-        ALfloat HFDecayTime{AL_EAXREVERB_DEFAULT_DECAY_HFRATIO * AL_EAXREVERB_DEFAULT_DECAY_TIME};
-        ALfloat LFDecayTime{AL_EAXREVERB_DEFAULT_DECAY_LFRATIO * AL_EAXREVERB_DEFAULT_DECAY_TIME};
-        ALfloat HFReference{AL_EAXREVERB_DEFAULT_HFREFERENCE};
-        ALfloat LFReference{AL_EAXREVERB_DEFAULT_LFREFERENCE};
-    } mParams;
+    void clear() noexcept
+    {
+        for(auto &filter : T60)
+            filter.clear();
+    }
+};
 
+struct ReverbPipeline {
     /* Master effect filters */
     struct {
         BiquadFilter Lp;
@@ -365,28 +437,88 @@ struct ReverbState final : public EffectState {
     } mFilter[NUM_LINES];
 
     /* Core delay line (early reflections and late reverb tap from this). */
-    DelayLineI mDelay;
+    DelayLineI mEarlyDelayIn;
+    DelayLineI mLateDelayIn;
 
     /* Tap points for early reflection delay. */
-    size_t  mEarlyDelayTap[NUM_LINES][2]{};
-    ALfloat mEarlyDelayCoeff[NUM_LINES][2]{};
+    size_t mEarlyDelayTap[NUM_LINES][2]{};
+    float mEarlyDelayCoeff[NUM_LINES]{};
 
     /* Tap points for late reverb feed and delay. */
-    size_t mLateFeedTap{};
     size_t mLateDelayTap[NUM_LINES][2]{};
 
     /* Coefficients for the all-pass and line scattering matrices. */
-    ALfloat mMixX{0.0f};
-    ALfloat mMixY{0.0f};
+    float mMixX{0.0f};
+    float mMixY{0.0f};
 
     EarlyReflections mEarly;
 
     LateReverb mLate;
 
-    bool mDoFading{};
+    std::array<std::array<BandSplitter,NUM_LINES>,2> mAmbiSplitter;
+
+    size_t mFadeSampleCount{1};
+
+    void updateDelayLine(const float earlyDelay, const float lateDelay, const float density_mult,
+        const float decayTime, const float frequency);
+    void update3DPanning(const float *ReflectionsPan, const float *LateReverbPan,
+        const float earlyGain, const float lateGain, const bool doUpmix, const MixParams *mainMix);
 
-    /* Maximum number of samples to process at once. */
-    size_t mMaxUpdate[2]{MAX_UPDATE_SAMPLES, MAX_UPDATE_SAMPLES};
+    void processEarly(size_t offset, const size_t samplesToDo,
+        const al::span<ReverbUpdateLine,NUM_LINES> tempSamples,
+        const al::span<FloatBufferLine,NUM_LINES> outSamples);
+    void processLate(size_t offset, const size_t samplesToDo,
+        const al::span<ReverbUpdateLine,NUM_LINES> tempSamples,
+        const al::span<FloatBufferLine,NUM_LINES> outSamples);
+
+    void clear() noexcept
+    {
+        for(auto &filter : mFilter)
+        {
+            filter.Lp.clear();
+            filter.Hp.clear();
+        }
+        mLate.clear();
+        for(auto &filters : mAmbiSplitter)
+        {
+            for(auto &filter : filters)
+                filter.clear();
+        }
+    }
+};
+
+struct ReverbState final : public EffectState {
+    /* All delay lines are allocated as a single buffer to reduce memory
+     * fragmentation and management code.
+     */
+    al::vector<std::array<float,NUM_LINES>,16> mSampleBuffer;
+
+    struct {
+        /* Calculated parameters which indicate if cross-fading is needed after
+         * an update.
+         */
+        float Density{1.0f};
+        float Diffusion{1.0f};
+        float DecayTime{1.49f};
+        float HFDecayTime{0.83f * 1.49f};
+        float LFDecayTime{1.0f * 1.49f};
+        float ModulationTime{0.25f};
+        float ModulationDepth{0.0f};
+        float HFReference{5000.0f};
+        float LFReference{250.0f};
+    } mParams;
+
+    enum PipelineState : uint8_t {
+        DeviceClear,
+        StartFade,
+        Fading,
+        Cleanup,
+        Normal,
+    };
+    PipelineState mPipelineState{DeviceClear};
+    uint8_t mCurrentPipeline{0};
+
+    ReverbPipeline mPipelines[2];
 
     /* The current write offset for all delay lines. */
     size_t mOffset{};
@@ -396,95 +528,105 @@ struct ReverbState final : public EffectState {
         alignas(16) FloatBufferLine mTempLine{};
         alignas(16) std::array<ReverbUpdateLine,NUM_LINES> mTempSamples;
     };
-    alignas(16) std::array<ReverbUpdateLine,NUM_LINES> mEarlySamples{};
-    alignas(16) std::array<ReverbUpdateLine,NUM_LINES> mLateSamples{};
+    alignas(16) std::array<FloatBufferLine,NUM_LINES> mEarlySamples{};
+    alignas(16) std::array<FloatBufferLine,NUM_LINES> mLateSamples{};
 
-    using MixOutT = void (ReverbState::*)(const al::span<FloatBufferLine> samplesOut,
-        const size_t counter, const size_t offset, const size_t todo);
+    std::array<float,MaxAmbiOrder+1> mOrderScales{};
 
-    MixOutT mMixOut{&ReverbState::MixOutPlain};
-    std::array<ALfloat,MAX_AMBI_ORDER+1> mOrderScales{};
-    std::array<std::array<BandSplitter,NUM_LINES>,2> mAmbiSplitter;
+    bool mUpmixOutput{false};
 
 
-    void MixOutPlain(const al::span<FloatBufferLine> samplesOut, const size_t counter,
-        const size_t offset, const size_t todo)
+    void MixOutPlain(ReverbPipeline &pipeline, const al::span<FloatBufferLine> samplesOut,
+        const size_t todo)
     {
         ASSUME(todo > 0);
 
-        /* Convert back to B-Format, and mix the results to output. */
-        const al::span<float> tmpspan{mTempLine.data(), todo};
+        /* When not upsampling, the panning gains convert to B-Format and pan
+         * at the same time.
+         */
         for(size_t c{0u};c < NUM_LINES;c++)
         {
-            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
-            MixRowSamples(tmpspan, {A2B[c], NUM_LINES}, mEarlySamples[0].data(),
-                mEarlySamples[0].size());
-            MixSamples(tmpspan, samplesOut, mEarly.CurrentGain[c], mEarly.PanGain[c], counter,
-                offset);
+            const al::span<float> tmpspan{mEarlySamples[c].data(), todo};
+            MixSamples(tmpspan, samplesOut, pipeline.mEarly.CurrentGains[c],
+                pipeline.mEarly.TargetGains[c], todo, 0);
         }
         for(size_t c{0u};c < NUM_LINES;c++)
         {
-            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
-            MixRowSamples(tmpspan, {A2B[c], NUM_LINES}, mLateSamples[0].data(),
-                mLateSamples[0].size());
-            MixSamples(tmpspan, samplesOut, mLate.CurrentGain[c], mLate.PanGain[c], counter,
-                offset);
+            const al::span<float> tmpspan{mLateSamples[c].data(), todo};
+            MixSamples(tmpspan, samplesOut, pipeline.mLate.CurrentGains[c],
+                pipeline.mLate.TargetGains[c], todo, 0);
         }
     }
 
-    void MixOutAmbiUp(const al::span<FloatBufferLine> samplesOut, const size_t counter,
-        const size_t offset, const size_t todo)
+    void MixOutAmbiUp(ReverbPipeline &pipeline, const al::span<FloatBufferLine> samplesOut,
+        const size_t todo)
     {
         ASSUME(todo > 0);
 
-        const al::span<float> tmpspan{mTempLine.data(), todo};
+        auto DoMixRow = [](const al::span<float> OutBuffer, const al::span<const float,4> Gains,
+            const float *InSamples, const size_t InStride)
+        {
+            std::fill(OutBuffer.begin(), OutBuffer.end(), 0.0f);
+            for(const float gain : Gains)
+            {
+                const float *RESTRICT input{al::assume_aligned<16>(InSamples)};
+                InSamples += InStride;
+
+                if(!(std::fabs(gain) > GainSilenceThreshold))
+                    continue;
+
+                auto mix_sample = [gain](const float sample, const float in) noexcept -> float
+                { return sample + in*gain; };
+                std::transform(OutBuffer.begin(), OutBuffer.end(), input, OutBuffer.begin(),
+                    mix_sample);
+            }
+        };
+
+        /* When upsampling, the B-Format conversion needs to be done separately
+         * so the proper HF scaling can be applied to each B-Format channel.
+         * The panning gains then pan and upsample the B-Format channels.
+         */
+        const al::span<float> tmpspan{al::assume_aligned<16>(mTempLine.data()), todo};
         for(size_t c{0u};c < NUM_LINES;c++)
         {
-            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
-            MixRowSamples(tmpspan, {A2B[c], NUM_LINES}, mEarlySamples[0].data(),
-                mEarlySamples[0].size());
+            DoMixRow(tmpspan, EarlyA2B[c], mEarlySamples[0].data(), mEarlySamples[0].size());
 
             /* Apply scaling to the B-Format's HF response to "upsample" it to
              * higher-order output.
              */
-            const ALfloat hfscale{(c==0) ? mOrderScales[0] : mOrderScales[1]};
-            mAmbiSplitter[0][c].applyHfScale(tmpspan.data(), hfscale, todo);
+            const float hfscale{(c==0) ? mOrderScales[0] : mOrderScales[1]};
+            pipeline.mAmbiSplitter[0][c].processHfScale(tmpspan, hfscale);
 
-            MixSamples(tmpspan, samplesOut, mEarly.CurrentGain[c], mEarly.PanGain[c], counter,
-                offset);
+            MixSamples(tmpspan, samplesOut, pipeline.mEarly.CurrentGains[c],
+                pipeline.mEarly.TargetGains[c], todo, 0);
         }
         for(size_t c{0u};c < NUM_LINES;c++)
         {
-            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
-            MixRowSamples(tmpspan, {A2B[c], NUM_LINES}, mLateSamples[0].data(),
-                mLateSamples[0].size());
+            DoMixRow(tmpspan, LateA2B[c], mLateSamples[0].data(), mLateSamples[0].size());
 
-            const ALfloat hfscale{(c==0) ? mOrderScales[0] : mOrderScales[1]};
-            mAmbiSplitter[1][c].applyHfScale(tmpspan.data(), hfscale, todo);
+            const float hfscale{(c==0) ? mOrderScales[0] : mOrderScales[1]};
+            pipeline.mAmbiSplitter[1][c].processHfScale(tmpspan, hfscale);
 
-            MixSamples(tmpspan, samplesOut, mLate.CurrentGain[c], mLate.PanGain[c], counter,
-                offset);
+            MixSamples(tmpspan, samplesOut, pipeline.mLate.CurrentGains[c],
+                pipeline.mLate.TargetGains[c], todo, 0);
         }
     }
 
-    bool allocLines(const ALfloat frequency);
-
-    void updateDelayLine(const ALfloat earlyDelay, const ALfloat lateDelay, const ALfloat density,
-        const ALfloat decayTime, const ALfloat frequency);
-    void update3DPanning(const ALfloat *ReflectionsPan, const ALfloat *LateReverbPan,
-        const ALfloat earlyGain, const ALfloat lateGain, const EffectTarget &target);
-
-    void earlyUnfaded(const size_t offset, const size_t todo);
-    void earlyFaded(const size_t offset, const size_t todo, const ALfloat fade,
-        const ALfloat fadeStep);
+    void mixOut(ReverbPipeline &pipeline, const al::span<FloatBufferLine> samplesOut, const size_t todo)
+    {
+        if(mUpmixOutput)
+            MixOutAmbiUp(pipeline, samplesOut, todo);
+        else
+            MixOutPlain(pipeline, samplesOut, todo);
+    }
 
-    void lateUnfaded(const size_t offset, const size_t todo);
-    void lateFaded(const size_t offset, const size_t todo, const ALfloat fade,
-        const ALfloat fadeStep);
+    void allocLines(const float frequency);
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
     DEF_NEWDEL(ReverbState)
 };
@@ -493,14 +635,13 @@ struct ReverbState final : public EffectState {
  *  Device Update                     *
  **************************************/
 
-inline ALfloat CalcDelayLengthMult(ALfloat density)
+inline float CalcDelayLengthMult(float density)
 { return maxf(5.0f, std::cbrt(density*DENSITY_SCALE)); }
 
 /* Calculates the delay line metrics and allocates the shared sample buffer
- * for all lines given the sample rate (frequency).  If an allocation failure
- * occurs, it returns AL_FALSE.
+ * for all lines given the sample rate (frequency).
  */
-bool ReverbState::allocLines(const ALfloat frequency)
+void ReverbState::allocLines(const float frequency)
 {
     /* All delay line lengths are calculated to accomodate the full range of
      * lengths given their respective paramters.
@@ -510,122 +651,137 @@ bool ReverbState::allocLines(const ALfloat frequency)
     /* Multiplier for the maximum density value, i.e. density=1, which is
      * actually the least density...
      */
-    ALfloat multiplier{CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY)};
+    const float multiplier{CalcDelayLengthMult(1.0f)};
 
-    /* The main delay length includes the maximum early reflection delay, the
-     * largest early tap width, the maximum late reverb delay, and the
-     * largest late tap width.  Finally, it must also be extended by the
-     * update size (BUFFERSIZE) for block processing.
+    /* The modulator's line length is calculated from the maximum modulation
+     * time and depth coefficient, and halfed for the low-to-high frequency
+     * swing.
      */
-    ALfloat length{AL_EAXREVERB_MAX_REFLECTIONS_DELAY + EARLY_TAP_LENGTHS.back()*multiplier +
-        AL_EAXREVERB_MAX_LATE_REVERB_DELAY +
-        (LATE_LINE_LENGTHS.back() - LATE_LINE_LENGTHS.front())/float{NUM_LINES}*multiplier};
-    totalSamples += mDelay.calcLineLength(length, totalSamples, frequency, BUFFERSIZE);
-
-    /* The early vector all-pass line. */
-    length = EARLY_ALLPASS_LENGTHS.back() * multiplier;
-    totalSamples += mEarly.VecAp.Delay.calcLineLength(length, totalSamples, frequency, 0);
-
-    /* The early reflection line. */
-    length = EARLY_LINE_LENGTHS.back() * multiplier;
-    totalSamples += mEarly.Delay.calcLineLength(length, totalSamples, frequency, 0);
-
-    /* The late vector all-pass line. */
-    length = LATE_ALLPASS_LENGTHS.back() * multiplier;
-    totalSamples += mLate.VecAp.Delay.calcLineLength(length, totalSamples, frequency, 0);
+    constexpr float max_mod_delay{MaxModulationTime*MODULATION_DEPTH_COEFF / 2.0f};
 
-    /* The late delay lines are calculated from the largest maximum density
-     * line length.
-     */
-    length = LATE_LINE_LENGTHS.back() * multiplier;
-    totalSamples += mLate.Delay.calcLineLength(length, totalSamples, frequency, 0);
-
-    if(totalSamples != mSampleBuffer.size())
+    for(auto &pipeline : mPipelines)
     {
-        mSampleBuffer.resize(totalSamples);
-        mSampleBuffer.shrink_to_fit();
+        /* The main delay length includes the maximum early reflection delay,
+         * the largest early tap width, the maximum late reverb delay, and the
+         * largest late tap width.  Finally, it must also be extended by the
+         * update size (BufferLineSize) for block processing.
+         */
+        float length{ReverbMaxReflectionsDelay + EARLY_TAP_LENGTHS.back()*multiplier};
+        totalSamples += pipeline.mEarlyDelayIn.calcLineLength(length, totalSamples, frequency,
+            BufferLineSize);
+
+        constexpr float LateLineDiffAvg{(LATE_LINE_LENGTHS.back()-LATE_LINE_LENGTHS.front()) /
+            float{NUM_LINES}};
+        length = ReverbMaxLateReverbDelay + LateLineDiffAvg*multiplier;
+        totalSamples += pipeline.mLateDelayIn.calcLineLength(length, totalSamples, frequency,
+            BufferLineSize);
+
+        /* The early vector all-pass line. */
+        length = EARLY_ALLPASS_LENGTHS.back() * multiplier;
+        totalSamples += pipeline.mEarly.VecAp.Delay.calcLineLength(length, totalSamples, frequency,
+            0);
+
+        /* The early reflection line. */
+        length = EARLY_LINE_LENGTHS.back() * multiplier;
+        totalSamples += pipeline.mEarly.Delay.calcLineLength(length, totalSamples, frequency,
+            MAX_UPDATE_SAMPLES);
+
+        /* The late vector all-pass line. */
+        length = LATE_ALLPASS_LENGTHS.back() * multiplier;
+        totalSamples += pipeline.mLate.VecAp.Delay.calcLineLength(length, totalSamples, frequency,
+            0);
+
+        /* The late delay lines are calculated from the largest maximum density
+         * line length, and the maximum modulation delay. Four additional
+         * samples are needed for resampling the modulator delay.
+         */
+        length = LATE_LINE_LENGTHS.back()*multiplier + max_mod_delay;
+        totalSamples += pipeline.mLate.Delay.calcLineLength(length, totalSamples, frequency, 4);
     }
 
+    if(totalSamples != mSampleBuffer.size())
+        decltype(mSampleBuffer)(totalSamples).swap(mSampleBuffer);
+
     /* Clear the sample buffer. */
-    std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), std::array<float,NUM_LINES>{});
+    std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), decltype(mSampleBuffer)::value_type{});
 
     /* Update all delays to reflect the new sample buffer. */
-    mDelay.realizeLineOffset(mSampleBuffer.data());
-    mEarly.VecAp.Delay.realizeLineOffset(mSampleBuffer.data());
-    mEarly.Delay.realizeLineOffset(mSampleBuffer.data());
-    mLate.VecAp.Delay.realizeLineOffset(mSampleBuffer.data());
-    mLate.Delay.realizeLineOffset(mSampleBuffer.data());
-
-    return true;
+    for(auto &pipeline : mPipelines)
+    {
+        pipeline.mEarlyDelayIn.realizeLineOffset(mSampleBuffer.data());
+        pipeline.mLateDelayIn.realizeLineOffset(mSampleBuffer.data());
+        pipeline.mEarly.VecAp.Delay.realizeLineOffset(mSampleBuffer.data());
+        pipeline.mEarly.Delay.realizeLineOffset(mSampleBuffer.data());
+        pipeline.mLate.VecAp.Delay.realizeLineOffset(mSampleBuffer.data());
+        pipeline.mLate.Delay.realizeLineOffset(mSampleBuffer.data());
+    }
 }
 
-ALboolean ReverbState::deviceUpdate(const ALCdevice *device)
+void ReverbState::deviceUpdate(const DeviceBase *device, const BufferStorage*)
 {
-    const auto frequency = static_cast<ALfloat>(device->Frequency);
+    const auto frequency = static_cast<float>(device->Frequency);
 
     /* Allocate the delay lines. */
-    if(!allocLines(frequency))
-        return AL_FALSE;
+    allocLines(frequency);
 
-    const ALfloat multiplier{CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY)};
-
-    /* The late feed taps are set a fixed position past the latest delay tap. */
-    mLateFeedTap = float2uint(
-        (AL_EAXREVERB_MAX_REFLECTIONS_DELAY + EARLY_TAP_LENGTHS.back()*multiplier) * frequency);
-
-    /* Clear filters and gain coefficients since the delay lines were all just
-     * cleared (if not reallocated).
-     */
-    for(auto &filter : mFilter)
+    for(auto &pipeline : mPipelines)
     {
-        filter.Lp.clear();
-        filter.Hp.clear();
-    }
+        /* Clear filters and gain coefficients since the delay lines were all just
+        * cleared (if not reallocated).
+        */
+        for(auto &filter : pipeline.mFilter)
+        {
+            filter.Lp.clear();
+            filter.Hp.clear();
+        }
 
-    for(auto &coeff : mEarlyDelayCoeff)
-        std::fill(std::begin(coeff), std::end(coeff), 0.0f);
-    for(auto &coeff : mEarly.Coeff)
-        std::fill(std::begin(coeff), std::end(coeff), 0.0f);
+        std::fill(std::begin(pipeline.mEarlyDelayCoeff),std::end(pipeline.mEarlyDelayCoeff), 0.0f);
+        std::fill(std::begin(pipeline.mEarlyDelayCoeff),std::end(pipeline.mEarlyDelayCoeff), 0.0f);
 
-    mLate.DensityGain[0] = 0.0f;
-    mLate.DensityGain[1] = 0.0f;
-    for(auto &t60 : mLate.T60)
-    {
-        t60.MidGain[0] = 0.0f;
-        t60.MidGain[1] = 0.0f;
-        t60.HFFilter.clear();
-        t60.LFFilter.clear();
+        pipeline.mLate.DensityGain = 0.0f;
+        for(auto &t60 : pipeline.mLate.T60)
+        {
+            t60.MidGain = 0.0f;
+            t60.HFFilter.clear();
+            t60.LFFilter.clear();
+        }
+
+        pipeline.mLate.Mod.Index = 0;
+        pipeline.mLate.Mod.Step = 1;
+        pipeline.mLate.Mod.Depth = 0.0f;
+
+        for(auto &gains : pipeline.mEarly.CurrentGains)
+            std::fill(std::begin(gains), std::end(gains), 0.0f);
+        for(auto &gains : pipeline.mEarly.TargetGains)
+            std::fill(std::begin(gains), std::end(gains), 0.0f);
+        for(auto &gains : pipeline.mLate.CurrentGains)
+            std::fill(std::begin(gains), std::end(gains), 0.0f);
+        for(auto &gains : pipeline.mLate.TargetGains)
+            std::fill(std::begin(gains), std::end(gains), 0.0f);
     }
+    mPipelineState = DeviceClear;
 
-    for(auto &gains : mEarly.CurrentGain)
-        std::fill(std::begin(gains), std::end(gains), 0.0f);
-    for(auto &gains : mEarly.PanGain)
-        std::fill(std::begin(gains), std::end(gains), 0.0f);
-    for(auto &gains : mLate.CurrentGain)
-        std::fill(std::begin(gains), std::end(gains), 0.0f);
-    for(auto &gains : mLate.PanGain)
-        std::fill(std::begin(gains), std::end(gains), 0.0f);
-
-    /* Reset fading and offset base. */
-    mDoFading = true;
-    std::fill(std::begin(mMaxUpdate), std::end(mMaxUpdate), MAX_UPDATE_SAMPLES);
+    /* Reset offset base. */
     mOffset = 0;
 
     if(device->mAmbiOrder > 1)
     {
-        mMixOut = &ReverbState::MixOutAmbiUp;
-        mOrderScales = BFormatDec::GetHFOrderScales(1, device->mAmbiOrder);
+        mUpmixOutput = true;
+        mOrderScales = AmbiScale::GetHFOrderScales(1, device->mAmbiOrder, device->m2DMixing);
     }
     else
     {
-        mMixOut = &ReverbState::MixOutPlain;
+        mUpmixOutput = false;
         mOrderScales.fill(1.0f);
     }
-    mAmbiSplitter[0][0].init(400.0f / frequency);
-    std::fill(mAmbiSplitter[0].begin()+1, mAmbiSplitter[0].end(), mAmbiSplitter[0][0]);
-    std::fill(mAmbiSplitter[1].begin(), mAmbiSplitter[1].end(), mAmbiSplitter[0][0]);
-
-    return AL_TRUE;
+    mPipelines[0].mAmbiSplitter[0][0].init(device->mXOverFreq / frequency);
+    for(auto &pipeline : mPipelines)
+    {
+        std::fill(pipeline.mAmbiSplitter[0].begin(), pipeline.mAmbiSplitter[0].end(),
+            pipeline.mAmbiSplitter[0][0]);
+        std::fill(pipeline.mAmbiSplitter[1].begin(), pipeline.mAmbiSplitter[1].end(),
+            pipeline.mAmbiSplitter[0][0]);
+    }
 }
 
 /**************************************
@@ -635,19 +791,22 @@ ALboolean ReverbState::deviceUpdate(const ALCdevice *device)
 /* Calculate a decay coefficient given the length of each cycle and the time
  * until the decay reaches -60 dB.
  */
-inline ALfloat CalcDecayCoeff(const ALfloat length, const ALfloat decayTime)
-{ return std::pow(REVERB_DECAY_GAIN, length/decayTime); }
+inline float CalcDecayCoeff(const float length, const float decayTime)
+{ return std::pow(ReverbDecayGain, length/decayTime); }
 
 /* Calculate a decay length from a coefficient and the time until the decay
  * reaches -60 dB.
  */
-inline ALfloat CalcDecayLength(const ALfloat coeff, const ALfloat decayTime)
-{ return std::log10(coeff) * decayTime / std::log10(REVERB_DECAY_GAIN); }
+inline float CalcDecayLength(const float coeff, const float decayTime)
+{
+    constexpr float log10_decaygain{-3.0f/*std::log10(ReverbDecayGain)*/};
+    return std::log10(coeff) * decayTime / log10_decaygain;
+}
 
 /* Calculate an attenuation to be applied to the input of any echo models to
  * compensate for modal density and decay time.
  */
-inline ALfloat CalcDensityGain(const ALfloat a)
+inline float CalcDensityGain(const float a)
 {
     /* The energy of a signal can be obtained by finding the area under the
      * squared signal.  This takes the form of Sum(x_n^2), where x is the
@@ -666,11 +825,11 @@ inline ALfloat CalcDensityGain(const ALfloat a)
 }
 
 /* Calculate the scattering matrix coefficients given a diffusion factor. */
-inline ALvoid CalcMatrixCoeffs(const ALfloat diffusion, ALfloat *x, ALfloat *y)
+inline void CalcMatrixCoeffs(const float diffusion, float *x, float *y)
 {
     /* The matrix is of order 4, so n is sqrt(4 - 1). */
-    ALfloat n{std::sqrt(3.0f)};
-    ALfloat t{diffusion * std::atan(n)};
+    constexpr float n{al::numbers::sqrt3_v<float>};
+    const float t{diffusion * std::atan(n)};
 
     /* Calculate the first mixing matrix coefficient. */
     *x = std::cos(t);
@@ -681,19 +840,18 @@ inline ALvoid CalcMatrixCoeffs(const ALfloat diffusion, ALfloat *x, ALfloat *y)
 /* Calculate the limited HF ratio for use with the late reverb low-pass
  * filters.
  */
-ALfloat CalcLimitedHfRatio(const ALfloat hfRatio, const ALfloat airAbsorptionGainHF,
-    const ALfloat decayTime)
+float CalcLimitedHfRatio(const float hfRatio, const float airAbsorptionGainHF,
+    const float decayTime)
 {
     /* Find the attenuation due to air absorption in dB (converting delay
      * time to meters using the speed of sound).  Then reversing the decay
      * equation, solve for HF ratio.  The delay length is cancelled out of
      * the equation, so it can be calculated once for all lines.
      */
-    ALfloat limitRatio{1.0f /
-        (CalcDecayLength(airAbsorptionGainHF, decayTime) * SPEEDOFSOUNDMETRESPERSEC)};
+    float limitRatio{1.0f / SpeedOfSoundMetersPerSec /
+        CalcDecayLength(airAbsorptionGainHF, decayTime)};
 
-    /* Using the limit calculated above, apply the upper bound to the HF ratio.
-     */
+    /* Using the limit calculated above, apply the upper bound to the HF ratio. */
     return minf(limitRatio, hfRatio);
 }
 
@@ -702,60 +860,89 @@ ALfloat CalcLimitedHfRatio(const ALfloat hfRatio, const ALfloat airAbsorptionGai
  * of specified length, using a combination of two shelf filter sections given
  * decay times for each band split at two reference frequencies.
  */
-void T60Filter::calcCoeffs(const ALfloat length, const ALfloat lfDecayTime,
-    const ALfloat mfDecayTime, const ALfloat hfDecayTime, const ALfloat lf0norm,
-    const ALfloat hf0norm)
+void T60Filter::calcCoeffs(const float length, const float lfDecayTime,
+    const float mfDecayTime, const float hfDecayTime, const float lf0norm,
+    const float hf0norm)
 {
-    const ALfloat mfGain{CalcDecayCoeff(length, mfDecayTime)};
-    const ALfloat lfGain{maxf(CalcDecayCoeff(length, lfDecayTime)/mfGain, 0.001f)};
-    const ALfloat hfGain{maxf(CalcDecayCoeff(length, hfDecayTime)/mfGain, 0.001f)};
-
-    MidGain[1] = mfGain;
-    LFFilter.setParams(BiquadType::LowShelf, lfGain, lf0norm,
-        LFFilter.rcpQFromSlope(lfGain, 1.0f));
-    HFFilter.setParams(BiquadType::HighShelf, hfGain, hf0norm,
-        HFFilter.rcpQFromSlope(hfGain, 1.0f));
+    const float mfGain{CalcDecayCoeff(length, mfDecayTime)};
+    const float lfGain{CalcDecayCoeff(length, lfDecayTime) / mfGain};
+    const float hfGain{CalcDecayCoeff(length, hfDecayTime) / mfGain};
+
+    MidGain = mfGain;
+    LFFilter.setParamsFromSlope(BiquadType::LowShelf, lf0norm, lfGain, 1.0f);
+    HFFilter.setParamsFromSlope(BiquadType::HighShelf, hf0norm, hfGain, 1.0f);
 }
 
 /* Update the early reflection line lengths and gain coefficients. */
-void EarlyReflections::updateLines(const ALfloat density, const ALfloat diffusion,
-    const ALfloat decayTime, const ALfloat frequency)
+void EarlyReflections::updateLines(const float density_mult, const float diffusion,
+    const float decayTime, const float frequency)
 {
-    const ALfloat multiplier{CalcDelayLengthMult(density)};
-
     /* Calculate the all-pass feed-back/forward coefficient. */
-    VecAp.Coeff = std::sqrt(0.5f) * std::pow(diffusion, 2.0f);
+    VecAp.Coeff = diffusion*diffusion * InvSqrt2;
 
     for(size_t i{0u};i < NUM_LINES;i++)
     {
-        /* Calculate the length (in seconds) of each all-pass line. */
-        ALfloat length{EARLY_ALLPASS_LENGTHS[i] * multiplier};
+        /* Calculate the delay length of each all-pass line. */
+        float length{EARLY_ALLPASS_LENGTHS[i] * density_mult};
+        VecAp.Offset[i] = float2uint(length * frequency);
 
-        /* Calculate the delay offset for each all-pass line. */
-        VecAp.Offset[i][1] = float2uint(length * frequency);
-
-        /* Calculate the length (in seconds) of each delay line. */
-        length = EARLY_LINE_LENGTHS[i] * multiplier;
-
-        /* Calculate the delay offset for each delay line. */
-        Offset[i][1] = float2uint(length * frequency);
+        /* Calculate the delay length of each delay line. */
+        length = EARLY_LINE_LENGTHS[i] * density_mult;
+        Offset[i] = float2uint(length * frequency);
 
         /* Calculate the gain (coefficient) for each line. */
-        Coeff[i][1] = CalcDecayCoeff(length, decayTime);
+        Coeff[i] = CalcDecayCoeff(length, decayTime);
     }
 }
 
+/* Update the EAX modulation step and depth. Keep in mind that this kind of
+ * vibrato is additive and not multiplicative as one may expect. The downswing
+ * will sound stronger than the upswing.
+ */
+void Modulation::updateModulator(float modTime, float modDepth, float frequency)
+{
+    /* Modulation is calculated in two parts.
+     *
+     * The modulation time effects the sinus rate, altering the speed of
+     * frequency changes. An index is incremented for each sample with an
+     * appropriate step size to generate an LFO, which will vary the feedback
+     * delay over time.
+     */
+    Step = maxu(fastf2u(MOD_FRACONE / (frequency * modTime)), 1);
+
+    /* The modulation depth effects the amount of frequency change over the
+     * range of the sinus. It needs to be scaled by the modulation time so that
+     * a given depth produces a consistent change in frequency over all ranges
+     * of time. Since the depth is applied to a sinus value, it needs to be
+     * halved once for the sinus range and again for the sinus swing in time
+     * (half of it is spent decreasing the frequency, half is spent increasing
+     * it).
+     */
+    if(modTime >= DefaultModulationTime)
+    {
+        /* To cancel the effects of a long period modulation on the late
+         * reverberation, the amount of pitch should be varied (decreased)
+         * according to the modulation time. The natural form is varying
+         * inversely, in fact resulting in an invariant.
+         */
+        Depth = MODULATION_DEPTH_COEFF / 4.0f * DefaultModulationTime * modDepth * frequency;
+    }
+    else
+        Depth = MODULATION_DEPTH_COEFF / 4.0f * modTime * modDepth * frequency;
+}
+
 /* Update the late reverb line lengths and T60 coefficients. */
-void LateReverb::updateLines(const ALfloat density, const ALfloat diffusion,
-    const ALfloat lfDecayTime, const ALfloat mfDecayTime, const ALfloat hfDecayTime,
-    const ALfloat lf0norm, const ALfloat hf0norm, const ALfloat frequency)
+void LateReverb::updateLines(const float density_mult, const float diffusion,
+    const float lfDecayTime, const float mfDecayTime, const float hfDecayTime,
+    const float lf0norm, const float hf0norm, const float frequency)
 {
     /* Scaling factor to convert the normalized reference frequencies from
      * representing 0...freq to 0...max_reference.
      */
-    const ALfloat norm_weight_factor{frequency / AL_EAXREVERB_MAX_HFREFERENCE};
+    constexpr float MaxHFReference{20000.0f};
+    const float norm_weight_factor{frequency / MaxHFReference};
 
-    const ALfloat late_allpass_avg{
+    const float late_allpass_avg{
         std::accumulate(LATE_ALLPASS_LENGTHS.begin(), LATE_ALLPASS_LENGTHS.end(), 0.0f) /
         float{NUM_LINES}};
 
@@ -767,42 +954,42 @@ void LateReverb::updateLines(const ALfloat density, const ALfloat diffusion,
      * The average length of the delay lines is used to calculate the
      * attenuation coefficient.
      */
-    const ALfloat multiplier{CalcDelayLengthMult(density)};
-    ALfloat length{std::accumulate(LATE_LINE_LENGTHS.begin(), LATE_LINE_LENGTHS.end(), 0.0f) /
-        float{NUM_LINES} * multiplier};
-    length += late_allpass_avg * multiplier;
+    float length{std::accumulate(LATE_LINE_LENGTHS.begin(), LATE_LINE_LENGTHS.end(), 0.0f) /
+        float{NUM_LINES} + late_allpass_avg};
+    length *= density_mult;
     /* The density gain calculation uses an average decay time weighted by
      * approximate bandwidth. This attempts to compensate for losses of energy
      * that reduce decay time due to scattering into highly attenuated bands.
      */
-    const ALfloat decayTimeWeighted{
-        (lf0norm*norm_weight_factor)*lfDecayTime +
-        (hf0norm*norm_weight_factor - lf0norm*norm_weight_factor)*mfDecayTime +
+    const float decayTimeWeighted{
+        lf0norm*norm_weight_factor*lfDecayTime +
+        (hf0norm - lf0norm)*norm_weight_factor*mfDecayTime +
         (1.0f - hf0norm*norm_weight_factor)*hfDecayTime};
-    DensityGain[1] = CalcDensityGain(CalcDecayCoeff(length, decayTimeWeighted));
+    DensityGain = CalcDensityGain(CalcDecayCoeff(length, decayTimeWeighted));
 
     /* Calculate the all-pass feed-back/forward coefficient. */
-    VecAp.Coeff = std::sqrt(0.5f) * std::pow(diffusion, 2.0f);
+    VecAp.Coeff = diffusion*diffusion * InvSqrt2;
 
     for(size_t i{0u};i < NUM_LINES;i++)
     {
-        /* Calculate the length (in seconds) of each all-pass line. */
-        length = LATE_ALLPASS_LENGTHS[i] * multiplier;
-
-        /* Calculate the delay offset for each all-pass line. */
-        VecAp.Offset[i][1] = float2uint(length * frequency);
+        /* Calculate the delay length of each all-pass line. */
+        length = LATE_ALLPASS_LENGTHS[i] * density_mult;
+        VecAp.Offset[i] = float2uint(length * frequency);
 
-        /* Calculate the length (in seconds) of each delay line. */
-        length = LATE_LINE_LENGTHS[i] * multiplier;
-
-        /* Calculate the delay offset for each delay line. */
-        Offset[i][1] = float2uint(length*frequency + 0.5f);
+        /* Calculate the delay length of each feedback delay line. A cubic
+         * resampler is used for modulation on the feedback delay, which
+         * includes one sample of delay. Reduce by one to compensate.
+         */
+        length = LATE_LINE_LENGTHS[i] * density_mult;
+        Offset[i] = maxu(float2uint(length*frequency + 0.5f), 1u) - 1u;
 
         /* Approximate the absorption that the vector all-pass would exhibit
          * given the current diffusion so we don't have to process a full T60
-         * filter for each of its four lines.
+         * filter for each of its four lines. Also include the average
+         * modulation delay (depth is half the max delay in samples).
          */
-        length += lerp(LATE_ALLPASS_LENGTHS[i], late_allpass_avg, diffusion) * multiplier;
+        length += lerpf(LATE_ALLPASS_LENGTHS[i], late_allpass_avg, diffusion)*density_mult +
+            Mod.Depth/frequency;
 
         /* Calculate the T60 damping coefficients for each line. */
         T60[i].calcCoeffs(length, lfDecayTime, mfDecayTime, hfDecayTime, lf0norm, hf0norm);
@@ -811,11 +998,9 @@ void LateReverb::updateLines(const ALfloat density, const ALfloat diffusion,
 
 
 /* Update the offsets for the main effect delay line. */
-void ReverbState::updateDelayLine(const ALfloat earlyDelay, const ALfloat lateDelay,
-    const ALfloat density, const ALfloat decayTime, const ALfloat frequency)
+void ReverbPipeline::updateDelayLine(const float earlyDelay, const float lateDelay,
+    const float density_mult, const float decayTime, const float frequency)
 {
-    const ALfloat multiplier{CalcDelayLengthMult(density)};
-
     /* Early reflection taps are decorrelated by means of an average room
      * reflection approximation described above the definition of the taps.
      * This approximation is linear and so the above density multiplier can
@@ -828,15 +1013,13 @@ void ReverbState::updateDelayLine(const ALfloat earlyDelay, const ALfloat lateDe
      */
     for(size_t i{0u};i < NUM_LINES;i++)
     {
-        ALfloat length{earlyDelay + EARLY_TAP_LENGTHS[i]*multiplier};
-        mEarlyDelayTap[i][1] = float2uint(length * frequency);
+        float length{EARLY_TAP_LENGTHS[i]*density_mult};
+        mEarlyDelayTap[i][1] = float2uint((earlyDelay+length) * frequency);
+        mEarlyDelayCoeff[i] = CalcDecayCoeff(length, decayTime);
 
-        length = EARLY_TAP_LENGTHS[i]*multiplier;
-        mEarlyDelayCoeff[i][1] = CalcDecayCoeff(length, decayTime);
-
-        length = (LATE_LINE_LENGTHS[i] - LATE_LINE_LENGTHS.front())/float{NUM_LINES}*multiplier +
+        length = (LATE_LINE_LENGTHS[i] - LATE_LINE_LENGTHS.front())/float{NUM_LINES}*density_mult +
             lateDelay;
-        mLateDelayTap[i][1] = mLateFeedTap + float2uint(length * frequency);
+        mLateDelayTap[i][1] = float2uint(length * frequency);
     }
 }
 
@@ -845,10 +1028,8 @@ void ReverbState::updateDelayLine(const ALfloat earlyDelay, const ALfloat lateDe
  * focal strength. This function results in a B-Format transformation matrix
  * that spatially focuses the signal in the desired direction.
  */
-alu::Matrix GetTransformFromVector(const ALfloat *vec)
+std::array<std::array<float,4>,4> GetTransformFromVector(const float *vec)
 {
-    constexpr float sqrt_3{1.73205080756887719318f};
-
     /* Normalize the panning vector according to the N3D scale, which has an
      * extra sqrt(3) term on the directional components. Converting from OpenAL
      * to B-Format also requires negating X (ACN 1) and Z (ACN 3). Note however
@@ -856,13 +1037,13 @@ alu::Matrix GetTransformFromVector(const ALfloat *vec)
      * rest of OpenAL which use right-handed. This is fixed by negating Z,
      * which cancels out with the B-Format Z negation.
      */
-    ALfloat norm[3];
-    ALfloat mag{std::sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2])};
+    float norm[3];
+    float mag{std::sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2])};
     if(mag > 1.0f)
     {
-        norm[0] = vec[0] / mag * -sqrt_3;
-        norm[1] = vec[1] / mag * sqrt_3;
-        norm[2] = vec[2] / mag * sqrt_3;
+        norm[0] = vec[0] / mag * -al::numbers::sqrt3_v<float>;
+        norm[1] = vec[1] / mag * al::numbers::sqrt3_v<float>;
+        norm[2] = vec[2] / mag * al::numbers::sqrt3_v<float>;
         mag = 1.0f;
     }
     else
@@ -871,131 +1052,201 @@ alu::Matrix GetTransformFromVector(const ALfloat *vec)
          * term. There's no need to renormalize the magnitude since it would
          * just be reapplied in the matrix.
          */
-        norm[0] = vec[0] * -sqrt_3;
-        norm[1] = vec[1] * sqrt_3;
-        norm[2] = vec[2] * sqrt_3;
+        norm[0] = vec[0] * -al::numbers::sqrt3_v<float>;
+        norm[1] = vec[1] * al::numbers::sqrt3_v<float>;
+        norm[2] = vec[2] * al::numbers::sqrt3_v<float>;
     }
 
-    return alu::Matrix{
-        1.0f,   0.0f,    0.0f,   0.0f,
-        norm[0], 1.0f-mag, 0.0f, 0.0f,
-        norm[1], 0.0f, 1.0f-mag, 0.0f,
-        norm[2], 0.0f, 0.0f, 1.0f-mag
-    };
+    return std::array<std::array<float,4>,4>{{
+        {{1.0f,   0.0f,    0.0f,   0.0f}},
+        {{norm[0], 1.0f-mag, 0.0f, 0.0f}},
+        {{norm[1], 0.0f, 1.0f-mag, 0.0f}},
+        {{norm[2], 0.0f, 0.0f, 1.0f-mag}}
+    }};
 }
 
 /* Update the early and late 3D panning gains. */
-void ReverbState::update3DPanning(const ALfloat *ReflectionsPan, const ALfloat *LateReverbPan,
-    const ALfloat earlyGain, const ALfloat lateGain, const EffectTarget &target)
+void ReverbPipeline::update3DPanning(const float *ReflectionsPan, const float *LateReverbPan,
+    const float earlyGain, const float lateGain, const bool doUpmix, const MixParams *mainMix)
 {
     /* Create matrices that transform a B-Format signal according to the
      * panning vectors.
      */
-    const alu::Matrix earlymat{GetTransformFromVector(ReflectionsPan)};
-    const alu::Matrix latemat{GetTransformFromVector(LateReverbPan)};
+    const std::array<std::array<float,4>,4> earlymat{GetTransformFromVector(ReflectionsPan)};
+    const std::array<std::array<float,4>,4> latemat{GetTransformFromVector(LateReverbPan)};
 
-    mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < NUM_LINES;i++)
-    {
-        const ALfloat coeffs[MAX_AMBI_CHANNELS]{earlymat[0][i], earlymat[1][i], earlymat[2][i],
-            earlymat[3][i]};
-        ComputePanGains(target.Main, coeffs, earlyGain, mEarly.PanGain[i]);
-    }
-    for(size_t i{0u};i < NUM_LINES;i++)
+    if(doUpmix)
     {
-        const ALfloat coeffs[MAX_AMBI_CHANNELS]{latemat[0][i], latemat[1][i], latemat[2][i],
-            latemat[3][i]};
-        ComputePanGains(target.Main, coeffs, lateGain, mLate.PanGain[i]);
-    }
-}
+        /* When upsampling, combine the early and late transforms with the
+         * first-order upsample matrix. This results in panning gains that
+         * apply the panning transform to first-order B-Format, which is then
+         * upsampled.
+         */
+        auto mult_matrix = [](const al::span<const std::array<float,4>,4> mtx1)
+        {
+            auto&& mtx2 = AmbiScale::FirstOrderUp;
+            std::array<std::array<float,MaxAmbiChannels>,NUM_LINES> res{};
 
-void ReverbState::update(const ALCcontext *Context, const ALeffectslot *Slot, const EffectProps *props, const EffectTarget target)
-{
-    const ALCdevice *Device{Context->mDevice.get()};
-    const auto frequency = static_cast<ALfloat>(Device->Frequency);
+            for(size_t i{0};i < mtx1[0].size();++i)
+            {
+                float *RESTRICT dst{res[i].data()};
+                for(size_t k{0};k < mtx1.size();++k)
+                {
+                    const float *RESTRICT src{mtx2[k].data()};
+                    const float a{mtx1[k][i]};
+                    for(size_t j{0};j < mtx2[0].size();++j)
+                        dst[j] += a * src[j];
+                }
+            }
 
-    /* Calculate the master filters */
-    ALfloat hf0norm{minf(props->Reverb.HFReference / frequency, 0.49f)};
-    /* Restrict the filter gains from going below -60dB to keep the filter from
-     * killing most of the signal.
-     */
-    ALfloat gainhf{maxf(props->Reverb.GainHF, 0.001f)};
-    mFilter[0].Lp.setParams(BiquadType::HighShelf, gainhf, hf0norm,
-        mFilter[0].Lp.rcpQFromSlope(gainhf, 1.0f));
-    ALfloat lf0norm{minf(props->Reverb.LFReference / frequency, 0.49f)};
-    ALfloat gainlf{maxf(props->Reverb.GainLF, 0.001f)};
-    mFilter[0].Hp.setParams(BiquadType::LowShelf, gainlf, lf0norm,
-        mFilter[0].Hp.rcpQFromSlope(gainlf, 1.0f));
-    for(size_t i{1u};i < NUM_LINES;i++)
-    {
-        mFilter[i].Lp.copyParamsFrom(mFilter[0].Lp);
-        mFilter[i].Hp.copyParamsFrom(mFilter[0].Hp);
+            return res;
+        };
+        auto earlycoeffs = mult_matrix(earlymat);
+        auto latecoeffs = mult_matrix(latemat);
+
+        for(size_t i{0u};i < NUM_LINES;i++)
+            ComputePanGains(mainMix, earlycoeffs[i].data(), earlyGain, mEarly.TargetGains[i]);
+        for(size_t i{0u};i < NUM_LINES;i++)
+            ComputePanGains(mainMix, latecoeffs[i].data(), lateGain, mLate.TargetGains[i]);
     }
+    else
+    {
+        /* When not upsampling, combine the early and late A-to-B-Format
+         * conversions with their respective transform. This results panning
+         * gains that convert A-Format to B-Format, which is then panned.
+         */
+        auto mult_matrix = [](const al::span<const std::array<float,NUM_LINES>,4> mtx1,
+            const al::span<const std::array<float,4>,4> mtx2)
+        {
+            std::array<std::array<float,MaxAmbiChannels>,NUM_LINES> res{};
 
-    /* Update the main effect delay and associated taps. */
-    updateDelayLine(props->Reverb.ReflectionsDelay, props->Reverb.LateReverbDelay,
-                    props->Reverb.Density, props->Reverb.DecayTime, frequency);
+            for(size_t i{0};i < mtx1[0].size();++i)
+            {
+                float *RESTRICT dst{res[i].data()};
+                for(size_t k{0};k < mtx1.size();++k)
+                {
+                    const float a{mtx1[k][i]};
+                    for(size_t j{0};j < mtx2.size();++j)
+                        dst[j] += a * mtx2[j][k];
+                }
+            }
 
-    /* Update the early lines. */
-    mEarly.updateLines(props->Reverb.Density, props->Reverb.Diffusion, props->Reverb.DecayTime,
-        frequency);
+            return res;
+        };
+        auto earlycoeffs = mult_matrix(EarlyA2B, earlymat);
+        auto latecoeffs = mult_matrix(LateA2B, latemat);
 
-    /* Get the mixing matrix coefficients. */
-    CalcMatrixCoeffs(props->Reverb.Diffusion, &mMixX, &mMixY);
+        for(size_t i{0u};i < NUM_LINES;i++)
+            ComputePanGains(mainMix, earlycoeffs[i].data(), earlyGain, mEarly.TargetGains[i]);
+        for(size_t i{0u};i < NUM_LINES;i++)
+            ComputePanGains(mainMix, latecoeffs[i].data(), lateGain, mLate.TargetGains[i]);
+    }
+}
+
+void ReverbState::update(const ContextBase *Context, const EffectSlot *Slot,
+    const EffectProps *props, const EffectTarget target)
+{
+    const DeviceBase *Device{Context->mDevice};
+    const auto frequency = static_cast<float>(Device->Frequency);
 
     /* If the HF limit parameter is flagged, calculate an appropriate limit
      * based on the air absorption parameter.
      */
-    ALfloat hfRatio{props->Reverb.DecayHFRatio};
+    float hfRatio{props->Reverb.DecayHFRatio};
     if(props->Reverb.DecayHFLimit && props->Reverb.AirAbsorptionGainHF < 1.0f)
         hfRatio = CalcLimitedHfRatio(hfRatio, props->Reverb.AirAbsorptionGainHF,
             props->Reverb.DecayTime);
 
     /* Calculate the LF/HF decay times. */
-    const ALfloat lfDecayTime{clampf(props->Reverb.DecayTime * props->Reverb.DecayLFRatio,
-        AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME)};
-    const ALfloat hfDecayTime{clampf(props->Reverb.DecayTime * hfRatio,
-        AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME)};
-
-    /* Update the late lines. */
-    mLate.updateLines(props->Reverb.Density, props->Reverb.Diffusion, lfDecayTime,
-        props->Reverb.DecayTime, hfDecayTime, lf0norm, hf0norm, frequency);
-
-    /* Update early and late 3D panning. */
-    const ALfloat gain{props->Reverb.Gain * Slot->Params.Gain * ReverbBoost};
-    update3DPanning(props->Reverb.ReflectionsPan, props->Reverb.LateReverbPan,
-        props->Reverb.ReflectionsGain*gain, props->Reverb.LateReverbGain*gain, target);
-
-    /* Calculate the max update size from the smallest relevant delay. */
-    mMaxUpdate[1] = minz(MAX_UPDATE_SAMPLES, minz(mEarly.Offset[0][1], mLate.Offset[0][1]));
-
-    /* Determine if delay-line cross-fading is required. Density is essentially
-     * a master control for the feedback delays, so changes the offsets of many
-     * delay lines.
-     */
-    mDoFading |= (mParams.Density != props->Reverb.Density ||
+    constexpr float MinDecayTime{0.1f}, MaxDecayTime{20.0f};
+    const float lfDecayTime{clampf(props->Reverb.DecayTime*props->Reverb.DecayLFRatio,
+        MinDecayTime, MaxDecayTime)};
+    const float hfDecayTime{clampf(props->Reverb.DecayTime*hfRatio, MinDecayTime, MaxDecayTime)};
+
+    /* Determine if a full update is required. */
+    const bool fullUpdate{mPipelineState == DeviceClear ||
+        /* Density is essentially a master control for the feedback delays, so
+         * changes the offsets of many delay lines.
+         */
+        mParams.Density != props->Reverb.Density ||
         /* Diffusion and decay times influences the decay rate (gain) of the
          * late reverb T60 filter.
          */
-       mParams.Diffusion != props->Reverb.Diffusion ||
-       mParams.DecayTime != props->Reverb.DecayTime ||
-       mParams.HFDecayTime != hfDecayTime ||
-       mParams.LFDecayTime != lfDecayTime ||
-       /* HF/LF References control the weighting used to calculate the density
-        * gain.
-        */
-       mParams.HFReference != props->Reverb.HFReference ||
-       mParams.LFReference != props->Reverb.LFReference);
-    if(mDoFading)
+        mParams.Diffusion != props->Reverb.Diffusion ||
+        mParams.DecayTime != props->Reverb.DecayTime ||
+        mParams.HFDecayTime != hfDecayTime ||
+        mParams.LFDecayTime != lfDecayTime ||
+        /* Modulation time and depth both require fading the modulation delay. */
+        mParams.ModulationTime != props->Reverb.ModulationTime ||
+        mParams.ModulationDepth != props->Reverb.ModulationDepth ||
+        /* HF/LF References control the weighting used to calculate the density
+         * gain.
+         */
+        mParams.HFReference != props->Reverb.HFReference ||
+        mParams.LFReference != props->Reverb.LFReference};
+    if(fullUpdate)
     {
         mParams.Density = props->Reverb.Density;
         mParams.Diffusion = props->Reverb.Diffusion;
         mParams.DecayTime = props->Reverb.DecayTime;
         mParams.HFDecayTime = hfDecayTime;
         mParams.LFDecayTime = lfDecayTime;
+        mParams.ModulationTime = props->Reverb.ModulationTime;
+        mParams.ModulationDepth = props->Reverb.ModulationDepth;
         mParams.HFReference = props->Reverb.HFReference;
         mParams.LFReference = props->Reverb.LFReference;
+
+        mPipelineState = (mPipelineState != DeviceClear) ? StartFade : Normal;
+        mCurrentPipeline ^= 1;
+    }
+    auto &pipeline = mPipelines[mCurrentPipeline];
+
+    /* Update early and late 3D panning. */
+    mOutTarget = target.Main->Buffer;
+    const float gain{props->Reverb.Gain * Slot->Gain * ReverbBoost};
+    pipeline.update3DPanning(props->Reverb.ReflectionsPan, props->Reverb.LateReverbPan,
+        props->Reverb.ReflectionsGain*gain, props->Reverb.LateReverbGain*gain, mUpmixOutput,
+        target.Main);
+
+    /* Calculate the master filters */
+    float hf0norm{minf(props->Reverb.HFReference/frequency, 0.49f)};
+    pipeline.mFilter[0].Lp.setParamsFromSlope(BiquadType::HighShelf, hf0norm, props->Reverb.GainHF, 1.0f);
+    float lf0norm{minf(props->Reverb.LFReference/frequency, 0.49f)};
+    pipeline.mFilter[0].Hp.setParamsFromSlope(BiquadType::LowShelf, lf0norm, props->Reverb.GainLF, 1.0f);
+    for(size_t i{1u};i < NUM_LINES;i++)
+    {
+        pipeline.mFilter[i].Lp.copyParamsFrom(pipeline.mFilter[0].Lp);
+        pipeline.mFilter[i].Hp.copyParamsFrom(pipeline.mFilter[0].Hp);
     }
+
+    /* The density-based room size (delay length) multiplier. */
+    const float density_mult{CalcDelayLengthMult(props->Reverb.Density)};
+
+    /* Update the main effect delay and associated taps. */
+    pipeline.updateDelayLine(props->Reverb.ReflectionsDelay, props->Reverb.LateReverbDelay,
+        density_mult, props->Reverb.DecayTime, frequency);
+
+    if(fullUpdate)
+    {
+        /* Update the early lines. */
+        pipeline.mEarly.updateLines(density_mult, props->Reverb.Diffusion, props->Reverb.DecayTime,
+            frequency);
+
+        /* Get the mixing matrix coefficients. */
+        CalcMatrixCoeffs(props->Reverb.Diffusion, &pipeline.mMixX, &pipeline.mMixY);
+
+        /* Update the modulator rate and depth. */
+        pipeline.mLate.Mod.updateModulator(props->Reverb.ModulationTime,
+            props->Reverb.ModulationDepth, frequency);
+
+        /* Update the late lines. */
+        pipeline.mLate.updateLines(density_mult, props->Reverb.Diffusion, lfDecayTime,
+            props->Reverb.DecayTime, hfDecayTime, lf0norm, hf0norm, frequency);
+    }
+
+    const float decaySamples{(props->Reverb.ReflectionsDelay + props->Reverb.LateReverbDelay
+        + props->Reverb.DecayTime) * frequency};
+    pipeline.mFadeSampleCount = static_cast<size_t>(minf(decaySamples, 1'000'000.0f));
 }
 
 
@@ -1042,19 +1293,19 @@ void ReverbState::update(const ALCcontext *Context, const ALeffectslot *Slot, co
  * whose combination of signs are being iterated.
  */
 inline auto VectorPartialScatter(const std::array<float,NUM_LINES> &RESTRICT in,
-    const ALfloat xCoeff, const ALfloat yCoeff) -> std::array<float,NUM_LINES>
+    const float xCoeff, const float yCoeff) -> std::array<float,NUM_LINES>
 {
-    std::array<float,NUM_LINES> out;
-    out[0] = xCoeff*in[0] + yCoeff*(          in[1] + -in[2] + in[3]);
-    out[1] = xCoeff*in[1] + yCoeff*(-in[0]          +  in[2] + in[3]);
-    out[2] = xCoeff*in[2] + yCoeff*( in[0] + -in[1]          + in[3]);
-    out[3] = xCoeff*in[3] + yCoeff*(-in[0] + -in[1] + -in[2]        );
-    return out;
+    return std::array<float,NUM_LINES>{{
+        xCoeff*in[0] + yCoeff*(          in[1] + -in[2] + in[3]),
+        xCoeff*in[1] + yCoeff*(-in[0]          +  in[2] + in[3]),
+        xCoeff*in[2] + yCoeff*( in[0] + -in[1]          + in[3]),
+        xCoeff*in[3] + yCoeff*(-in[0] + -in[1] + -in[2]        )
+    }};
 }
 
 /* Utilizes the above, but reverses the input channels. */
-void VectorScatterRevDelayIn(const DelayLineI delay, size_t offset, const ALfloat xCoeff,
-    const ALfloat yCoeff, const al::span<const ReverbUpdateLine,NUM_LINES> in, const size_t count)
+void VectorScatterRevDelayIn(const DelayLineI delay, size_t offset, const float xCoeff,
+    const float yCoeff, const al::span<const ReverbUpdateLine,NUM_LINES> in, const size_t count)
 {
     ASSUME(count > 0);
 
@@ -1083,17 +1334,17 @@ void VectorScatterRevDelayIn(const DelayLineI delay, size_t offset, const ALfloa
  * Two static specializations are used for transitional (cross-faded) delay
  * line processing and non-transitional processing.
  */
-void VecAllpass::processUnfaded(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
-    const ALfloat xCoeff, const ALfloat yCoeff, const size_t todo)
+void VecAllpass::process(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
+    const float xCoeff, const float yCoeff, const size_t todo)
 {
     const DelayLineI delay{Delay};
-    const ALfloat feedCoeff{Coeff};
+    const float feedCoeff{Coeff};
 
     ASSUME(todo > 0);
 
     size_t vap_offset[NUM_LINES];
     for(size_t j{0u};j < NUM_LINES;j++)
-        vap_offset[j] = offset - Offset[j][0];
+        vap_offset[j] = offset - Offset[j];
     for(size_t i{0u};i < todo;)
     {
         for(size_t j{0u};j < NUM_LINES;j++)
@@ -1109,60 +1360,8 @@ void VecAllpass::processUnfaded(const al::span<ReverbUpdateLine,NUM_LINES> sampl
             std::array<float,NUM_LINES> f;
             for(size_t j{0u};j < NUM_LINES;j++)
             {
-                const ALfloat input{samples[j][i]};
-                const ALfloat out{delay.Line[vap_offset[j]++][j] - feedCoeff*input};
-                f[j] = input + feedCoeff*out;
-
-                samples[j][i] = out;
-            }
-            ++i;
-
-            delay.Line[offset++] = VectorPartialScatter(f, xCoeff, yCoeff);
-        } while(--td);
-    }
-}
-void VecAllpass::processFaded(const al::span<ReverbUpdateLine,NUM_LINES> samples, size_t offset,
-    const ALfloat xCoeff, const ALfloat yCoeff, ALfloat fadeCount, const ALfloat fadeStep,
-    const size_t todo)
-{
-    const DelayLineI delay{Delay};
-    const ALfloat feedCoeff{Coeff};
-
-    ASSUME(todo > 0);
-
-    size_t vap_offset[NUM_LINES][2];
-    for(size_t j{0u};j < NUM_LINES;j++)
-    {
-        vap_offset[j][0] = offset - Offset[j][0];
-        vap_offset[j][1] = offset - Offset[j][1];
-    }
-    for(size_t i{0u};i < todo;)
-    {
-        for(size_t j{0u};j < NUM_LINES;j++)
-        {
-            vap_offset[j][0] &= delay.Mask;
-            vap_offset[j][1] &= delay.Mask;
-        }
-        offset &= delay.Mask;
-
-        size_t maxoff{offset};
-        for(size_t j{0u};j < NUM_LINES;j++)
-            maxoff = maxz(maxoff, maxz(vap_offset[j][0], vap_offset[j][1]));
-        size_t td{minz(delay.Mask+1 - maxoff, todo - i)};
-
-        do {
-            fadeCount += 1.0f;
-            const float fade{fadeCount * fadeStep};
-
-            std::array<float,NUM_LINES> f;
-            for(size_t j{0u};j < NUM_LINES;j++)
-                f[j] = delay.Line[vap_offset[j][0]++][j]*(1.0f-fade) +
-                    delay.Line[vap_offset[j][1]++][j]*fade;
-
-            for(size_t j{0u};j < NUM_LINES;j++)
-            {
-                const ALfloat input{samples[j][i]};
-                const ALfloat out{f[j] - feedCoeff*input};
+                const float input{samples[j][i]};
+                const float out{delay.Line[vap_offset[j]++][j] - feedCoeff*input};
                 f[j] = input + feedCoeff*out;
 
                 samples[j][i] = out;
@@ -1189,892 +1388,373 @@ void VecAllpass::processFaded(const al::span<ReverbUpdateLine,NUM_LINES> samples
  *
  * Finally, the early response is reversed, scattered (based on diffusion),
  * and fed into the late reverb section of the main delay line.
- *
- * Two static specializations are used for transitional (cross-faded) delay
- * line processing and non-transitional processing.
  */
-void ReverbState::earlyUnfaded(const size_t offset, const size_t todo)
+void ReverbPipeline::processEarly(size_t offset, const size_t samplesToDo,
+    const al::span<ReverbUpdateLine, NUM_LINES> tempSamples,
+    const al::span<FloatBufferLine, NUM_LINES> outSamples)
 {
     const DelayLineI early_delay{mEarly.Delay};
-    const DelayLineI main_delay{mDelay};
-    const ALfloat mixX{mMixX};
-    const ALfloat mixY{mMixY};
-
-    ASSUME(todo > 0);
+    const DelayLineI in_delay{mEarlyDelayIn};
+    const float mixX{mMixX};
+    const float mixY{mMixY};
 
-    /* First, load decorrelated samples from the main delay line as the primary
-     * reflections.
-     */
-    for(size_t j{0u};j < NUM_LINES;j++)
-    {
-        size_t early_delay_tap{offset - mEarlyDelayTap[j][0]};
-        const ALfloat coeff{mEarlyDelayCoeff[j][0]};
-        for(size_t i{0u};i < todo;)
-        {
-            early_delay_tap &= main_delay.Mask;
-            size_t td{minz(main_delay.Mask+1 - early_delay_tap, todo - i)};
-            do {
-                mTempSamples[j][i++] = main_delay.Line[early_delay_tap++][j] * coeff;
-            } while(--td);
-        }
-    }
-
-    /* Apply a vector all-pass, to help color the initial reflections based on
-     * the diffusion strength.
-     */
-    mEarly.VecAp.processUnfaded(mTempSamples, offset, mixX, mixY, todo);
+    ASSUME(samplesToDo > 0);
 
-    /* Apply a delay and bounce to generate secondary reflections, combine with
-     * the primary reflections and write out the result for mixing.
-     */
-    for(size_t j{0u};j < NUM_LINES;j++)
+    for(size_t base{0};base < samplesToDo;)
     {
-        size_t feedb_tap{offset - mEarly.Offset[j][0]};
-        const ALfloat feedb_coeff{mEarly.Coeff[j][0]};
-        float *out = mEarlySamples[j].data();
+        const size_t todo{minz(samplesToDo-base, MAX_UPDATE_SAMPLES)};
 
-        for(size_t i{0u};i < todo;)
+        /* First, load decorrelated samples from the main delay line as the
+         * primary reflections.
+         */
+        const float fadeStep{1.0f / static_cast<float>(todo)};
+        for(size_t j{0u};j < NUM_LINES;j++)
         {
-            feedb_tap &= early_delay.Mask;
-            size_t td{minz(early_delay.Mask+1 - feedb_tap, todo - i)};
-            do {
-                out[i] = mTempSamples[j][i] + early_delay.Line[feedb_tap++][j]*feedb_coeff;
-                ++i;
-            } while(--td);
-        }
-    }
-    for(size_t j{0u};j < NUM_LINES;j++)
-        early_delay.write(offset, NUM_LINES-1-j, mTempSamples[j].data(), todo);
+            size_t early_delay_tap0{offset - mEarlyDelayTap[j][0]};
+            size_t early_delay_tap1{offset - mEarlyDelayTap[j][1]};
+            const float coeff{mEarlyDelayCoeff[j]};
+            const float coeffStep{early_delay_tap0 != early_delay_tap1 ? coeff*fadeStep : 0.0f};
+            float fadeCount{0.0f};
 
-    /* Also write the result back to the main delay line for the late reverb
-     * stage to pick up at the appropriate time, appplying a scatter and
-     * bounce to improve the initial diffusion in the late reverb.
-     */
-    const size_t late_feed_tap{offset - mLateFeedTap};
-    VectorScatterRevDelayIn(main_delay, late_feed_tap, mixX, mixY, mEarlySamples, todo);
-}
-void ReverbState::earlyFaded(const size_t offset, const size_t todo, const ALfloat fade,
-    const ALfloat fadeStep)
-{
-    const DelayLineI early_delay{mEarly.Delay};
-    const DelayLineI main_delay{mDelay};
-    const ALfloat mixX{mMixX};
-    const ALfloat mixY{mMixY};
-
-    ASSUME(todo > 0);
+            for(size_t i{0u};i < todo;)
+            {
+                early_delay_tap0 &= in_delay.Mask;
+                early_delay_tap1 &= in_delay.Mask;
+                const size_t max_tap{maxz(early_delay_tap0, early_delay_tap1)};
+                size_t td{minz(in_delay.Mask+1 - max_tap, todo-i)};
+                do {
+                    const float fade0{coeff - coeffStep*fadeCount};
+                    const float fade1{coeffStep*fadeCount};
+                    fadeCount += 1.0f;
+                    tempSamples[j][i++] = in_delay.Line[early_delay_tap0++][j]*fade0 +
+                        in_delay.Line[early_delay_tap1++][j]*fade1;
+                } while(--td);
+            }
 
-    for(size_t j{0u};j < NUM_LINES;j++)
-    {
-        size_t early_delay_tap0{offset - mEarlyDelayTap[j][0]};
-        size_t early_delay_tap1{offset - mEarlyDelayTap[j][1]};
-        const ALfloat oldCoeff{mEarlyDelayCoeff[j][0]};
-        const ALfloat oldCoeffStep{-oldCoeff * fadeStep};
-        const ALfloat newCoeffStep{mEarlyDelayCoeff[j][1] * fadeStep};
-        ALfloat fadeCount{fade};
-
-        for(size_t i{0u};i < todo;)
-        {
-            early_delay_tap0 &= main_delay.Mask;
-            early_delay_tap1 &= main_delay.Mask;
-            size_t td{minz(main_delay.Mask+1 - maxz(early_delay_tap0, early_delay_tap1), todo-i)};
-            do {
-                fadeCount += 1.0f;
-                const ALfloat fade0{oldCoeff + oldCoeffStep*fadeCount};
-                const ALfloat fade1{newCoeffStep*fadeCount};
-                mTempSamples[j][i++] =
-                    main_delay.Line[early_delay_tap0++][j]*fade0 +
-                    main_delay.Line[early_delay_tap1++][j]*fade1;
-            } while(--td);
+            mEarlyDelayTap[j][0] = mEarlyDelayTap[j][1];
         }
-    }
 
-    mEarly.VecAp.processFaded(mTempSamples, offset, mixX, mixY, fade, fadeStep, todo);
+        /* Apply a vector all-pass, to help color the initial reflections based
+         * on the diffusion strength.
+         */
+        mEarly.VecAp.process(tempSamples, offset, mixX, mixY, todo);
 
-    for(size_t j{0u};j < NUM_LINES;j++)
-    {
-        size_t feedb_tap0{offset - mEarly.Offset[j][0]};
-        size_t feedb_tap1{offset - mEarly.Offset[j][1]};
-        const ALfloat feedb_oldCoeff{mEarly.Coeff[j][0]};
-        const ALfloat feedb_oldCoeffStep{-feedb_oldCoeff * fadeStep};
-        const ALfloat feedb_newCoeffStep{mEarly.Coeff[j][1] * fadeStep};
-        float *out = mEarlySamples[j].data();
-        ALfloat fadeCount{fade};
-
-        for(size_t i{0u};i < todo;)
+        /* Apply a delay and bounce to generate secondary reflections, combine
+         * with the primary reflections and write out the result for mixing.
+         */
+        for(size_t j{0u};j < NUM_LINES;j++)
+            early_delay.write(offset, NUM_LINES-1-j, tempSamples[j].data(), todo);
+        for(size_t j{0u};j < NUM_LINES;j++)
         {
-            feedb_tap0 &= early_delay.Mask;
-            feedb_tap1 &= early_delay.Mask;
-            size_t td{minz(early_delay.Mask+1 - maxz(feedb_tap0, feedb_tap1), todo - i)};
+            size_t feedb_tap{offset - mEarly.Offset[j]};
+            const float feedb_coeff{mEarly.Coeff[j]};
+            float *RESTRICT out{al::assume_aligned<16>(outSamples[j].data() + base)};
 
-            do {
-                fadeCount += 1.0f;
-                const ALfloat fade0{feedb_oldCoeff + feedb_oldCoeffStep*fadeCount};
-                const ALfloat fade1{feedb_newCoeffStep*fadeCount};
-                out[i] = mTempSamples[j][i] +
-                    early_delay.Line[feedb_tap0++][j]*fade0 +
-                    early_delay.Line[feedb_tap1++][j]*fade1;
-                ++i;
-            } while(--td);
+            for(size_t i{0u};i < todo;)
+            {
+                feedb_tap &= early_delay.Mask;
+                size_t td{minz(early_delay.Mask+1 - feedb_tap, todo - i)};
+                do {
+                    tempSamples[j][i] += early_delay.Line[feedb_tap++][j]*feedb_coeff;
+                    out[i] = tempSamples[j][i];
+                    ++i;
+                } while(--td);
+            }
         }
+
+        /* Finally, write the result to the late delay line input for the late
+         * reverb stage to pick up at the appropriate time, applying a scatter
+         * and bounce to improve the initial diffusion in the late reverb.
+         */
+        VectorScatterRevDelayIn(mLateDelayIn, offset, mixX, mixY, tempSamples, todo);
+
+        base += todo;
+        offset += todo;
     }
-    for(size_t j{0u};j < NUM_LINES;j++)
-        early_delay.write(offset, NUM_LINES-1-j, mTempSamples[j].data(), todo);
+}
 
-    const size_t late_feed_tap{offset - mLateFeedTap};
-    VectorScatterRevDelayIn(main_delay, late_feed_tap, mixX, mixY, mEarlySamples, todo);
+void Modulation::calcDelays(size_t todo)
+{
+    constexpr float mod_scale{al::numbers::pi_v<float> * 2.0f / MOD_FRACONE};
+    uint idx{Index};
+    const uint step{Step};
+    const float depth{Depth};
+    for(size_t i{0};i < todo;++i)
+    {
+        idx += step;
+        const float lfo{std::sin(static_cast<float>(idx&MOD_FRACMASK) * mod_scale)};
+        ModDelays[i] = (lfo+1.0f) * depth;
+    }
+    Index = idx;
 }
 
+
 /* This generates the reverb tail using a modified feed-back delay network
  * (FDN).
  *
- * Results from the early reflections are mixed with the output from the late
- * delay lines.
+ * Results from the early reflections are mixed with the output from the
+ * modulated late delay lines.
  *
  * The late response is then completed by T60 and all-pass filtering the mix.
  *
  * Finally, the lines are reversed (so they feed their opposite directions)
  * and scattered with the FDN matrix before re-feeding the delay lines.
- *
- * Two variations are made, one for for transitional (cross-faded) delay line
- * processing and one for non-transitional processing.
  */
-void ReverbState::lateUnfaded(const size_t offset, const size_t todo)
+void ReverbPipeline::processLate(size_t offset, const size_t samplesToDo,
+    const al::span<ReverbUpdateLine, NUM_LINES> tempSamples,
+    const al::span<FloatBufferLine, NUM_LINES> outSamples)
 {
     const DelayLineI late_delay{mLate.Delay};
-    const DelayLineI main_delay{mDelay};
-    const ALfloat mixX{mMixX};
-    const ALfloat mixY{mMixY};
+    const DelayLineI in_delay{mLateDelayIn};
+    const float mixX{mMixX};
+    const float mixY{mMixY};
 
-    ASSUME(todo > 0);
+    ASSUME(samplesToDo > 0);
 
-    /* First, load decorrelated samples from the main and feedback delay lines.
-     * Filter the signal to apply its frequency-dependent decay.
-     */
-    for(size_t j{0u};j < NUM_LINES;j++)
+    for(size_t base{0};base < samplesToDo;)
     {
-        size_t late_delay_tap{offset - mLateDelayTap[j][0]};
-        size_t late_feedb_tap{offset - mLate.Offset[j][0]};
-        const ALfloat midGain{mLate.T60[j].MidGain[0]};
-        const ALfloat densityGain{mLate.DensityGain[0] * midGain};
-        for(size_t i{0u};i < todo;)
-        {
-            late_delay_tap &= main_delay.Mask;
-            late_feedb_tap &= late_delay.Mask;
-            size_t td{minz(todo - i,
-                minz(main_delay.Mask+1 - late_delay_tap, late_delay.Mask+1 - late_feedb_tap))};
-            do {
-                mTempSamples[j][i++] =
-                    main_delay.Line[late_delay_tap++][j]*densityGain +
-                    late_delay.Line[late_feedb_tap++][j]*midGain;
-            } while(--td);
-        }
-        mLate.T60[j].process(mTempSamples[j].data(), todo);
-    }
-
-    /* Apply a vector all-pass to improve micro-surface diffusion, and write
-     * out the results for mixing.
-     */
-    mLate.VecAp.processUnfaded(mTempSamples, offset, mixX, mixY, todo);
-    for(size_t j{0u};j < NUM_LINES;j++)
-        std::copy_n(mTempSamples[j].begin(), todo, mLateSamples[j].begin());
-
-    /* Finally, scatter and bounce the results to refeed the feedback buffer. */
-    VectorScatterRevDelayIn(late_delay, offset, mixX, mixY, mTempSamples, todo);
-}
-void ReverbState::lateFaded(const size_t offset, const size_t todo, const ALfloat fade,
-    const ALfloat fadeStep)
-{
-    const DelayLineI late_delay{mLate.Delay};
-    const DelayLineI main_delay{mDelay};
-    const ALfloat mixX{mMixX};
-    const ALfloat mixY{mMixY};
+        const size_t todo{minz(samplesToDo-base, minz(mLate.Offset[0], MAX_UPDATE_SAMPLES))};
+        ASSUME(todo > 0);
 
-    ASSUME(todo > 0);
+        /* First, calculate the modulated delays for the late feedback. */
+        mLate.Mod.calcDelays(todo);
 
-    for(size_t j{0u};j < NUM_LINES;j++)
-    {
-        const ALfloat oldMidGain{mLate.T60[j].MidGain[0]};
-        const ALfloat midGain{mLate.T60[j].MidGain[1]};
-        const ALfloat oldMidStep{-oldMidGain * fadeStep};
-        const ALfloat midStep{midGain * fadeStep};
-        const ALfloat oldDensityGain{mLate.DensityGain[0] * oldMidGain};
-        const ALfloat densityGain{mLate.DensityGain[1] * midGain};
-        const ALfloat oldDensityStep{-oldDensityGain * fadeStep};
-        const ALfloat densityStep{densityGain * fadeStep};
-        size_t late_delay_tap0{offset - mLateDelayTap[j][0]};
-        size_t late_delay_tap1{offset - mLateDelayTap[j][1]};
-        size_t late_feedb_tap0{offset - mLate.Offset[j][0]};
-        size_t late_feedb_tap1{offset - mLate.Offset[j][1]};
-        ALfloat fadeCount{fade};
-
-        for(size_t i{0u};i < todo;)
+        /* Next, load decorrelated samples from the main and feedback delay
+         * lines. Filter the signal to apply its frequency-dependent decay.
+         */
+        const float fadeStep{1.0f / static_cast<float>(todo)};
+        for(size_t j{0u};j < NUM_LINES;j++)
         {
-            late_delay_tap0 &= main_delay.Mask;
-            late_delay_tap1 &= main_delay.Mask;
-            late_feedb_tap0 &= late_delay.Mask;
-            late_feedb_tap1 &= late_delay.Mask;
-            size_t td{minz(todo - i,
-                minz(main_delay.Mask+1 - maxz(late_delay_tap0, late_delay_tap1),
-                    late_delay.Mask+1 - maxz(late_feedb_tap0, late_feedb_tap1)))};
-            do {
-                fadeCount += 1.0f;
-                const ALfloat fade0{oldDensityGain + oldDensityStep*fadeCount};
-                const ALfloat fade1{densityStep*fadeCount};
-                const ALfloat gfade0{oldMidGain + oldMidStep*fadeCount};
-                const ALfloat gfade1{midStep*fadeCount};
-                mTempSamples[j][i++] =
-                    main_delay.Line[late_delay_tap0++][j]*fade0 +
-                    main_delay.Line[late_delay_tap1++][j]*fade1 +
-                    late_delay.Line[late_feedb_tap0++][j]*gfade0 +
-                    late_delay.Line[late_feedb_tap1++][j]*gfade1;
-            } while(--td);
+            size_t late_delay_tap0{offset - mLateDelayTap[j][0]};
+            size_t late_delay_tap1{offset - mLateDelayTap[j][1]};
+            size_t late_feedb_tap{offset - mLate.Offset[j]};
+            const float midGain{mLate.T60[j].MidGain};
+            const float densityGain{mLate.DensityGain * midGain};
+            const float densityStep{late_delay_tap0 != late_delay_tap1 ?
+                densityGain*fadeStep : 0.0f};
+            float fadeCount{0.0f};
+
+            for(size_t i{0u};i < todo;)
+            {
+                late_delay_tap0 &= in_delay.Mask;
+                late_delay_tap1 &= in_delay.Mask;
+                size_t td{minz(todo-i, in_delay.Mask+1 - maxz(late_delay_tap0, late_delay_tap1))};
+                do {
+                    /* Calculate the read offset and offset between it and the
+                     * next sample.
+                     */
+                    const float fdelay{mLate.Mod.ModDelays[i]};
+                    const size_t idelay{float2uint(fdelay * float{gCubicTable.sTableSteps})};
+                    const size_t delay{late_feedb_tap - (idelay>>gCubicTable.sTableBits)};
+                    const size_t delayoffset{idelay & gCubicTable.sTableMask};
+                    ++late_feedb_tap;
+
+                    /* Get the samples around by the delayed offset. */
+                    const float out0{late_delay.Line[(delay  ) & late_delay.Mask][j]};
+                    const float out1{late_delay.Line[(delay-1) & late_delay.Mask][j]};
+                    const float out2{late_delay.Line[(delay-2) & late_delay.Mask][j]};
+                    const float out3{late_delay.Line[(delay-3) & late_delay.Mask][j]};
+
+                    /* The output is obtained by interpolating the four samples
+                     * that were acquired above, and combined with the main
+                     * delay tap.
+                     */
+                    const float out{out0*gCubicTable.getCoeff0(delayoffset)
+                        + out1*gCubicTable.getCoeff1(delayoffset)
+                        + out2*gCubicTable.getCoeff2(delayoffset)
+                        + out3*gCubicTable.getCoeff3(delayoffset)};
+                    const float fade0{densityGain - densityStep*fadeCount};
+                    const float fade1{densityStep*fadeCount};
+                    fadeCount += 1.0f;
+                    tempSamples[j][i] = out*midGain +
+                        in_delay.Line[late_delay_tap0++][j]*fade0 +
+                        in_delay.Line[late_delay_tap1++][j]*fade1;
+                    ++i;
+                } while(--td);
+            }
+            mLateDelayTap[j][0] = mLateDelayTap[j][1];
+
+            mLate.T60[j].process({tempSamples[j].data(), todo});
         }
-        mLate.T60[j].process(mTempSamples[j].data(), todo);
-    }
 
-    mLate.VecAp.processFaded(mTempSamples, offset, mixX, mixY, fade, fadeStep, todo);
-    for(size_t j{0u};j < NUM_LINES;j++)
-        std::copy_n(mTempSamples[j].begin(), todo, mLateSamples[j].begin());
+        /* Apply a vector all-pass to improve micro-surface diffusion, and
+         * write out the results for mixing.
+         */
+        mLate.VecAp.process(tempSamples, offset, mixX, mixY, todo);
+        for(size_t j{0u};j < NUM_LINES;j++)
+            std::copy_n(tempSamples[j].begin(), todo, outSamples[j].begin()+base);
+
+        /* Finally, scatter and bounce the results to refeed the feedback buffer. */
+        VectorScatterRevDelayIn(late_delay, offset, mixX, mixY, tempSamples, todo);
 
-    VectorScatterRevDelayIn(late_delay, offset, mixX, mixY, mTempSamples, todo);
+        base += todo;
+        offset += todo;
+    }
 }
 
 void ReverbState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
 {
-    size_t offset{mOffset};
+    const size_t offset{mOffset};
 
     ASSUME(samplesToDo > 0);
 
-    /* Convert B-Format to A-Format for processing. */
-    const size_t numInput{samplesIn.size()};
-    const al::span<float> tmpspan{mTempLine.data(), samplesToDo};
-    for(size_t c{0u};c < NUM_LINES;c++)
-    {
-        std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
-        MixRowSamples(tmpspan, {B2A[c], numInput}, samplesIn[0].data(), samplesIn[0].size());
+    auto &oldpipeline = mPipelines[mCurrentPipeline^1];
+    auto &pipeline = mPipelines[mCurrentPipeline];
 
-        /* Band-pass the incoming samples and feed the initial delay line. */
-        mFilter[c].Lp.process(mTempLine.data(), mTempLine.data(), samplesToDo);
-        mFilter[c].Hp.process(mTempLine.data(), mTempLine.data(), samplesToDo);
-        mDelay.write(offset, c, mTempLine.data(), samplesToDo);
-    }
-
-    /* Process reverb for these samples. */
-    if LIKELY(!mDoFading)
+    if(mPipelineState >= Fading)
     {
-        for(size_t base{0};base < samplesToDo;)
+        /* Convert B-Format to A-Format for processing. */
+        const size_t numInput{minz(samplesIn.size(), NUM_LINES)};
+        const al::span<float> tmpspan{al::assume_aligned<16>(mTempLine.data()), samplesToDo};
+        for(size_t c{0u};c < NUM_LINES;c++)
         {
-            /* Calculate the number of samples we can do this iteration. */
-            size_t todo{minz(samplesToDo - base, mMaxUpdate[0])};
-            /* Some mixers require maintaining a 4-sample alignment, so ensure
-             * that if it's not the last iteration.
-             */
-            if(base+todo < samplesToDo) todo &= ~size_t{3};
-            ASSUME(todo > 0);
+            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
+            for(size_t i{0};i < numInput;++i)
+            {
+                const float gain{B2A[c][i]};
+                const float *RESTRICT input{al::assume_aligned<16>(samplesIn[i].data())};
 
-            /* Generate non-faded early reflections and late reverb. */
-            earlyUnfaded(offset, todo);
-            lateUnfaded(offset, todo);
+                auto mix_sample = [gain](const float sample, const float in) noexcept -> float
+                { return sample + in*gain; };
+                std::transform(tmpspan.begin(), tmpspan.end(), input, tmpspan.begin(),
+                    mix_sample);
+            }
 
-            /* Finally, mix early reflections and late reverb. */
-            (this->*mMixOut)(samplesOut, samplesToDo-base, base, todo);
+            /* Band-pass the incoming samples and feed the initial delay line. */
+            auto&& filter = DualBiquad{pipeline.mFilter[c].Lp, pipeline.mFilter[c].Hp};
+            filter.process(tmpspan, tmpspan.data());
+            pipeline.mEarlyDelayIn.write(offset, c, tmpspan.cbegin(), samplesToDo);
+        }
+        if(mPipelineState == Fading)
+        {
+            /* Give the old pipeline silence if it's still fading out. */
+            for(size_t c{0u};c < NUM_LINES;c++)
+            {
+                std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
 
-            offset += todo;
-            base += todo;
+                auto&& filter = DualBiquad{oldpipeline.mFilter[c].Lp, oldpipeline.mFilter[c].Hp};
+                filter.process(tmpspan, tmpspan.data());
+                oldpipeline.mEarlyDelayIn.write(offset, c, tmpspan.cbegin(), samplesToDo);
+            }
         }
     }
     else
     {
+        /* At the start of a fade, fade in input for the current pipeline, and
+         * fade out input for the old pipeline.
+         */
+        const size_t numInput{minz(samplesIn.size(), NUM_LINES)};
+        const al::span<float> tmpspan{al::assume_aligned<16>(mTempLine.data()), samplesToDo};
         const float fadeStep{1.0f / static_cast<float>(samplesToDo)};
-        for(size_t base{0};base < samplesToDo;)
-        {
-            size_t todo{minz(samplesToDo - base, minz(mMaxUpdate[0], mMaxUpdate[1]))};
-            if(base+todo < samplesToDo) todo &= ~size_t{3};
-            ASSUME(todo > 0);
 
-            /* Generate cross-faded early reflections and late reverb. */
-            auto fadeCount = static_cast<ALfloat>(base);
-            earlyFaded(offset, todo, fadeCount, fadeStep);
-            lateFaded(offset, todo, fadeCount, fadeStep);
+        for(size_t c{0u};c < NUM_LINES;c++)
+        {
+            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
+            for(size_t i{0};i < numInput;++i)
+            {
+                const float gain{B2A[c][i]};
+                const float *RESTRICT input{al::assume_aligned<16>(samplesIn[i].data())};
 
-            (this->*mMixOut)(samplesOut, samplesToDo-base, base, todo);
+                auto mix_sample = [gain](const float sample, const float in) noexcept -> float
+                { return sample + in*gain; };
+                std::transform(tmpspan.begin(), tmpspan.end(), input, tmpspan.begin(),
+                    mix_sample);
+            }
+            float stepCount{0.0f};
+            for(float &sample : tmpspan)
+            {
+                stepCount += 1.0f;
+                sample *= stepCount*fadeStep;
+            }
 
-            offset += todo;
-            base += todo;
+            auto&& filter = DualBiquad{pipeline.mFilter[c].Lp, pipeline.mFilter[c].Hp};
+            filter.process(tmpspan, tmpspan.data());
+            pipeline.mEarlyDelayIn.write(offset, c, tmpspan.cbegin(), samplesToDo);
         }
-
-        /* Update the cross-fading delay line taps. */
         for(size_t c{0u};c < NUM_LINES;c++)
         {
-            mEarlyDelayTap[c][0] = mEarlyDelayTap[c][1];
-            mEarlyDelayCoeff[c][0] = mEarlyDelayCoeff[c][1];
-            mEarly.VecAp.Offset[c][0] = mEarly.VecAp.Offset[c][1];
-            mEarly.Offset[c][0] = mEarly.Offset[c][1];
-            mEarly.Coeff[c][0] = mEarly.Coeff[c][1];
-            mLateDelayTap[c][0] = mLateDelayTap[c][1];
-            mLate.VecAp.Offset[c][0] = mLate.VecAp.Offset[c][1];
-            mLate.Offset[c][0] = mLate.Offset[c][1];
-            mLate.T60[c].MidGain[0] = mLate.T60[c].MidGain[1];
-        }
-        mLate.DensityGain[0] = mLate.DensityGain[1];
-        mMaxUpdate[0] = mMaxUpdate[1];
-        mDoFading = false;
-    }
-    mOffset = offset;
-}
+            std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
+            for(size_t i{0};i < numInput;++i)
+            {
+                const float gain{B2A[c][i]};
+                const float *RESTRICT input{al::assume_aligned<16>(samplesIn[i].data())};
 
+                auto mix_sample = [gain](const float sample, const float in) noexcept -> float
+                { return sample + in*gain; };
+                std::transform(tmpspan.begin(), tmpspan.end(), input, tmpspan.begin(),
+                    mix_sample);
+            }
+            float stepCount{0.0f};
+            for(float &sample : tmpspan)
+            {
+                stepCount += 1.0f;
+                sample *= 1.0f - stepCount*fadeStep;
+            }
 
-void EAXReverb_setParami(EffectProps *props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_EAXREVERB_DECAY_HFLIMIT:
-            if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay hflimit out of range");
-            props->Reverb.DecayHFLimit = val != AL_FALSE;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
-                param);
-    }
-}
-void EAXReverb_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ EAXReverb_setParami(props, context, param, vals[0]); }
-void EAXReverb_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_EAXREVERB_DENSITY:
-            if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb room rolloff factor out of range");
-            props->Reverb.RoomRolloffFactor = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param);
-    }
-}
-void EAXReverb_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{
-    switch(param)
-    {
-        case AL_EAXREVERB_REFLECTIONS_PAN:
-            if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
-                SETERR_RETURN(context, 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])))
-                SETERR_RETURN(context, 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:
-            EAXReverb_setParamf(props, context, param, vals[0]);
-            break;
+            auto&& filter = DualBiquad{oldpipeline.mFilter[c].Lp, oldpipeline.mFilter[c].Hp};
+            filter.process(tmpspan, tmpspan.data());
+            oldpipeline.mEarlyDelayIn.write(offset, c, tmpspan.cbegin(), samplesToDo);
+        }
+        mPipelineState = Fading;
     }
-}
 
-void EAXReverb_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
-    {
-        case AL_EAXREVERB_DECAY_HFLIMIT:
-            *val = props->Reverb.DecayHFLimit;
-            break;
+    /* Process reverb for these samples. and mix them to the output. */
+    pipeline.processEarly(offset, samplesToDo, mTempSamples, mEarlySamples);
+    pipeline.processLate(offset, samplesToDo, mTempSamples, mLateSamples);
+    mixOut(pipeline, samplesOut, samplesToDo);
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
-                param);
-    }
-}
-void EAXReverb_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ EAXReverb_getParami(props, context, param, vals); }
-void EAXReverb_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val)
-{
-    switch(param)
+    if(mPipelineState != Normal)
     {
-        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;
+        if(mPipelineState == Cleanup)
+        {
+            size_t numSamples{mSampleBuffer.size()/2};
+            size_t pipelineOffset{numSamples * (mCurrentPipeline^1)};
+            std::fill_n(mSampleBuffer.data()+pipelineOffset, numSamples,
+                decltype(mSampleBuffer)::value_type{});
 
-        case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
-            *val = props->Reverb.RoomRolloffFactor;
-            break;
+            oldpipeline.clear();
+            mPipelineState = Normal;
+        }
+        else
+        {
+            /* If this is the final mix for this old pipeline, set the target
+             * gains to 0 to ensure a complete fade out, and set the state to
+             * Cleanup so the next invocation cleans up the delay buffers and
+             * filters.
+             */
+            if(samplesToDo >= oldpipeline.mFadeSampleCount)
+            {
+                for(auto &gains : oldpipeline.mEarly.TargetGains)
+                    std::fill(std::begin(gains), std::end(gains), 0.0f);
+                for(auto &gains : oldpipeline.mLate.TargetGains)
+                    std::fill(std::begin(gains), std::end(gains), 0.0f);
+                oldpipeline.mFadeSampleCount = 0;
+                mPipelineState = Cleanup;
+            }
+            else
+                oldpipeline.mFadeSampleCount -= samplesToDo;
 
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param);
-    }
-}
-void EAXReverb_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            EAXReverb_getParamf(props, context, param, vals);
-            break;
+            /* Process the old reverb for these samples. */
+            oldpipeline.processEarly(offset, samplesToDo, mTempSamples, mEarlySamples);
+            oldpipeline.processLate(offset, samplesToDo, mTempSamples, mLateSamples);
+            mixOut(oldpipeline, samplesOut, samplesToDo);
+        }
     }
-}
 
-DEFINE_ALEFFECT_VTABLE(EAXReverb);
+    mOffset = offset + samplesToDo;
+}
 
 
 struct ReverbStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new ReverbState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &EAXReverb_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ReverbState{}}; }
 };
 
-EffectProps ReverbStateFactory::getDefaultProps() const 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, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_REVERB_DECAY_HFLIMIT:
-            if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay hflimit out of range");
-            props->Reverb.DecayHFLimit = val != AL_FALSE;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
-    }
-}
-void StdReverb_setParamiv(EffectProps *props, ALCcontext *context, ALenum param, const ALint *vals)
-{ StdReverb_setParami(props, context, param, vals[0]); }
-void StdReverb_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_REVERB_DENSITY:
-            if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb room rolloff factor out of range");
-            props->Reverb.RoomRolloffFactor = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
-    }
-}
-void StdReverb_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ StdReverb_setParamf(props, context, param, vals[0]); }
-
-void StdReverb_getParami(const EffectProps *props, ALCcontext *context, ALenum param, ALint *val)
-{
-    switch(param)
-    {
-        case AL_REVERB_DECAY_HFLIMIT:
-            *val = props->Reverb.DecayHFLimit;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
-    }
-}
-void StdReverb_getParamiv(const EffectProps *props, ALCcontext *context, ALenum param, ALint *vals)
-{ StdReverb_getParami(props, context, param, vals); }
-void StdReverb_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *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:
-            context->setError(AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
-    }
-}
-void StdReverb_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ StdReverb_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(StdReverb);
-
-
 struct StdReverbStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new ReverbState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &StdReverb_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new ReverbState{}}; }
 };
 
-EffectProps StdReverbStateFactory::getDefaultProps() const 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
 
 EffectStateFactory *ReverbStateFactory_getFactory()
diff --git a/alc/effects/vmorpher.cpp b/alc/effects/vmorpher.cpp
index b1b7cc06..872c7add 100644
--- a/alc/effects/vmorpher.cpp
+++ b/alc/effects/vmorpher.cpp
@@ -1,38 +1,63 @@
 /**
- * OpenAL cross platform audio library
+ * This file is part of the OpenAL Soft cross platform audio library
+ *
  * Copyright (C) 2019 by Anis A. Hireche
- * 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.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
  *
- * 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
+ * * Neither the name of Spherical-Harmonic-Transform nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
-#include <cmath>
-#include <cstdlib>
 #include <algorithm>
+#include <array>
+#include <cstdlib>
 #include <functional>
+#include <iterator>
+
+#include "alc/effects/base.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/context.h"
+#include "core/devformat.h"
+#include "core/device.h"
+#include "core/effectslot.h"
+#include "core/mixer.h"
+#include "intrusive_ptr.h"
 
-#include "al/auxeffectslot.h"
-#include "alcmain.h"
-#include "alcontext.h"
-#include "alu.h"
 
 namespace {
 
-#define MAX_UPDATE_SAMPLES 128
+using uint = unsigned int;
+
+#define MAX_UPDATE_SAMPLES 256
 #define NUM_FORMANTS       4
 #define NUM_FILTERS        2
 #define Q_FACTOR           5.0f
@@ -44,22 +69,22 @@ namespace {
 #define WAVEFORM_FRACONE   (1<<WAVEFORM_FRACBITS)
 #define WAVEFORM_FRACMASK  (WAVEFORM_FRACONE-1)
 
-inline float Sin(ALuint index)
+inline float Sin(uint index)
 {
-    constexpr float scale{al::MathDefs<float>::Tau() / WAVEFORM_FRACONE};
+    constexpr float scale{al::numbers::pi_v<float>*2.0f / WAVEFORM_FRACONE};
     return std::sin(static_cast<float>(index) * scale)*0.5f + 0.5f;
 }
 
-inline float Saw(ALuint index)
+inline float Saw(uint index)
 { return static_cast<float>(index) / float{WAVEFORM_FRACONE}; }
 
-inline float Triangle(ALuint index)
+inline float Triangle(uint index)
 { return std::fabs(static_cast<float>(index)*(2.0f/WAVEFORM_FRACONE) - 1.0f); }
 
-inline float Half(ALuint) { return 0.5f; }
+inline float Half(uint) { return 0.5f; }
 
-template<float (&func)(ALuint)>
-void Oscillate(float *RESTRICT dst, ALuint index, const ALuint step, size_t todo)
+template<float (&func)(uint)>
+void Oscillate(float *RESTRICT dst, uint index, const uint step, size_t todo)
 {
     for(size_t i{0u};i < todo;i++)
     {
@@ -71,32 +96,32 @@ void Oscillate(float *RESTRICT dst, ALuint index, const ALuint step, size_t todo
 
 struct FormantFilter
 {
-    ALfloat mCoeff{0.0f};
-    ALfloat mGain{1.0f};
-    ALfloat mS1{0.0f};
-    ALfloat mS2{0.0f};
+    float mCoeff{0.0f};
+    float mGain{1.0f};
+    float mS1{0.0f};
+    float mS2{0.0f};
 
     FormantFilter() = default;
-    FormantFilter(ALfloat f0norm, ALfloat gain)
-      : mCoeff{std::tan(al::MathDefs<float>::Pi() * f0norm)}, mGain{gain}
+    FormantFilter(float f0norm, float gain)
+      : mCoeff{std::tan(al::numbers::pi_v<float> * f0norm)}, mGain{gain}
     { }
 
-    inline void process(const ALfloat *samplesIn, ALfloat *samplesOut, const size_t numInput)
+    inline void process(const float *samplesIn, float *samplesOut, const size_t numInput)
     {
         /* A state variable filter from a topology-preserving transform.
          * Based on a talk given by Ivan Cohen: https://www.youtube.com/watch?v=esjHXGPyrhg
          */
-        const ALfloat g{mCoeff};
-        const ALfloat gain{mGain};
-        const ALfloat h{1.0f / (1.0f + (g/Q_FACTOR) + (g*g))};
-        ALfloat s1{mS1};
-        ALfloat s2{mS2};
+        const float g{mCoeff};
+        const float gain{mGain};
+        const float h{1.0f / (1.0f + (g/Q_FACTOR) + (g*g))};
+        float s1{mS1};
+        float s2{mS2};
 
         for(size_t i{0u};i < numInput;i++)
         {
-            const ALfloat H{(samplesIn[i] - (1.0f/Q_FACTOR + g)*s1 - s2)*h};
-            const ALfloat B{g*H + s1};
-            const ALfloat L{g*B + s2};
+            const float H{(samplesIn[i] - (1.0f/Q_FACTOR + g)*s1 - s2)*h};
+            const float B{g*H + s1};
+            const float L{g*B + s2};
 
             s1 = g*H + B;
             s2 = g*B + L;
@@ -118,33 +143,40 @@ struct FormantFilter
 
 struct VmorpherState final : public EffectState {
     struct {
+        uint mTargetChannel{InvalidChannelIndex};
+
         /* Effect parameters */
-        FormantFilter Formants[NUM_FILTERS][NUM_FORMANTS];
+        FormantFilter mFormants[NUM_FILTERS][NUM_FORMANTS];
 
         /* Effect gains for each channel */
-        ALfloat CurrentGains[MAX_OUTPUT_CHANNELS]{};
-        ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
-    } mChans[MAX_AMBI_CHANNELS];
+        float mCurrentGain{};
+        float mTargetGain{};
+    } mChans[MaxAmbiChannels];
 
-    void (*mGetSamples)(float*RESTRICT, ALuint, const ALuint, size_t){};
+    void (*mGetSamples)(float*RESTRICT, uint, const uint, size_t){};
 
-    ALuint mIndex{0};
-    ALuint mStep{1};
+    uint mIndex{0};
+    uint mStep{1};
 
     /* Effects buffers */
-    ALfloat mSampleBufferA[MAX_UPDATE_SAMPLES]{};
-    ALfloat mSampleBufferB[MAX_UPDATE_SAMPLES]{};
+    alignas(16) float mSampleBufferA[MAX_UPDATE_SAMPLES]{};
+    alignas(16) float mSampleBufferB[MAX_UPDATE_SAMPLES]{};
+    alignas(16) float mLfo[MAX_UPDATE_SAMPLES]{};
 
-    ALboolean deviceUpdate(const ALCdevice *device) override;
-    void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
-    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) override;
+    void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) override;
 
-    static std::array<FormantFilter,4> getFiltersByPhoneme(ALenum phoneme, ALfloat frequency, ALfloat pitch);
+    static std::array<FormantFilter,4> getFiltersByPhoneme(VMorpherPhenome phoneme,
+        float frequency, float pitch);
 
     DEF_NEWDEL(VmorpherState)
 };
 
-std::array<FormantFilter,4> VmorpherState::getFiltersByPhoneme(ALenum phoneme, ALfloat frequency, ALfloat pitch)
+std::array<FormantFilter,4> VmorpherState::getFiltersByPhoneme(VMorpherPhenome phoneme,
+    float frequency, float pitch)
 {
     /* Using soprano formant set of values to
      * better match mid-range frequency space.
@@ -153,79 +185,81 @@ std::array<FormantFilter,4> VmorpherState::getFiltersByPhoneme(ALenum phoneme, A
      */
     switch(phoneme)
     {
-    case AL_VOCAL_MORPHER_PHONEME_A:
+    case VMorpherPhenome::A:
         return {{
             {( 800 * pitch) / frequency, 1.000000f}, /* std::pow(10.0f,   0 / 20.0f); */
             {(1150 * pitch) / frequency, 0.501187f}, /* std::pow(10.0f,  -6 / 20.0f); */
             {(2900 * pitch) / frequency, 0.025118f}, /* std::pow(10.0f, -32 / 20.0f); */
             {(3900 * pitch) / frequency, 0.100000f}  /* std::pow(10.0f, -20 / 20.0f); */
         }};
-    case AL_VOCAL_MORPHER_PHONEME_E:
+    case VMorpherPhenome::E:
         return {{
             {( 350 * pitch) / frequency, 1.000000f}, /* std::pow(10.0f,   0 / 20.0f); */
             {(2000 * pitch) / frequency, 0.100000f}, /* std::pow(10.0f, -20 / 20.0f); */
             {(2800 * pitch) / frequency, 0.177827f}, /* std::pow(10.0f, -15 / 20.0f); */
             {(3600 * pitch) / frequency, 0.009999f}  /* std::pow(10.0f, -40 / 20.0f); */
         }};
-    case AL_VOCAL_MORPHER_PHONEME_I:
+    case VMorpherPhenome::I:
         return {{
             {( 270 * pitch) / frequency, 1.000000f}, /* std::pow(10.0f,   0 / 20.0f); */
             {(2140 * pitch) / frequency, 0.251188f}, /* std::pow(10.0f, -12 / 20.0f); */
             {(2950 * pitch) / frequency, 0.050118f}, /* std::pow(10.0f, -26 / 20.0f); */
             {(3900 * pitch) / frequency, 0.050118f}  /* std::pow(10.0f, -26 / 20.0f); */
         }};
-    case AL_VOCAL_MORPHER_PHONEME_O:
+    case VMorpherPhenome::O:
         return {{
             {( 450 * pitch) / frequency, 1.000000f}, /* std::pow(10.0f,   0 / 20.0f); */
             {( 800 * pitch) / frequency, 0.281838f}, /* std::pow(10.0f, -11 / 20.0f); */
             {(2830 * pitch) / frequency, 0.079432f}, /* std::pow(10.0f, -22 / 20.0f); */
             {(3800 * pitch) / frequency, 0.079432f}  /* std::pow(10.0f, -22 / 20.0f); */
         }};
-    case AL_VOCAL_MORPHER_PHONEME_U:
+    case VMorpherPhenome::U:
         return {{
             {( 325 * pitch) / frequency, 1.000000f}, /* std::pow(10.0f,   0 / 20.0f); */
             {( 700 * pitch) / frequency, 0.158489f}, /* std::pow(10.0f, -16 / 20.0f); */
             {(2700 * pitch) / frequency, 0.017782f}, /* std::pow(10.0f, -35 / 20.0f); */
             {(3800 * pitch) / frequency, 0.009999f}  /* std::pow(10.0f, -40 / 20.0f); */
         }};
+    default:
+        break;
     }
     return {};
 }
 
 
-ALboolean VmorpherState::deviceUpdate(const ALCdevice* /*device*/)
+void VmorpherState::deviceUpdate(const DeviceBase*, const BufferStorage*)
 {
     for(auto &e : mChans)
     {
-        std::for_each(std::begin(e.Formants[VOWEL_A_INDEX]), std::end(e.Formants[VOWEL_A_INDEX]),
+        e.mTargetChannel = InvalidChannelIndex;
+        std::for_each(std::begin(e.mFormants[VOWEL_A_INDEX]), std::end(e.mFormants[VOWEL_A_INDEX]),
             std::mem_fn(&FormantFilter::clear));
-        std::for_each(std::begin(e.Formants[VOWEL_B_INDEX]), std::end(e.Formants[VOWEL_B_INDEX]),
+        std::for_each(std::begin(e.mFormants[VOWEL_B_INDEX]), std::end(e.mFormants[VOWEL_B_INDEX]),
             std::mem_fn(&FormantFilter::clear));
-        std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
+        e.mCurrentGain = 0.0f;
     }
-
-    return AL_TRUE;
 }
 
-void VmorpherState::update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target)
+void VmorpherState::update(const ContextBase *context, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
 {
-    const ALCdevice *device{context->mDevice.get()};
-    const ALfloat frequency{static_cast<ALfloat>(device->Frequency)};
-    const ALfloat step{props->Vmorpher.Rate / frequency};
-    mStep = fastf2u(clampf(step*WAVEFORM_FRACONE, 0.0f, ALfloat{WAVEFORM_FRACONE-1}));
+    const DeviceBase *device{context->mDevice};
+    const float frequency{static_cast<float>(device->Frequency)};
+    const float step{props->Vmorpher.Rate / frequency};
+    mStep = fastf2u(clampf(step*WAVEFORM_FRACONE, 0.0f, float{WAVEFORM_FRACONE-1}));
 
     if(mStep == 0)
         mGetSamples = Oscillate<Half>;
-    else if(props->Vmorpher.Waveform == AL_VOCAL_MORPHER_WAVEFORM_SINUSOID)
+    else if(props->Vmorpher.Waveform == VMorpherWaveform::Sinusoid)
         mGetSamples = Oscillate<Sin>;
-    else if(props->Vmorpher.Waveform == AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH)
-        mGetSamples = Oscillate<Saw>;
-    else /*if(props->Vmorpher.Waveform == AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE)*/
+    else if(props->Vmorpher.Waveform == VMorpherWaveform::Triangle)
         mGetSamples = Oscillate<Triangle>;
+    else /*if(props->Vmorpher.Waveform == VMorpherWaveform::Sawtooth)*/
+        mGetSamples = Oscillate<Saw>;
 
-    const ALfloat pitchA{std::pow(2.0f,
+    const float pitchA{std::pow(2.0f,
         static_cast<float>(props->Vmorpher.PhonemeACoarseTuning) / 12.0f)};
-    const ALfloat pitchB{std::pow(2.0f,
+    const float pitchB{std::pow(2.0f,
         static_cast<float>(props->Vmorpher.PhonemeBCoarseTuning) / 12.0f)};
 
     auto vowelA = getFiltersByPhoneme(props->Vmorpher.PhonemeA, frequency, pitchA);
@@ -234,16 +268,17 @@ void VmorpherState::update(const ALCcontext *context, const ALeffectslot *slot,
     /* Copy the filter coefficients to the input channels. */
     for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
     {
-        std::copy(vowelA.begin(), vowelA.end(), std::begin(mChans[i].Formants[VOWEL_A_INDEX]));
-        std::copy(vowelB.begin(), vowelB.end(), std::begin(mChans[i].Formants[VOWEL_B_INDEX]));
+        std::copy(vowelA.begin(), vowelA.end(), std::begin(mChans[i].mFormants[VOWEL_A_INDEX]));
+        std::copy(vowelB.begin(), vowelB.end(), std::begin(mChans[i].mFormants[VOWEL_B_INDEX]));
     }
 
     mOutTarget = target.Main->Buffer;
-    for(size_t i{0u};i < slot->Wet.Buffer.size();++i)
+    auto set_channel = [this](size_t idx, uint outchan, float outgain)
     {
-        auto coeffs = GetAmbiIdentityRow(i);
-        ComputePanGains(target.Main, coeffs.data(), slot->Params.Gain, mChans[i].TargetGains);
-    }
+        mChans[idx].mTargetChannel = outchan;
+        mChans[idx].mTargetGain = outgain;
+    };
+    target.Main->setAmbiMixParams(slot->Wet, slot->Gain, set_channel);
 }
 
 void VmorpherState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut)
@@ -253,41 +288,46 @@ void VmorpherState::process(const size_t samplesToDo, const al::span<const Float
      */
     for(size_t base{0u};base < samplesToDo;)
     {
-        alignas(16) ALfloat lfo[MAX_UPDATE_SAMPLES];
         const size_t td{minz(MAX_UPDATE_SAMPLES, samplesToDo-base)};
 
-        mGetSamples(lfo, mIndex, mStep, td);
-        mIndex += static_cast<ALuint>(mStep * td);
+        mGetSamples(mLfo, mIndex, mStep, td);
+        mIndex += static_cast<uint>(mStep * td);
         mIndex &= WAVEFORM_FRACMASK;
 
-        auto chandata = std::addressof(mChans[0]);
+        auto chandata = std::begin(mChans);
         for(const auto &input : samplesIn)
         {
-            std::fill_n(std::begin(mSampleBufferA), td, 0.0f);
-            std::fill_n(std::begin(mSampleBufferB), td, 0.0f);
+            const size_t outidx{chandata->mTargetChannel};
+            if(outidx == InvalidChannelIndex)
+            {
+                ++chandata;
+                continue;
+            }
 
-            auto& vowelA = chandata->Formants[VOWEL_A_INDEX];
-            auto& vowelB = chandata->Formants[VOWEL_B_INDEX];
+            auto& vowelA = chandata->mFormants[VOWEL_A_INDEX];
+            auto& vowelB = chandata->mFormants[VOWEL_B_INDEX];
 
             /* Process first vowel. */
+            std::fill_n(std::begin(mSampleBufferA), td, 0.0f);
             vowelA[0].process(&input[base], mSampleBufferA, td);
             vowelA[1].process(&input[base], mSampleBufferA, td);
             vowelA[2].process(&input[base], mSampleBufferA, td);
             vowelA[3].process(&input[base], mSampleBufferA, td);
 
             /* Process second vowel. */
+            std::fill_n(std::begin(mSampleBufferB), td, 0.0f);
             vowelB[0].process(&input[base], mSampleBufferB, td);
             vowelB[1].process(&input[base], mSampleBufferB, td);
             vowelB[2].process(&input[base], mSampleBufferB, td);
             vowelB[3].process(&input[base], mSampleBufferB, td);
 
-            alignas(16) ALfloat blended[MAX_UPDATE_SAMPLES];
+            alignas(16) float blended[MAX_UPDATE_SAMPLES];
             for(size_t i{0u};i < td;i++)
-                blended[i] = lerp(mSampleBufferA[i], mSampleBufferB[i], lfo[i]);
+                blended[i] = lerpf(mSampleBufferA[i], mSampleBufferB[i], mLfo[i]);
 
             /* Now, mix the processed sound data to the output. */
-            MixSamples({blended, td}, samplesOut, chandata->CurrentGains, chandata->TargetGains,
-                samplesToDo-base, base);
+            MixSamples({blended, td}, samplesOut[outidx].data()+base, chandata->mCurrentGain,
+                chandata->mTargetGain, samplesToDo-base);
             ++chandata;
         }
 
@@ -296,133 +336,11 @@ void VmorpherState::process(const size_t samplesToDo, const al::span<const Float
 }
 
 
-void Vmorpher_setParami(EffectProps* props, ALCcontext *context, ALenum param, ALint val)
-{
-    switch(param)
-    {
-        case AL_VOCAL_MORPHER_WAVEFORM:
-            if(!(val >= AL_VOCAL_MORPHER_MIN_WAVEFORM && val <= AL_VOCAL_MORPHER_MAX_WAVEFORM))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher waveform out of range");
-            props->Vmorpher.Waveform = val;
-            break;
-
-        case AL_VOCAL_MORPHER_PHONEMEA:
-            if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEA && val <= AL_VOCAL_MORPHER_MAX_PHONEMEA))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher phoneme-a out of range");
-            props->Vmorpher.PhonemeA = val;
-            break;
-
-        case AL_VOCAL_MORPHER_PHONEMEB:
-            if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEB && val <= AL_VOCAL_MORPHER_MAX_PHONEMEB))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher phoneme-b out of range");
-            props->Vmorpher.PhonemeB = 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher phoneme-a coarse tuning out of range");
-            props->Vmorpher.PhonemeACoarseTuning = 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))
-                SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher phoneme-b coarse tuning out of range");
-            props->Vmorpher.PhonemeBCoarseTuning = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
-                param);
-    }
-}
-void Vmorpher_setParamiv(EffectProps*, ALCcontext *context, ALenum param, const ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x", param); }
-void Vmorpher_setParamf(EffectProps *props, ALCcontext *context, ALenum param, ALfloat val)
-{
-    switch(param)
-    {
-        case AL_VOCAL_MORPHER_RATE:
-            if(!(val >= AL_VOCAL_MORPHER_MIN_RATE && val <= AL_VOCAL_MORPHER_MAX_RATE))
-              SETERR_RETURN(context, AL_INVALID_VALUE,, "Vocal morpher rate out of range");
-            props->Vmorpher.Rate = val;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
-                param);
-    }
-}
-void Vmorpher_setParamfv(EffectProps *props, ALCcontext *context, ALenum param, const ALfloat *vals)
-{ Vmorpher_setParamf(props, context, param, vals[0]); }
-
-void Vmorpher_getParami(const EffectProps* props, ALCcontext *context, ALenum param, ALint* val)
-{
-    switch(param)
-    {
-        case AL_VOCAL_MORPHER_PHONEMEA:
-            *val = props->Vmorpher.PhonemeA;
-            break;
-
-        case AL_VOCAL_MORPHER_PHONEMEB:
-            *val = props->Vmorpher.PhonemeB;
-            break;
-
-        case AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING:
-            *val = props->Vmorpher.PhonemeACoarseTuning;
-            break;
-
-        case AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING:
-            *val = props->Vmorpher.PhonemeBCoarseTuning;
-            break;
-
-        case AL_VOCAL_MORPHER_WAVEFORM:
-            *val = props->Vmorpher.Waveform;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
-                param);
-    }
-}
-void Vmorpher_getParamiv(const EffectProps*, ALCcontext *context, ALenum param, ALint*)
-{ context->setError(AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x", param); }
-void Vmorpher_getParamf(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *val)
-{
-    switch(param)
-    {
-        case AL_VOCAL_MORPHER_RATE:
-            *val = props->Vmorpher.Rate;
-            break;
-
-        default:
-            context->setError(AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
-                param);
-    }
-}
-void Vmorpher_getParamfv(const EffectProps *props, ALCcontext *context, ALenum param, ALfloat *vals)
-{ Vmorpher_getParamf(props, context, param, vals); }
-
-DEFINE_ALEFFECT_VTABLE(Vmorpher);
-
-
 struct VmorpherStateFactory final : public EffectStateFactory {
-    EffectState *create() override { return new VmorpherState{}; }
-    EffectProps getDefaultProps() const noexcept override;
-    const EffectVtable *getEffectVtable() const noexcept override { return &Vmorpher_vtable; }
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new VmorpherState{}}; }
 };
 
-EffectProps VmorpherStateFactory::getDefaultProps() const noexcept
-{
-    EffectProps props{};
-    props.Vmorpher.Rate                 = AL_VOCAL_MORPHER_DEFAULT_RATE;
-    props.Vmorpher.PhonemeA             = AL_VOCAL_MORPHER_DEFAULT_PHONEMEA;
-    props.Vmorpher.PhonemeB             = 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             = AL_VOCAL_MORPHER_DEFAULT_WAVEFORM;
-    return props;
-}
-
 } // namespace
 
 EffectStateFactory *VmorpherStateFactory_getFactory()
diff --git a/alc/filters/splitter.cpp b/alc/filters/splitter.cpp
deleted file mode 100644
index c6218e70..00000000
--- a/alc/filters/splitter.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-
-#include "config.h"
-
-#include "splitter.h"
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-
-#include "math_defs.h"
-#include "opthelpers.h"
-
-
-template<typename Real>
-void BandSplitterR<Real>::init(Real f0norm)
-{
-    const Real w{f0norm * al::MathDefs<Real>::Tau()};
-    const Real cw{std::cos(w)};
-    if(cw > std::numeric_limits<float>::epsilon())
-        mCoeff = (std::sin(w) - 1.0f) / cw;
-    else
-        mCoeff = cw * -0.5f;
-
-    mLpZ1 = 0.0f;
-    mLpZ2 = 0.0f;
-    mApZ1 = 0.0f;
-}
-
-template<typename Real>
-void BandSplitterR<Real>::process(Real *hpout, Real *lpout, const Real *input, const size_t count)
-{
-    ASSUME(count > 0);
-
-    const Real ap_coeff{mCoeff};
-    const Real lp_coeff{mCoeff*0.5f + 0.5f};
-    Real lp_z1{mLpZ1};
-    Real lp_z2{mLpZ2};
-    Real ap_z1{mApZ1};
-    auto proc_sample = [ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1,&lpout](const Real in) noexcept -> Real
-    {
-        /* Low-pass sample processing. */
-        Real d{(in - lp_z1) * lp_coeff};
-        Real lp_y{lp_z1 + d};
-        lp_z1 = lp_y + d;
-
-        d = (lp_y - lp_z2) * lp_coeff;
-        lp_y = lp_z2 + d;
-        lp_z2 = lp_y + d;
-
-        *(lpout++) = lp_y;
-
-        /* All-pass sample processing. */
-        Real ap_y{in*ap_coeff + ap_z1};
-        ap_z1 = in - ap_y*ap_coeff;
-
-        /* High-pass generated from removing low-passed output. */
-        return ap_y - lp_y;
-    };
-    std::transform(input, input+count, hpout, proc_sample);
-    mLpZ1 = lp_z1;
-    mLpZ2 = lp_z2;
-    mApZ1 = ap_z1;
-}
-
-template<typename Real>
-void BandSplitterR<Real>::applyHfScale(Real *samples, const Real hfscale, const size_t count)
-{
-    ASSUME(count > 0);
-
-    const Real ap_coeff{mCoeff};
-    const Real lp_coeff{mCoeff*0.5f + 0.5f};
-    Real lp_z1{mLpZ1};
-    Real lp_z2{mLpZ2};
-    Real ap_z1{mApZ1};
-    auto proc_sample = [hfscale,ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1](const Real in) noexcept -> Real
-    {
-        /* Low-pass sample processing. */
-        Real d{(in - lp_z1) * lp_coeff};
-        Real lp_y{lp_z1 + d};
-        lp_z1 = lp_y + d;
-
-        d = (lp_y - lp_z2) * lp_coeff;
-        lp_y = lp_z2 + d;
-        lp_z2 = lp_y + d;
-
-        /* All-pass sample processing. */
-        Real ap_y{in*ap_coeff + ap_z1};
-        ap_z1 = in - ap_y*ap_coeff;
-
-        /* High-pass generated from removing low-passed output. */
-        return (ap_y-lp_y)*hfscale + lp_y;
-    };
-    std::transform(samples, samples+count, samples, proc_sample);
-    mLpZ1 = lp_z1;
-    mLpZ2 = lp_z2;
-    mApZ1 = ap_z1;
-}
-
-template<typename Real>
-void BandSplitterR<Real>::applyAllpass(Real *samples, const size_t count) const
-{
-    ASSUME(count > 0);
-
-    const Real coeff{mCoeff};
-    Real z1{0.0f};
-    auto proc_sample = [coeff,&z1](const Real in) noexcept -> Real
-    {
-        const Real out{in*coeff + z1};
-        z1 = in - out*coeff;
-        return out;
-    };
-    std::transform(samples, samples+count, samples, proc_sample);
-}
-
-
-template class BandSplitterR<float>;
-template class BandSplitterR<double>;
diff --git a/alc/filters/splitter.h b/alc/filters/splitter.h
deleted file mode 100644
index 5117a244..00000000
--- a/alc/filters/splitter.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef FILTER_SPLITTER_H
-#define FILTER_SPLITTER_H
-
-#include <cstddef>
-
-
-/* Band splitter. Splits a signal into two phase-matching frequency bands. */
-template<typename Real>
-class BandSplitterR {
-    Real mCoeff{0.0f};
-    Real mLpZ1{0.0f};
-    Real mLpZ2{0.0f};
-    Real mApZ1{0.0f};
-
-public:
-    BandSplitterR() = default;
-    BandSplitterR(const BandSplitterR&) = default;
-    BandSplitterR(Real f0norm) { init(f0norm); }
-
-    void init(Real f0norm);
-    void clear() noexcept { mLpZ1 = mLpZ2 = mApZ1 = 0.0f; }
-    void process(Real *hpout, Real *lpout, const Real *input, const size_t count);
-
-    void applyHfScale(Real *samples, const Real hfscale, const size_t count);
-
-    /* The all-pass portion of the band splitter. Applies the same phase shift
-     * without splitting the signal. Note that each use of this method is
-     * indepedent, it does not track history between calls.
-     */
-    void applyAllpass(Real *samples, const size_t count) const;
-};
-using BandSplitter = BandSplitterR<float>;
-
-#endif /* FILTER_SPLITTER_H */
diff --git a/alc/fpu_modes.h b/alc/fpu_modes.h
deleted file mode 100644
index 5465e9cf..00000000
--- a/alc/fpu_modes.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef FPU_MODES_H
-#define FPU_MODES_H
-
-class FPUCtl {
-#if defined(HAVE_SSE_INTRINSICS) || (defined(__GNUC__) && defined(HAVE_SSE))
-    unsigned int sse_state{};
-#endif
-    bool in_mode{};
-
-public:
-    FPUCtl();
-    /* HACK: 32-bit targets for GCC seem to have a problem here with certain
-     * noexcept methods (which destructors are) causing an internal compiler
-     * error. No idea why it's these methods specifically, but this is needed
-     * to get it to compile.
-     */
-    ~FPUCtl() noexcept(false) { leave(); }
-
-    FPUCtl(const FPUCtl&) = delete;
-    FPUCtl& operator=(const FPUCtl&) = delete;
-
-    void leave();
-};
-
-#endif /* FPU_MODES_H */
diff --git a/alc/helpers.cpp b/alc/helpers.cpp
deleted file mode 100644
index 4ea94c7d..00000000
--- a/alc/helpers.cpp
+++ /dev/null
@@ -1,649 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2011 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
- */
-
-#ifdef _WIN32
-#ifdef __MINGW32__
-#define _WIN32_IE 0x501
-#else
-#define _WIN32_IE 0x400
-#endif
-#endif
-
-#include "config.h"
-
-#include <algorithm>
-#include <cerrno>
-#include <cstdarg>
-#include <cstdlib>
-#include <cstdio>
-#include <cstring>
-#include <mutex>
-#include <string>
-
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-#ifdef HAVE_INTRIN_H
-#include <intrin.h>
-#endif
-#ifdef HAVE_CPUID_H
-#include <cpuid.h>
-#endif
-#ifdef HAVE_SSE_INTRINSICS
-#include <xmmintrin.h>
-#endif
-#ifdef HAVE_SYS_SYSCONF_H
-#include <sys/sysconf.h>
-#endif
-
-#ifdef HAVE_PROC_PIDPATH
-#include <libproc.h>
-#endif
-
-#ifdef __FreeBSD__
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#endif
-
-#ifndef _WIN32
-#include <unistd.h>
-#elif defined(_WIN32_IE)
-#include <shlobj.h>
-#endif
-
-#include "alcmain.h"
-#include "almalloc.h"
-#include "alfstream.h"
-#include "alspan.h"
-#include "alstring.h"
-#include "compat.h"
-#include "cpu_caps.h"
-#include "fpu_modes.h"
-#include "logging.h"
-#include "strutils.h"
-#include "vector.h"
-
-
-#if defined(HAVE_GCC_GET_CPUID) && (defined(__i386__) || defined(__x86_64__) || \
-                                    defined(_M_IX86) || defined(_M_X64))
-using reg_type = unsigned int;
-static inline void get_cpuid(unsigned int f, reg_type *regs)
-{ __get_cpuid(f, &regs[0], &regs[1], &regs[2], &regs[3]); }
-#define CAN_GET_CPUID
-#elif defined(HAVE_CPUID_INTRINSIC) && (defined(__i386__) || defined(__x86_64__) || \
-                                        defined(_M_IX86) || defined(_M_X64))
-using reg_type = int;
-static inline void get_cpuid(unsigned int f, reg_type *regs)
-{ (__cpuid)(regs, f); }
-#define CAN_GET_CPUID
-#endif
-
-int CPUCapFlags = 0;
-
-void FillCPUCaps(int capfilter)
-{
-    int caps = 0;
-
-/* FIXME: We really should get this for all available CPUs in case different
- * CPUs have different caps (is that possible on one machine?). */
-#ifdef CAN_GET_CPUID
-    union {
-        reg_type regs[4];
-        char str[sizeof(reg_type[4])];
-    } cpuinf[3]{};
-
-    get_cpuid(0, cpuinf[0].regs);
-    if(cpuinf[0].regs[0] == 0)
-        ERR("Failed to get CPUID\n");
-    else
-    {
-        unsigned int maxfunc = cpuinf[0].regs[0];
-        unsigned int maxextfunc;
-
-        get_cpuid(0x80000000, cpuinf[0].regs);
-        maxextfunc = cpuinf[0].regs[0];
-
-        TRACE("Detected max CPUID function: 0x%x (ext. 0x%x)\n", maxfunc, maxextfunc);
-
-        TRACE("Vendor ID: \"%.4s%.4s%.4s\"\n", cpuinf[0].str+4, cpuinf[0].str+12, cpuinf[0].str+8);
-        if(maxextfunc >= 0x80000004)
-        {
-            get_cpuid(0x80000002, cpuinf[0].regs);
-            get_cpuid(0x80000003, cpuinf[1].regs);
-            get_cpuid(0x80000004, cpuinf[2].regs);
-            TRACE("Name: \"%.16s%.16s%.16s\"\n", cpuinf[0].str, cpuinf[1].str, cpuinf[2].str);
-        }
-
-        if(maxfunc >= 1)
-        {
-            get_cpuid(1, cpuinf[0].regs);
-            if((cpuinf[0].regs[3]&(1<<25)))
-                caps |= CPU_CAP_SSE;
-            if((caps&CPU_CAP_SSE) && (cpuinf[0].regs[3]&(1<<26)))
-                caps |= CPU_CAP_SSE2;
-            if((caps&CPU_CAP_SSE2) && (cpuinf[0].regs[2]&(1<<0)))
-                caps |= CPU_CAP_SSE3;
-            if((caps&CPU_CAP_SSE3) && (cpuinf[0].regs[2]&(1<<19)))
-                caps |= CPU_CAP_SSE4_1;
-        }
-    }
-#else
-    /* Assume support for whatever's supported if we can't check for it */
-#if defined(HAVE_SSE4_1)
-#warning "Assuming SSE 4.1 run-time support!"
-    caps |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3 | CPU_CAP_SSE4_1;
-#elif defined(HAVE_SSE3)
-#warning "Assuming SSE 3 run-time support!"
-    caps |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3;
-#elif defined(HAVE_SSE2)
-#warning "Assuming SSE 2 run-time support!"
-    caps |= CPU_CAP_SSE | CPU_CAP_SSE2;
-#elif defined(HAVE_SSE)
-#warning "Assuming SSE run-time support!"
-    caps |= CPU_CAP_SSE;
-#endif
-#endif
-#ifdef HAVE_NEON
-    al::ifstream file{"/proc/cpuinfo"};
-    if(!file.is_open())
-        ERR("Failed to open /proc/cpuinfo, cannot check for NEON support\n");
-    else
-    {
-        std::string features;
-
-        auto getline = [](std::istream &f, std::string &output) -> bool
-        {
-            while(f.good() && f.peek() == '\n')
-                f.ignore();
-            return std::getline(f, output) && !output.empty();
-
-        };
-        while(getline(file, features))
-        {
-            if(features.compare(0, 10, "Features\t:", 10) == 0)
-                break;
-        }
-        file.close();
-
-        size_t extpos{9};
-        while((extpos=features.find("neon", extpos+1)) != std::string::npos)
-        {
-            if((extpos == 0 || std::isspace(features[extpos-1])) &&
-                (extpos+4 == features.length() || std::isspace(features[extpos+4])))
-            {
-                caps |= CPU_CAP_NEON;
-                break;
-            }
-        }
-    }
-#endif
-
-    TRACE("Extensions:%s%s%s%s%s%s\n",
-        ((capfilter&CPU_CAP_SSE)    ? ((caps&CPU_CAP_SSE)    ? " +SSE"    : " -SSE")    : ""),
-        ((capfilter&CPU_CAP_SSE2)   ? ((caps&CPU_CAP_SSE2)   ? " +SSE2"   : " -SSE2")   : ""),
-        ((capfilter&CPU_CAP_SSE3)   ? ((caps&CPU_CAP_SSE3)   ? " +SSE3"   : " -SSE3")   : ""),
-        ((capfilter&CPU_CAP_SSE4_1) ? ((caps&CPU_CAP_SSE4_1) ? " +SSE4.1" : " -SSE4.1") : ""),
-        ((capfilter&CPU_CAP_NEON)   ? ((caps&CPU_CAP_NEON)   ? " +NEON"   : " -NEON")   : ""),
-        ((!capfilter) ? " -none-" : "")
-    );
-    CPUCapFlags = caps & capfilter;
-}
-
-
-FPUCtl::FPUCtl()
-{
-#if defined(HAVE_SSE_INTRINSICS)
-    this->sse_state = _mm_getcsr();
-    unsigned int sseState = this->sse_state;
-    sseState |= 0x8000; /* set flush-to-zero */
-    sseState |= 0x0040; /* set denormals-are-zero */
-    _mm_setcsr(sseState);
-
-#elif defined(__GNUC__) && defined(HAVE_SSE)
-
-    if((CPUCapFlags&CPU_CAP_SSE))
-    {
-        __asm__ __volatile__("stmxcsr %0" : "=m" (*&this->sse_state));
-        unsigned int sseState = this->sse_state;
-        sseState |= 0x8000; /* set flush-to-zero */
-        if((CPUCapFlags&CPU_CAP_SSE2))
-            sseState |= 0x0040; /* set denormals-are-zero */
-        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&sseState));
-    }
-#endif
-
-    this->in_mode = true;
-}
-
-void FPUCtl::leave()
-{
-    if(!this->in_mode) return;
-
-#if defined(HAVE_SSE_INTRINSICS)
-    _mm_setcsr(this->sse_state);
-
-#elif defined(__GNUC__) && defined(HAVE_SSE)
-
-    if((CPUCapFlags&CPU_CAP_SSE))
-        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&this->sse_state));
-#endif
-    this->in_mode = false;
-}
-
-
-#ifdef _WIN32
-
-const PathNamePair &GetProcBinary()
-{
-    static PathNamePair ret;
-    if(!ret.fname.empty() || !ret.path.empty())
-        return ret;
-
-    al::vector<WCHAR> fullpath(256);
-    DWORD len;
-    while((len=GetModuleFileNameW(nullptr, fullpath.data(), static_cast<DWORD>(fullpath.size()))) == fullpath.size())
-        fullpath.resize(fullpath.size() << 1);
-    if(len == 0)
-    {
-        ERR("Failed to get process name: error %lu\n", GetLastError());
-        return ret;
-    }
-
-    fullpath.resize(len);
-    if(fullpath.back() != 0)
-        fullpath.push_back(0);
-
-    auto sep = std::find(fullpath.rbegin()+1, fullpath.rend(), '\\');
-    sep = std::find(fullpath.rbegin()+1, sep, '/');
-    if(sep != fullpath.rend())
-    {
-        *sep = 0;
-        ret.fname = wstr_to_utf8(&*sep + 1);
-        ret.path = wstr_to_utf8(fullpath.data());
-    }
-    else
-        ret.fname = wstr_to_utf8(fullpath.data());
-
-    TRACE("Got binary: %s, %s\n", ret.path.c_str(), ret.fname.c_str());
-    return ret;
-}
-
-
-void al_print(FILE *logfile, const char *fmt, ...)
-{
-    al::vector<char> dynmsg;
-    char stcmsg[256];
-    char *str{stcmsg};
-
-    va_list args, args2;
-    va_start(args, fmt);
-    va_copy(args2, args);
-    int msglen{std::vsnprintf(str, sizeof(stcmsg), fmt, args)};
-    if UNLIKELY(msglen >= 0 && static_cast<size_t>(msglen) >= sizeof(stcmsg))
-    {
-        dynmsg.resize(static_cast<size_t>(msglen) + 1u);
-        str = dynmsg.data();
-        msglen = std::vsnprintf(str, dynmsg.size(), fmt, args2);
-    }
-    va_end(args2);
-    va_end(args);
-
-    std::wstring wstr{utf8_to_wstr(str)};
-    fputws(wstr.c_str(), logfile);
-    fflush(logfile);
-}
-
-
-static inline int is_slash(int c)
-{ return (c == '\\' || c == '/'); }
-
-static void DirectorySearch(const char *path, const char *ext, al::vector<std::string> *const results)
-{
-    std::string pathstr{path};
-    pathstr += "\\*";
-    pathstr += ext;
-    TRACE("Searching %s\n", pathstr.c_str());
-
-    std::wstring wpath{utf8_to_wstr(pathstr.c_str())};
-    WIN32_FIND_DATAW fdata;
-    HANDLE hdl{FindFirstFileW(wpath.c_str(), &fdata)};
-    if(hdl == INVALID_HANDLE_VALUE) return;
-
-    const auto base = results->size();
-
-    do {
-        results->emplace_back();
-        std::string &str = results->back();
-        str = path;
-        str += '\\';
-        str += wstr_to_utf8(fdata.cFileName);
-    } while(FindNextFileW(hdl, &fdata));
-    FindClose(hdl);
-
-    const al::span<std::string> newlist{results->data()+base, results->size()-base};
-    std::sort(newlist.begin(), newlist.end());
-    for(const auto &name : newlist)
-        TRACE(" got %s\n", name.c_str());
-}
-
-al::vector<std::string> SearchDataFiles(const char *ext, const char *subdir)
-{
-    static std::mutex search_lock;
-    std::lock_guard<std::mutex> _{search_lock};
-
-    /* If the path is absolute, use it directly. */
-    al::vector<std::string> results;
-    if(isalpha(subdir[0]) && subdir[1] == ':' && is_slash(subdir[2]))
-    {
-        std::string path{subdir};
-        std::replace(path.begin(), path.end(), '/', '\\');
-        DirectorySearch(path.c_str(), ext, &results);
-        return results;
-    }
-    if(subdir[0] == '\\' && subdir[1] == '\\' && subdir[2] == '?' && subdir[3] == '\\')
-    {
-        DirectorySearch(subdir, ext, &results);
-        return results;
-    }
-
-    std::string path;
-
-    /* Search the app-local directory. */
-    if(auto localpath = al::getenv(L"ALSOFT_LOCAL_PATH"))
-    {
-        path = wstr_to_utf8(localpath->c_str());
-        if(is_slash(path.back()))
-            path.pop_back();
-    }
-    else if(WCHAR *cwdbuf{_wgetcwd(nullptr, 0)})
-    {
-        path = wstr_to_utf8(cwdbuf);
-        if(is_slash(path.back()))
-            path.pop_back();
-        free(cwdbuf);
-    }
-    else
-        path = ".";
-    std::replace(path.begin(), path.end(), '/', '\\');
-    DirectorySearch(path.c_str(), ext, &results);
-
-    /* Search the local and global data dirs. */
-    static const int ids[2]{ CSIDL_APPDATA, CSIDL_COMMON_APPDATA };
-    for(int id : ids)
-    {
-        WCHAR buffer[MAX_PATH];
-        if(SHGetSpecialFolderPathW(nullptr, buffer, id, FALSE) == FALSE)
-            continue;
-
-        path = wstr_to_utf8(buffer);
-        if(!is_slash(path.back()))
-            path += '\\';
-        path += subdir;
-        std::replace(path.begin(), path.end(), '/', '\\');
-
-        DirectorySearch(path.c_str(), ext, &results);
-    }
-
-    return results;
-}
-
-void SetRTPriority(void)
-{
-    bool failed = false;
-    if(RTPrioLevel > 0)
-        failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
-    if(failed) ERR("Failed to set priority level for thread\n");
-}
-
-#else
-
-#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
-#include <pthread.h>
-#include <sched.h>
-#endif
-
-const PathNamePair &GetProcBinary()
-{
-    static PathNamePair ret;
-    if(!ret.fname.empty() || !ret.path.empty())
-        return ret;
-
-    al::vector<char> pathname;
-#ifdef __FreeBSD__
-    size_t pathlen;
-    int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
-    if(sysctl(mib, 4, nullptr, &pathlen, nullptr, 0) == -1)
-        WARN("Failed to sysctl kern.proc.pathname: %s\n", strerror(errno));
-    else
-    {
-        pathname.resize(pathlen + 1);
-        sysctl(mib, 4, pathname.data(), &pathlen, nullptr, 0);
-        pathname.resize(pathlen);
-    }
-#endif
-#ifdef HAVE_PROC_PIDPATH
-    if(pathname.empty())
-    {
-        char procpath[PROC_PIDPATHINFO_MAXSIZE]{};
-        const pid_t pid{getpid()};
-        if(proc_pidpath(pid, procpath, sizeof(procpath)) < 1)
-            ERR("proc_pidpath(%d, ...) failed: %s\n", pid, strerror(errno));
-        else
-            pathname.insert(pathname.end(), procpath, procpath+strlen(procpath));
-    }
-#endif
-    if(pathname.empty())
-    {
-        pathname.resize(256);
-
-        const char *selfname{"/proc/self/exe"};
-        ssize_t len{readlink(selfname, pathname.data(), pathname.size())};
-        if(len == -1 && errno == ENOENT)
-        {
-            selfname = "/proc/self/file";
-            len = readlink(selfname, pathname.data(), pathname.size());
-        }
-        if(len == -1 && errno == ENOENT)
-        {
-            selfname = "/proc/curproc/exe";
-            len = readlink(selfname, pathname.data(), pathname.size());
-        }
-        if(len == -1 && errno == ENOENT)
-        {
-            selfname = "/proc/curproc/file";
-            len = readlink(selfname, pathname.data(), pathname.size());
-        }
-
-        while(len > 0 && static_cast<size_t>(len) == pathname.size())
-        {
-            pathname.resize(pathname.size() << 1);
-            len = readlink(selfname, pathname.data(), pathname.size());
-        }
-        if(len <= 0)
-        {
-            WARN("Failed to readlink %s: %s\n", selfname, strerror(errno));
-            return ret;
-        }
-
-        pathname.resize(static_cast<size_t>(len));
-    }
-    while(!pathname.empty() && pathname.back() == 0)
-        pathname.pop_back();
-
-    auto sep = std::find(pathname.crbegin(), pathname.crend(), '/');
-    if(sep != pathname.crend())
-    {
-        ret.path = std::string(pathname.cbegin(), sep.base()-1);
-        ret.fname = std::string(sep.base(), pathname.cend());
-    }
-    else
-        ret.fname = std::string(pathname.cbegin(), pathname.cend());
-
-    TRACE("Got binary: %s, %s\n", ret.path.c_str(), ret.fname.c_str());
-    return ret;
-}
-
-
-void al_print(FILE *logfile, const char *fmt, ...)
-{
-    va_list ap;
-
-    va_start(ap, fmt);
-    vfprintf(logfile, fmt, ap);
-    va_end(ap);
-
-    fflush(logfile);
-}
-
-
-static void DirectorySearch(const char *path, const char *ext, al::vector<std::string> *const results)
-{
-    TRACE("Searching %s for *%s\n", path, ext);
-    DIR *dir{opendir(path)};
-    if(!dir) return;
-
-    const auto base = results->size();
-    const size_t extlen{strlen(ext)};
-
-    struct dirent *dirent;
-    while((dirent=readdir(dir)) != nullptr)
-    {
-        if(strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0)
-            continue;
-
-        const size_t len{strlen(dirent->d_name)};
-        if(len <= extlen) continue;
-        if(al::strcasecmp(dirent->d_name+len-extlen, ext) != 0)
-            continue;
-
-        results->emplace_back();
-        std::string &str = results->back();
-        str = path;
-        if(str.back() != '/')
-            str.push_back('/');
-        str += dirent->d_name;
-    }
-    closedir(dir);
-
-    const al::span<std::string> newlist{results->data()+base, results->size()-base};
-    std::sort(newlist.begin(), newlist.end());
-    for(const auto &name : newlist)
-        TRACE(" got %s\n", name.c_str());
-}
-
-al::vector<std::string> SearchDataFiles(const char *ext, const char *subdir)
-{
-    static std::mutex search_lock;
-    std::lock_guard<std::mutex> _{search_lock};
-
-    al::vector<std::string> results;
-    if(subdir[0] == '/')
-    {
-        DirectorySearch(subdir, ext, &results);
-        return results;
-    }
-
-    /* Search the app-local directory. */
-    if(auto localpath = al::getenv("ALSOFT_LOCAL_PATH"))
-        DirectorySearch(localpath->c_str(), ext, &results);
-    else
-    {
-        al::vector<char> cwdbuf(256);
-        while(!getcwd(cwdbuf.data(), cwdbuf.size()))
-        {
-            if(errno != ERANGE)
-            {
-                cwdbuf.clear();
-                break;
-            }
-            cwdbuf.resize(cwdbuf.size() << 1);
-        }
-        if(cwdbuf.empty())
-            DirectorySearch(".", ext, &results);
-        else
-        {
-            DirectorySearch(cwdbuf.data(), ext, &results);
-            cwdbuf.clear();
-        }
-    }
-
-    // Search local data dir
-    if(auto datapath = al::getenv("XDG_DATA_HOME"))
-    {
-        std::string &path = *datapath;
-        if(path.back() != '/')
-            path += '/';
-        path += subdir;
-        DirectorySearch(path.c_str(), ext, &results);
-    }
-    else if(auto homepath = al::getenv("HOME"))
-    {
-        std::string &path = *homepath;
-        if(path.back() == '/')
-            path.pop_back();
-        path += "/.local/share/";
-        path += subdir;
-        DirectorySearch(path.c_str(), ext, &results);
-    }
-
-    // Search global data dirs
-    std::string datadirs{al::getenv("XDG_DATA_DIRS").value_or("/usr/local/share/:/usr/share/")};
-
-    size_t curpos{0u};
-    while(curpos < datadirs.size())
-    {
-        size_t nextpos{datadirs.find(':', curpos)};
-
-        std::string path{(nextpos != std::string::npos) ?
-            datadirs.substr(curpos, nextpos++ - curpos) : datadirs.substr(curpos)};
-        curpos = nextpos;
-
-        if(path.empty()) continue;
-        if(path.back() != '/')
-            path += '/';
-        path += subdir;
-
-        DirectorySearch(path.c_str(), ext, &results);
-    }
-
-    return results;
-}
-
-void SetRTPriority()
-{
-    bool failed = false;
-#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
-    if(RTPrioLevel > 0)
-    {
-        struct sched_param param;
-        /* Use the minimum real-time priority possible for now (on Linux this
-         * should be 1 for SCHED_RR) */
-        param.sched_priority = sched_get_priority_min(SCHED_RR);
-        failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
-    }
-#else
-    /* Real-time priority not available */
-    failed = (RTPrioLevel>0);
-#endif
-    if(failed)
-        ERR("Failed to set priority level for thread\n");
-}
-
-#endif
diff --git a/alc/hrtf.cpp b/alc/hrtf.cpp
deleted file mode 100644
index 8e416cf1..00000000
--- a/alc/hrtf.cpp
+++ /dev/null
@@ -1,1424 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2011 by Chris Robinson
- * 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 "hrtf.h"
-
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cctype>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <fstream>
-#include <iterator>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <numeric>
-#include <type_traits>
-#include <utility>
-
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "alconfig.h"
-#include "alfstream.h"
-#include "almalloc.h"
-#include "alnumeric.h"
-#include "aloptional.h"
-#include "alspan.h"
-#include "filters/splitter.h"
-#include "logging.h"
-#include "math_defs.h"
-#include "opthelpers.h"
-
-
-struct HrtfHandle {
-    std::unique_ptr<HrtfEntry> mEntry;
-    al::FlexArray<char> mFilename;
-
-    HrtfHandle(size_t fname_len) : mFilename{fname_len} { }
-
-    static std::unique_ptr<HrtfHandle> Create(size_t fname_len)
-    { return std::unique_ptr<HrtfHandle>{new (FamCount{fname_len}) HrtfHandle{fname_len}}; }
-
-    DEF_FAM_NEWDEL(HrtfHandle, mFilename)
-};
-
-namespace {
-
-using namespace std::placeholders;
-
-using HrtfHandlePtr = std::unique_ptr<HrtfHandle>;
-
-/* Data set limits must be the same as or more flexible than those defined in
- * the makemhr utility.
- */
-#define MIN_IR_SIZE                  (8)
-#define MAX_IR_SIZE                  (512)
-#define MOD_IR_SIZE                  (2)
-
-#define MIN_FD_COUNT                 (1)
-#define MAX_FD_COUNT                 (16)
-
-#define MIN_FD_DISTANCE              (50)
-#define MAX_FD_DISTANCE              (2500)
-
-#define MIN_EV_COUNT                 (5)
-#define MAX_EV_COUNT                 (181)
-
-#define MIN_AZ_COUNT                 (1)
-#define MAX_AZ_COUNT                 (255)
-
-#define MAX_HRIR_DELAY               (HRTF_HISTORY_LENGTH-1)
-
-constexpr ALchar magicMarker00[8]{'M','i','n','P','H','R','0','0'};
-constexpr ALchar magicMarker01[8]{'M','i','n','P','H','R','0','1'};
-constexpr ALchar magicMarker02[8]{'M','i','n','P','H','R','0','2'};
-
-/* First value for pass-through coefficients (remaining are 0), used for omni-
- * directional sounds. */
-constexpr ALfloat PassthruCoeff{0.707106781187f/*sqrt(0.5)*/};
-
-std::mutex LoadedHrtfLock;
-al::vector<HrtfHandlePtr> LoadedHrtfs;
-
-
-class databuf final : public std::streambuf {
-    int_type underflow() override
-    { return traits_type::eof(); }
-
-    pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) override
-    {
-        if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
-            return traits_type::eof();
-
-        char_type *cur;
-        switch(whence)
-        {
-            case std::ios_base::beg:
-                if(offset < 0 || offset > egptr()-eback())
-                    return traits_type::eof();
-                cur = eback() + offset;
-                break;
-
-            case std::ios_base::cur:
-                if((offset >= 0 && offset > egptr()-gptr()) ||
-                   (offset < 0 && -offset > gptr()-eback()))
-                    return traits_type::eof();
-                cur = gptr() + offset;
-                break;
-
-            case std::ios_base::end:
-                if(offset > 0 || -offset > egptr()-eback())
-                    return traits_type::eof();
-                cur = egptr() + offset;
-                break;
-
-            default:
-                return traits_type::eof();
-        }
-
-        setg(eback(), cur, egptr());
-        return cur - eback();
-    }
-
-    pos_type seekpos(pos_type pos, std::ios_base::openmode mode) override
-    {
-        // Simplified version of seekoff
-        if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
-            return traits_type::eof();
-
-        if(pos < 0 || pos > egptr()-eback())
-            return traits_type::eof();
-
-        setg(eback(), eback() + static_cast<size_t>(pos), egptr());
-        return pos;
-    }
-
-public:
-    databuf(const char_type *start_, const char_type *end_) noexcept
-    {
-        setg(const_cast<char_type*>(start_), const_cast<char_type*>(start_),
-             const_cast<char_type*>(end_));
-    }
-};
-
-class idstream final : public std::istream {
-    databuf mStreamBuf;
-
-public:
-    idstream(const char *start_, const char *end_)
-      : std::istream{nullptr}, mStreamBuf{start_, end_}
-    { init(&mStreamBuf); }
-};
-
-
-struct IdxBlend { ALsizei idx; ALfloat blend; };
-/* Calculate the elevation index given the polar elevation in radians. This
- * will return an index between 0 and (evcount - 1).
- */
-IdxBlend CalcEvIndex(ALsizei evcount, ALfloat ev)
-{
-    ev = (al::MathDefs<float>::Pi()*0.5f + ev) * static_cast<float>(evcount-1) /
-        al::MathDefs<float>::Pi();
-    ALsizei idx{float2int(ev)};
-
-    return IdxBlend{mini(idx, evcount-1), ev-static_cast<float>(idx)};
-}
-
-/* Calculate the azimuth index given the polar azimuth in radians. This will
- * return an index between 0 and (azcount - 1).
- */
-IdxBlend CalcAzIndex(ALsizei azcount, ALfloat az)
-{
-    az = (al::MathDefs<float>::Tau()+az) * static_cast<float>(azcount) /
-        al::MathDefs<float>::Tau();
-    ALsizei idx{float2int(az)};
-
-    return IdxBlend{idx%azcount, az-static_cast<float>(idx)};
-}
-
-} // namespace
-
-
-/* Calculates static HRIR coefficients and delays for the given polar elevation
- * and azimuth in radians. The coefficients are normalized.
- */
-void GetHrtfCoeffs(const HrtfEntry *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat distance,
-    ALfloat spread, HrirArray &coeffs, ALsizei (&delays)[2])
-{
-    const ALfloat dirfact{1.0f - (spread / al::MathDefs<float>::Tau())};
-
-    const auto *field = Hrtf->field;
-    const auto *field_end = field + Hrtf->fdCount-1;
-    ALsizei ebase{0};
-    while(distance < field->distance && field != field_end)
-    {
-        ebase += field->evCount;
-        ++field;
-    }
-
-    /* Claculate the elevation indinces. */
-    const auto elev0 = CalcEvIndex(field->evCount, elevation);
-    const ALsizei elev1_idx{mini(elev0.idx+1, field->evCount-1)};
-    const ALsizei ir0offset{Hrtf->elev[ebase + elev0.idx].irOffset};
-    const ALsizei ir1offset{Hrtf->elev[ebase + elev1_idx].irOffset};
-
-    /* Calculate azimuth indices. */
-    const auto az0 = CalcAzIndex(Hrtf->elev[ebase + elev0.idx].azCount, azimuth);
-    const auto az1 = CalcAzIndex(Hrtf->elev[ebase + elev1_idx].azCount, azimuth);
-
-    /* Calculate the HRIR indices to blend. */
-    ALsizei idx[4]{
-        ir0offset + az0.idx,
-        ir0offset + ((az0.idx+1) % Hrtf->elev[ebase + elev0.idx].azCount),
-        ir1offset + az1.idx,
-        ir1offset + ((az1.idx+1) % Hrtf->elev[ebase + elev1_idx].azCount)
-    };
-
-    /* Calculate bilinear blending weights, attenuated according to the
-     * directional panning factor.
-     */
-    const ALfloat blend[4]{
-        (1.0f-elev0.blend) * (1.0f-az0.blend) * dirfact,
-        (1.0f-elev0.blend) * (     az0.blend) * dirfact,
-        (     elev0.blend) * (1.0f-az1.blend) * dirfact,
-        (     elev0.blend) * (     az1.blend) * dirfact
-    };
-
-    /* Calculate the blended HRIR delays. */
-    delays[0] = fastf2i(
-        Hrtf->delays[idx[0]][0]*blend[0] + Hrtf->delays[idx[1]][0]*blend[1] +
-        Hrtf->delays[idx[2]][0]*blend[2] + Hrtf->delays[idx[3]][0]*blend[3]
-    );
-    delays[1] = fastf2i(
-        Hrtf->delays[idx[0]][1]*blend[0] + Hrtf->delays[idx[1]][1]*blend[1] +
-        Hrtf->delays[idx[2]][1]*blend[2] + Hrtf->delays[idx[3]][1]*blend[3]
-    );
-
-    const ALuint irSize{Hrtf->irSize};
-    ASSUME(irSize >= MIN_IR_SIZE);
-
-    /* Calculate the sample offsets for the HRIR indices. */
-    idx[0] *= HRIR_LENGTH;
-    idx[1] *= HRIR_LENGTH;
-    idx[2] *= HRIR_LENGTH;
-    idx[3] *= HRIR_LENGTH;
-
-    /* Calculate the blended HRIR coefficients. */
-    ALfloat *coeffout{al::assume_aligned<16>(&coeffs[0][0])};
-    coeffout[0] = PassthruCoeff * (1.0f-dirfact);
-    coeffout[1] = PassthruCoeff * (1.0f-dirfact);
-    std::fill(coeffout+2, coeffout + HRIR_LENGTH*2, 0.0f);
-    for(ALsizei c{0};c < 4;c++)
-    {
-        const ALfloat *srccoeffs{al::assume_aligned<16>(Hrtf->coeffs[idx[c]])};
-        const ALfloat mult{blend[c]};
-        auto blend_coeffs = [mult](const ALfloat src, const ALfloat coeff) noexcept -> ALfloat
-        { return src*mult + coeff; };
-        std::transform(srccoeffs, srccoeffs + irSize*2, coeffout, coeffout, blend_coeffs);
-    }
-}
-
-
-std::unique_ptr<DirectHrtfState> DirectHrtfState::Create(size_t num_chans)
-{
-    return std::unique_ptr<DirectHrtfState>{new (FamCount{num_chans}) DirectHrtfState{num_chans}};
-}
-
-void BuildBFormatHrtf(const HrtfEntry *Hrtf, DirectHrtfState *state,
-    const al::span<const AngularPoint> AmbiPoints, const ALfloat (*AmbiMatrix)[MAX_AMBI_CHANNELS],
-    const ALfloat *AmbiOrderHFGain)
-{
-    using double2 = std::array<double,2>;
-    struct ImpulseResponse {
-        alignas(16) std::array<double2,HRIR_LENGTH> hrir;
-        ALuint ldelay, rdelay;
-    };
-
-    static const int OrderFromChan[MAX_AMBI_CHANNELS]{
-        0, 1,1,1, 2,2,2,2,2, 3,3,3,3,3,3,3,
-    };
-    /* Set this to true for dual-band HRTF processing. May require better
-     * calculation of the new IR length to deal with the head and tail
-     * generated by the HF scaling.
-     */
-    static constexpr bool DualBand{true};
-
-    ALuint min_delay{HRTF_HISTORY_LENGTH};
-    ALuint max_delay{0};
-    al::vector<ImpulseResponse> impres; impres.reserve(AmbiPoints.size());
-    auto calc_res = [Hrtf,&max_delay,&min_delay](const AngularPoint &pt) -> ImpulseResponse
-    {
-        ImpulseResponse res;
-
-        auto &field = Hrtf->field[0];
-
-        /* Calculate the elevation indices. */
-        const auto elev0 = CalcEvIndex(field.evCount, pt.Elev.value);
-        const ALsizei elev1_idx{mini(elev0.idx+1, field.evCount-1)};
-        const ALsizei ir0offset{Hrtf->elev[elev0.idx].irOffset};
-        const ALsizei ir1offset{Hrtf->elev[elev1_idx].irOffset};
-
-        /* Calculate azimuth indices. */
-        const auto az0 = CalcAzIndex(Hrtf->elev[elev0.idx].azCount, pt.Azim.value);
-        const auto az1 = CalcAzIndex(Hrtf->elev[elev1_idx].azCount, pt.Azim.value);
-
-        /* Calculate the HRIR indices to blend. */
-        const ALuint idx[4]{
-            static_cast<ALuint>(ir0offset + az0.idx),
-            static_cast<ALuint>(ir0offset + ((az0.idx+1) % Hrtf->elev[elev0.idx].azCount)),
-            static_cast<ALuint>(ir1offset + az1.idx),
-            static_cast<ALuint>(ir1offset + ((az1.idx+1) % Hrtf->elev[elev1_idx].azCount))};
-
-        /* Calculate bilinear blending weights. */
-        const ALfloat blend[4]{
-            (1.0f-elev0.blend) * (1.0f-az0.blend),
-            (1.0f-elev0.blend) * (     az0.blend),
-            (     elev0.blend) * (1.0f-az1.blend),
-            (     elev0.blend) * (     az1.blend)};
-
-        /* Calculate the blended HRIR delays. */
-        res.ldelay = fastf2u(
-            Hrtf->delays[idx[0]][0]*blend[0] + Hrtf->delays[idx[1]][0]*blend[1] +
-            Hrtf->delays[idx[2]][0]*blend[2] + Hrtf->delays[idx[3]][0]*blend[3]);
-        res.rdelay = fastf2u(
-            Hrtf->delays[idx[0]][1]*blend[0] + Hrtf->delays[idx[1]][1]*blend[1] +
-            Hrtf->delays[idx[2]][1]*blend[2] + Hrtf->delays[idx[3]][1]*blend[3]);
-
-        const size_t irSize{Hrtf->irSize};
-        ASSUME(irSize >= MIN_IR_SIZE);
-
-        /* Calculate the blended HRIR coefficients. */
-        double *coeffout{al::assume_aligned<16>(&res.hrir[0][0])};
-        std::fill(coeffout, coeffout + HRIR_LENGTH*2, 0.0);
-        for(ALsizei c{0};c < 4;c++)
-        {
-            const ALfloat *srccoeffs{al::assume_aligned<16>(Hrtf->coeffs[idx[c]*HRIR_LENGTH])};
-            const ALfloat mult{blend[c]};
-            auto blend_coeffs = [mult](const float src, const double coeff) noexcept -> double
-            { return src*mult + coeff; };
-            std::transform(srccoeffs, srccoeffs + HRIR_LENGTH*2, coeffout, coeffout, blend_coeffs);
-        }
-
-        min_delay = minu(min_delay, minu(res.ldelay, res.rdelay));
-        max_delay = maxu(max_delay, maxu(res.ldelay, res.rdelay));
-
-        return res;
-    };
-    std::transform(AmbiPoints.begin(), AmbiPoints.end(), std::back_inserter(impres), calc_res);
-
-    /* For dual-band processing, add a 16-sample delay to compensate for the HF
-     * scale on the minimum-phase response.
-     */
-    static constexpr ALsizei base_delay{DualBand ? 16 : 0};
-    const ALdouble xover_norm{400.0 / Hrtf->sampleRate};
-    BandSplitterR<double> splitter{xover_norm};
-
-    auto tmpres = al::vector<std::array<double2,HRIR_LENGTH>>(state->Coeffs.size());
-    auto tmpflt = al::vector<std::array<double,HRIR_LENGTH*4>>(3);
-    for(size_t c{0u};c < AmbiPoints.size();++c)
-    {
-        const al::span<const double2,HRIR_LENGTH> hrir{impres[c].hrir};
-        const ALuint ldelay{impres[c].ldelay - min_delay + base_delay};
-        const ALuint rdelay{impres[c].rdelay - min_delay + base_delay};
-
-        if /*constexpr*/(!DualBand)
-        {
-            /* For single-band decoding, apply the HF scale to the response. */
-            for(size_t i{0u};i < state->Coeffs.size();++i)
-            {
-                const double mult{double{AmbiOrderHFGain[OrderFromChan[i]]} * AmbiMatrix[c][i]};
-                const ALuint numirs{HRIR_LENGTH - maxu(ldelay, rdelay)};
-                ALuint lidx{ldelay}, ridx{rdelay};
-                for(ALuint j{0};j < numirs;++j)
-                {
-                    tmpres[i][lidx++][0] += hrir[j][0] * mult;
-                    tmpres[i][ridx++][1] += hrir[j][1] * mult;
-                }
-            }
-            continue;
-        }
-
-        /* For dual-band processing, the HRIR needs to be split into low and
-         * high frequency responses. The band-splitter alone creates frequency-
-         * dependent phase-shifts, which is not ideal. To counteract it,
-         * combine it with a backwards phase-shift.
-         */
-
-        /* Load the (left) HRIR backwards, into a temp buffer with padding. */
-        std::fill(tmpflt[2].begin(), tmpflt[2].end(), 0.0);
-        std::transform(hrir.cbegin(), hrir.cend(), tmpflt[2].rbegin() + HRIR_LENGTH*3,
-            [](const double2 &ir) noexcept -> double { return ir[0]; });
-
-        /* Apply the all-pass on the reversed signal and reverse the resulting
-         * sample array. This produces the forward response with a backwards
-         * phase-shift (+n degrees becomes -n degrees).
-         */
-        splitter.applyAllpass(tmpflt[2].data(), tmpflt[2].size());
-        std::reverse(tmpflt[2].begin(), tmpflt[2].end());
-
-        /* Now apply the band-splitter. This applies the normal phase-shift,
-         * which cancels out with the backwards phase-shift to get the original
-         * phase on the split signal.
-         */
-        splitter.clear();
-        splitter.process(tmpflt[0].data(), tmpflt[1].data(), tmpflt[2].data(), tmpflt[2].size());
-
-        /* Apply left ear response with delay and HF scale. */
-        for(size_t i{0u};i < state->Coeffs.size();++i)
-        {
-            const ALdouble mult{AmbiMatrix[c][i]};
-            const ALdouble hfgain{AmbiOrderHFGain[OrderFromChan[i]]};
-            ALuint j{HRIR_LENGTH*3 - ldelay};
-            for(ALuint lidx{0};lidx < HRIR_LENGTH;++lidx,++j)
-                tmpres[i][lidx][0] += (tmpflt[0][j]*hfgain + tmpflt[1][j]) * mult;
-        }
-
-        /* Now run the same process on the right HRIR. */
-        std::fill(tmpflt[2].begin(), tmpflt[2].end(), 0.0);
-        std::transform(hrir.cbegin(), hrir.cend(), tmpflt[2].rbegin() + HRIR_LENGTH*3,
-            [](const double2 &ir) noexcept -> double { return ir[1]; });
-
-        splitter.applyAllpass(tmpflt[2].data(), tmpflt[2].size());
-        std::reverse(tmpflt[2].begin(), tmpflt[2].end());
-
-        splitter.clear();
-        splitter.process(tmpflt[0].data(), tmpflt[1].data(), tmpflt[2].data(), tmpflt[2].size());
-
-        for(size_t i{0u};i < state->Coeffs.size();++i)
-        {
-            const ALdouble mult{AmbiMatrix[c][i]};
-            const ALdouble hfgain{AmbiOrderHFGain[OrderFromChan[i]]};
-            ALuint j{HRIR_LENGTH*3 - rdelay};
-            for(ALuint ridx{0};ridx < HRIR_LENGTH;++ridx,++j)
-                tmpres[i][ridx][1] += (tmpflt[0][j]*hfgain + tmpflt[1][j]) * mult;
-        }
-    }
-    tmpflt.clear();
-    impres.clear();
-
-    for(size_t i{0u};i < state->Coeffs.size();++i)
-    {
-        auto copy_arr = [](const double2 &in) noexcept -> float2
-        { return float2{{static_cast<float>(in[0]), static_cast<float>(in[1])}}; };
-        std::transform(tmpres[i].cbegin(), tmpres[i].cend(), state->Coeffs[i].begin(),
-            copy_arr);
-    }
-    tmpres.clear();
-
-    ALuint max_length{HRIR_LENGTH};
-    /* Increase the IR size by double the base delay with dual-band processing
-     * to account for the head and tail from the HF response scale.
-     */
-    const ALuint irsize{minu(Hrtf->irSize + base_delay*2, max_length)};
-    max_length = minu(max_delay-min_delay + irsize, max_length);
-
-    /* Round up to the next IR size multiple. */
-    max_length += MOD_IR_SIZE-1;
-    max_length -= max_length%MOD_IR_SIZE;
-
-    TRACE("Skipped delay: %u, max delay: %u, new FIR length: %u\n", min_delay, max_delay-min_delay,
-        max_length);
-    state->IrSize = max_length;
-}
-
-
-namespace {
-
-std::unique_ptr<HrtfEntry> CreateHrtfStore(ALuint rate, ALushort irSize, const ALuint fdCount,
-    const ALubyte *evCount, const ALushort *distance, const ALushort *azCount,
-    const ALushort *irOffset, ALushort irCount, const ALfloat (*coeffs)[2],
-    const ALubyte (*delays)[2], const char *filename)
-{
-    std::unique_ptr<HrtfEntry> Hrtf;
-
-    ALuint evTotal{std::accumulate(evCount, evCount+fdCount, 0u)};
-    size_t total{sizeof(HrtfEntry)};
-    total  = RoundUp(total, alignof(HrtfEntry::Field)); /* Align for field infos */
-    total += sizeof(HrtfEntry::Field)*fdCount;
-    total  = RoundUp(total, alignof(HrtfEntry::Elevation)); /* Align for elevation infos */
-    total += sizeof(Hrtf->elev[0])*evTotal;
-    total  = RoundUp(total, 16); /* Align for coefficients using SIMD */
-    total += sizeof(Hrtf->coeffs[0])*HRIR_LENGTH*irCount;
-    total += sizeof(Hrtf->delays[0])*irCount;
-
-    Hrtf.reset(new (al_calloc(16, total)) HrtfEntry{});
-    if(!Hrtf)
-        ERR("Out of memory allocating storage for %s.\n", filename);
-    else
-    {
-        InitRef(Hrtf->mRef, 1u);
-        Hrtf->sampleRate = rate;
-        Hrtf->irSize = irSize;
-        Hrtf->fdCount = fdCount;
-
-        /* Set up pointers to storage following the main HRTF struct. */
-        char *base = reinterpret_cast<char*>(Hrtf.get());
-        uintptr_t offset = sizeof(HrtfEntry);
-
-        offset = RoundUp(offset, alignof(HrtfEntry::Field)); /* Align for field infos */
-        auto field_ = reinterpret_cast<HrtfEntry::Field*>(base + offset);
-        offset += sizeof(field_[0])*fdCount;
-
-        offset = RoundUp(offset, alignof(HrtfEntry::Elevation)); /* Align for elevation infos */
-        auto elev_ = reinterpret_cast<HrtfEntry::Elevation*>(base + offset);
-        offset += sizeof(elev_[0])*evTotal;
-
-        offset = RoundUp(offset, 16); /* Align for coefficients using SIMD */
-        auto coeffs_ = reinterpret_cast<ALfloat(*)[2]>(base + offset);
-        offset += sizeof(coeffs_[0])*HRIR_LENGTH*irCount;
-
-        auto delays_ = reinterpret_cast<ALubyte(*)[2]>(base + offset);
-        offset += sizeof(delays_[0])*irCount;
-
-        assert(offset == total);
-
-        /* Copy input data to storage. */
-        for(ALuint i{0};i < fdCount;i++)
-        {
-            field_[i].distance = distance[i] / 1000.0f;
-            field_[i].evCount = evCount[i];
-        }
-        for(ALuint i{0};i < evTotal;i++)
-        {
-            elev_[i].azCount = azCount[i];
-            elev_[i].irOffset = irOffset[i];
-        }
-        for(ALuint i{0};i < irCount;i++)
-        {
-            for(ALuint j{0};j < ALuint{irSize};j++)
-            {
-                coeffs_[i*HRIR_LENGTH + j][0] = coeffs[i*irSize + j][0];
-                coeffs_[i*HRIR_LENGTH + j][1] = coeffs[i*irSize + j][1];
-            }
-            for(ALuint j{irSize};j < HRIR_LENGTH;j++)
-            {
-                coeffs_[i*HRIR_LENGTH + j][0] = 0.0f;
-                coeffs_[i*HRIR_LENGTH + j][1] = 0.0f;
-            }
-        }
-        for(ALuint i{0};i < irCount;i++)
-        {
-            delays_[i][0] = delays[i][0];
-            delays_[i][1] = delays[i][1];
-        }
-
-        /* Finally, assign the storage pointers. */
-        Hrtf->field = field_;
-        Hrtf->elev = elev_;
-        Hrtf->coeffs = coeffs_;
-        Hrtf->delays = delays_;
-    }
-
-    return Hrtf;
-}
-
-ALubyte GetLE_ALubyte(std::istream &data)
-{
-    return static_cast<ALubyte>(data.get());
-}
-
-ALshort GetLE_ALshort(std::istream &data)
-{
-    int ret = data.get();
-    ret |= data.get() << 8;
-    return static_cast<ALshort>((ret^32768) - 32768);
-}
-
-ALushort GetLE_ALushort(std::istream &data)
-{
-    int ret = data.get();
-    ret |= data.get() << 8;
-    return static_cast<ALushort>(ret);
-}
-
-ALint GetLE_ALint24(std::istream &data)
-{
-    int ret = data.get();
-    ret |= data.get() << 8;
-    ret |= data.get() << 16;
-    return (ret^8388608) - 8388608;
-}
-
-ALuint GetLE_ALuint(std::istream &data)
-{
-    int ret = data.get();
-    ret |= data.get() << 8;
-    ret |= data.get() << 16;
-    ret |= data.get() << 24;
-    return static_cast<ALuint>(ret);
-}
-
-std::unique_ptr<HrtfEntry> LoadHrtf00(std::istream &data, const char *filename)
-{
-    ALuint rate{GetLE_ALuint(data)};
-    ALushort irCount{GetLE_ALushort(data)};
-    ALushort irSize{GetLE_ALushort(data)};
-    ALubyte evCount{GetLE_ALubyte(data)};
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-
-    ALboolean failed{AL_FALSE};
-    if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
-    {
-        ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
-            irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
-        failed = AL_TRUE;
-    }
-    if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
-    {
-        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
-            evCount, MIN_EV_COUNT, MAX_EV_COUNT);
-        failed = AL_TRUE;
-    }
-    if(failed)
-        return nullptr;
-
-    auto evOffset = al::vector<ALushort>(evCount);
-    for(auto &val : evOffset)
-        val = GetLE_ALushort(data);
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-    for(size_t i{1};i < evCount;i++)
-    {
-        if(evOffset[i] <= evOffset[i-1])
-        {
-            ERR("Invalid evOffset: evOffset[%zu]=%d (last=%d)\n", i, evOffset[i], evOffset[i-1]);
-            failed = AL_TRUE;
-        }
-    }
-    if(irCount <= evOffset.back())
-    {
-        ERR("Invalid evOffset: evOffset[%zu]=%d (irCount=%d)\n",
-            evOffset.size()-1, evOffset.back(), irCount);
-        failed = AL_TRUE;
-    }
-    if(failed)
-        return nullptr;
-
-    auto azCount = al::vector<ALushort>(evCount);
-    for(size_t i{1};i < evCount;i++)
-    {
-        azCount[i-1] = static_cast<ALushort>(evOffset[i] - evOffset[i-1]);
-        if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
-        {
-            ERR("Unsupported azimuth count: azCount[%zd]=%d (%d to %d)\n",
-                i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
-            failed = AL_TRUE;
-        }
-    }
-    azCount.back() = static_cast<ALushort>(irCount - evOffset.back());
-    if(azCount.back() < MIN_AZ_COUNT || azCount.back() > MAX_AZ_COUNT)
-    {
-        ERR("Unsupported azimuth count: azCount[%zu]=%d (%d to %d)\n",
-            azCount.size()-1, azCount.back(), MIN_AZ_COUNT, MAX_AZ_COUNT);
-        failed = AL_TRUE;
-    }
-    if(failed)
-        return nullptr;
-
-    auto coeffs = al::vector<std::array<ALfloat,2>>(irSize*irCount);
-    auto delays = al::vector<std::array<ALubyte,2>>(irCount);
-    for(auto &val : coeffs)
-        val[0] = GetLE_ALshort(data) / 32768.0f;
-    for(auto &val : delays)
-        val[0] = GetLE_ALubyte(data);
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-    for(size_t i{0};i < irCount;i++)
-    {
-        if(delays[i][0] > MAX_HRIR_DELAY)
-        {
-            ERR("Invalid delays[%zd]: %d (%d)\n", i, delays[i][0], MAX_HRIR_DELAY);
-            failed = AL_TRUE;
-        }
-    }
-    if(failed)
-        return nullptr;
-
-    /* Mirror the left ear responses to the right ear. */
-    for(size_t i{0};i < evCount;i++)
-    {
-        const ALushort evoffset{evOffset[i]};
-        const ALushort azcount{azCount[i]};
-        for(size_t j{0};j < azcount;j++)
-        {
-            const size_t lidx{evoffset + j};
-            const size_t ridx{evoffset + ((azcount-j) % azcount)};
-
-            for(size_t k{0};k < irSize;k++)
-                coeffs[ridx*irSize + k][1] = coeffs[lidx*irSize + k][0];
-            delays[ridx][1] = delays[lidx][0];
-        }
-    }
-
-    static const ALushort distance{0};
-    return CreateHrtfStore(rate, irSize, 1, &evCount, &distance, azCount.data(), evOffset.data(),
-        irCount, &reinterpret_cast<ALfloat(&)[2]>(coeffs[0]),
-        &reinterpret_cast<ALubyte(&)[2]>(delays[0]), filename);
-}
-
-std::unique_ptr<HrtfEntry> LoadHrtf01(std::istream &data, const char *filename)
-{
-    ALuint rate{GetLE_ALuint(data)};
-    ALushort irSize{GetLE_ALubyte(data)};
-    ALubyte evCount{GetLE_ALubyte(data)};
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-
-    ALboolean failed{AL_FALSE};
-    if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
-    {
-        ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
-            irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
-        failed = AL_TRUE;
-    }
-    if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
-    {
-        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
-            evCount, MIN_EV_COUNT, MAX_EV_COUNT);
-        failed = AL_TRUE;
-    }
-    if(failed)
-        return nullptr;
-
-    auto azCount = al::vector<ALushort>(evCount);
-    std::generate(azCount.begin(), azCount.end(), std::bind(GetLE_ALubyte, std::ref(data)));
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-    for(size_t i{0};i < evCount;++i)
-    {
-        if(azCount[i] < MIN_AZ_COUNT || azCount[i] > MAX_AZ_COUNT)
-        {
-            ERR("Unsupported azimuth count: azCount[%zd]=%d (%d to %d)\n", i, azCount[i],
-                MIN_AZ_COUNT, MAX_AZ_COUNT);
-            failed = AL_TRUE;
-        }
-    }
-    if(failed)
-        return nullptr;
-
-    auto evOffset = al::vector<ALushort>(evCount);
-    evOffset[0] = 0;
-    ALushort irCount{azCount[0]};
-    for(size_t i{1};i < evCount;i++)
-    {
-        evOffset[i] = static_cast<ALushort>(evOffset[i-1] + azCount[i-1]);
-        irCount = static_cast<ALushort>(irCount + azCount[i]);
-    }
-
-    auto coeffs = al::vector<std::array<ALfloat,2>>(irSize*irCount);
-    auto delays = al::vector<std::array<ALubyte,2>>(irCount);
-    for(auto &val : coeffs)
-        val[0] = GetLE_ALshort(data) / 32768.0f;
-    for(auto &val : delays)
-        val[0] = GetLE_ALubyte(data);
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-    for(size_t i{0};i < irCount;i++)
-    {
-        if(delays[i][0] > MAX_HRIR_DELAY)
-        {
-            ERR("Invalid delays[%zd]: %d (%d)\n", i, delays[i][0], MAX_HRIR_DELAY);
-            failed = AL_TRUE;
-        }
-    }
-    if(failed)
-        return nullptr;
-
-    /* Mirror the left ear responses to the right ear. */
-    for(size_t i{0};i < evCount;i++)
-    {
-        const ALushort evoffset{evOffset[i]};
-        const ALushort azcount{azCount[i]};
-        for(size_t j{0};j < azcount;j++)
-        {
-            const size_t lidx{evoffset + j};
-            const size_t ridx{evoffset + ((azcount-j) % azcount)};
-
-            for(size_t k{0};k < irSize;k++)
-                coeffs[ridx*irSize + k][1] = coeffs[lidx*irSize + k][0];
-            delays[ridx][1] = delays[lidx][0];
-        }
-    }
-
-    static const ALushort distance{0};
-    return CreateHrtfStore(rate, irSize, 1, &evCount, &distance, azCount.data(), evOffset.data(),
-        irCount, &reinterpret_cast<ALfloat(&)[2]>(coeffs[0]),
-        &reinterpret_cast<ALubyte(&)[2]>(delays[0]), filename);
-}
-
-#define SAMPLETYPE_S16 0
-#define SAMPLETYPE_S24 1
-
-#define CHANTYPE_LEFTONLY  0
-#define CHANTYPE_LEFTRIGHT 1
-
-std::unique_ptr<HrtfEntry> LoadHrtf02(std::istream &data, const char *filename)
-{
-    ALuint rate{GetLE_ALuint(data)};
-    ALubyte sampleType{GetLE_ALubyte(data)};
-    ALubyte channelType{GetLE_ALubyte(data)};
-    ALushort irSize{GetLE_ALubyte(data)};
-    ALubyte fdCount{GetLE_ALubyte(data)};
-    if(!data || data.eof())
-    {
-        ERR("Failed reading %s\n", filename);
-        return nullptr;
-    }
-
-    ALboolean failed{AL_FALSE};
-    if(sampleType > SAMPLETYPE_S24)
-    {
-        ERR("Unsupported sample type: %d\n", sampleType);
-        failed = AL_TRUE;
-    }
-    if(channelType > CHANTYPE_LEFTRIGHT)
-    {
-        ERR("Unsupported channel type: %d\n", channelType);
-        failed = AL_TRUE;
-    }
-
-    if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
-    {
-        ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
-            irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
-        failed = AL_TRUE;
-    }
-    if(fdCount < 1 || fdCount > MAX_FD_COUNT)
-    {
-        ERR("Multiple field-depths not supported: fdCount=%d (%d to %d)\n",
-            fdCount, MIN_FD_COUNT, MAX_FD_COUNT);
-        failed = AL_TRUE;
-    }
-    if(failed)
-        return nullptr;
-
-    auto distance = al::vector<ALushort>(fdCount);
-    auto evCount = al::vector<ALubyte>(fdCount);
-    auto azCount = al::vector<ALushort>{};
-    for(size_t f{0};f < fdCount;f++)
-    {
-        distance[f] = GetLE_ALushort(data);
-        evCount[f] = GetLE_ALubyte(data);
-        if(!data || data.eof())
-        {
-            ERR("Failed reading %s\n", filename);
-            return nullptr;
-        }
-
-        if(distance[f] < MIN_FD_DISTANCE || distance[f] > MAX_FD_DISTANCE)
-        {
-            ERR("Unsupported field distance[%zu]=%d (%d to %d millimeters)\n", f, distance[f],
-                MIN_FD_DISTANCE, MAX_FD_DISTANCE);
-            failed = AL_TRUE;
-        }
-        if(f > 0 && distance[f] <= distance[f-1])
-        {
-            ERR("Field distance[%zu] is not after previous (%d > %d)\n", f, distance[f],
-                distance[f-1]);
-            failed = AL_TRUE;
-        }
-        if(evCount[f] < MIN_EV_COUNT || evCount[f] > MAX_EV_COUNT)
-        {
-            ERR("Unsupported elevation count: evCount[%zu]=%d (%d to %d)\n", f, evCount[f],
-                MIN_EV_COUNT, MAX_EV_COUNT);
-            failed = AL_TRUE;
-        }
-        if(failed)
-            return nullptr;
-
-        const size_t ebase{azCount.size()};
-        azCount.resize(ebase + evCount[f]);
-        std::generate(azCount.begin()+static_cast<ptrdiff_t>(ebase), azCount.end(),
-            std::bind(GetLE_ALubyte, std::ref(data)));
-        if(!data || data.eof())
-        {
-            ERR("Failed reading %s\n", filename);
-            return nullptr;
-        }
-
-        for(size_t e{0};e < evCount[f];e++)
-        {
-            if(azCount[ebase+e] < MIN_AZ_COUNT || azCount[ebase+e] > MAX_AZ_COUNT)
-            {
-                ERR("Unsupported azimuth count: azCount[%zu][%zu]=%d (%d to %d)\n", f, e,
-                    azCount[ebase+e], MIN_AZ_COUNT, MAX_AZ_COUNT);
-                failed = AL_TRUE;
-            }
-        }
-        if(failed)
-            return nullptr;
-    }
-
-    auto evOffset = al::vector<ALushort>(azCount.size());
-    evOffset[0] = 0;
-    std::partial_sum(azCount.cbegin(), azCount.cend()-1, evOffset.begin()+1);
-    const auto irTotal = static_cast<ALushort>(evOffset.back() + azCount.back());
-
-    auto coeffs = al::vector<std::array<ALfloat,2>>(irSize*irTotal);
-    auto delays = al::vector<std::array<ALubyte,2>>(irTotal);
-    if(channelType == CHANTYPE_LEFTONLY)
-    {
-        if(sampleType == SAMPLETYPE_S16)
-        {
-            for(auto &val : coeffs)
-                val[0] = GetLE_ALshort(data) / 32768.0f;
-        }
-        else if(sampleType == SAMPLETYPE_S24)
-        {
-            for(auto &val : coeffs)
-                val[0] = static_cast<float>(GetLE_ALint24(data)) / 8388608.0f;
-        }
-        for(auto &val : delays)
-            val[0] = GetLE_ALubyte(data);
-        if(!data || data.eof())
-        {
-            ERR("Failed reading %s\n", filename);
-            return nullptr;
-        }
-        for(size_t i{0};i < irTotal;++i)
-        {
-            if(delays[i][0] > MAX_HRIR_DELAY)
-            {
-                ERR("Invalid delays[%zu][0]: %d (%d)\n", i, delays[i][0], MAX_HRIR_DELAY);
-                failed = AL_TRUE;
-            }
-        }
-    }
-    else if(channelType == CHANTYPE_LEFTRIGHT)
-    {
-        if(sampleType == SAMPLETYPE_S16)
-        {
-            for(auto &val : coeffs)
-            {
-                val[0] = GetLE_ALshort(data) / 32768.0f;
-                val[1] = GetLE_ALshort(data) / 32768.0f;
-            }
-        }
-        else if(sampleType == SAMPLETYPE_S24)
-        {
-            for(auto &val : coeffs)
-            {
-                val[0] = static_cast<float>(GetLE_ALint24(data)) / 8388608.0f;
-                val[1] = static_cast<float>(GetLE_ALint24(data)) / 8388608.0f;
-            }
-        }
-        for(auto &val : delays)
-        {
-            val[0] = GetLE_ALubyte(data);
-            val[1] = GetLE_ALubyte(data);
-        }
-        if(!data || data.eof())
-        {
-            ERR("Failed reading %s\n", filename);
-            return nullptr;
-        }
-
-        for(size_t i{0};i < irTotal;++i)
-        {
-            if(delays[i][0] > MAX_HRIR_DELAY)
-            {
-                ERR("Invalid delays[%zu][0]: %d (%d)\n", i, delays[i][0], MAX_HRIR_DELAY);
-                failed = AL_TRUE;
-            }
-            if(delays[i][1] > MAX_HRIR_DELAY)
-            {
-                ERR("Invalid delays[%zu][1]: %d (%d)\n", i, delays[i][1], MAX_HRIR_DELAY);
-                failed = AL_TRUE;
-            }
-        }
-    }
-    if(failed)
-        return nullptr;
-
-    if(channelType == CHANTYPE_LEFTONLY)
-    {
-        /* Mirror the left ear responses to the right ear. */
-        size_t ebase{0};
-        for(size_t f{0};f < fdCount;f++)
-        {
-            for(size_t e{0};e < evCount[f];e++)
-            {
-                const ALushort evoffset{evOffset[ebase+e]};
-                const ALushort azcount{azCount[ebase+e]};
-                for(size_t a{0};a < azcount;a++)
-                {
-                    const size_t lidx{evoffset + a};
-                    const size_t ridx{evoffset + ((azcount-a) % azcount)};
-
-                    for(size_t k{0};k < irSize;k++)
-                        coeffs[ridx*irSize + k][1] = coeffs[lidx*irSize + k][0];
-                    delays[ridx][1] = delays[lidx][0];
-                }
-            }
-            ebase += evCount[f];
-        }
-    }
-
-    if(fdCount > 1)
-    {
-        auto distance_ = al::vector<ALushort>(distance.size());
-        auto evCount_ = al::vector<ALubyte>(evCount.size());
-        auto azCount_ = al::vector<ALushort>(azCount.size());
-        auto evOffset_ = al::vector<ALushort>(evOffset.size());
-        auto coeffs_ = al::vector<float2>(coeffs.size());
-        auto delays_ = al::vector<std::array<ALubyte,2>>(delays.size());
-
-        /* Simple reverse for the per-field elements. */
-        std::reverse_copy(distance.cbegin(), distance.cend(), distance_.begin());
-        std::reverse_copy(evCount.cbegin(), evCount.cend(), evCount_.begin());
-
-        /* Each field has a group of elevations, which each have an azimuth
-         * count. Reverse the order of the groups, keeping the relative order
-         * of per-group azimuth counts.
-         */
-        auto azcnt_end = azCount_.end();
-        auto copy_azs = [&azCount,&azcnt_end](const ptrdiff_t ebase, const ALubyte num_evs) -> ptrdiff_t
-        {
-            auto azcnt_src = azCount.begin()+ebase;
-            azcnt_end = std::copy_backward(azcnt_src, azcnt_src+num_evs, azcnt_end);
-            return ebase + num_evs;
-        };
-        std::accumulate(evCount.cbegin(), evCount.cend(), ptrdiff_t{0}, copy_azs);
-        assert(azCount_.begin() == azcnt_end);
-
-        /* Reestablish the IR offset for each elevation index, given the new
-         * ordering of elevations.
-         */
-        evOffset_[0] = 0;
-        std::partial_sum(azCount_.cbegin(), azCount_.cend()-1, evOffset_.begin()+1);
-
-        /* Reverse the order of each field's group of IRs. */
-        auto coeffs_end = coeffs_.end();
-        auto delays_end = delays_.end();
-        auto copy_irs = [irSize,&azCount,&coeffs,&delays,&coeffs_end,&delays_end](const ptrdiff_t ebase, const ALubyte num_evs) -> ptrdiff_t
-        {
-            const ALsizei abase{std::accumulate(azCount.cbegin(), azCount.cbegin()+ebase, 0)};
-            const ALsizei num_azs{std::accumulate(azCount.cbegin()+ebase,
-                azCount.cbegin() + (ebase+num_evs), 0)};
-
-            coeffs_end = std::copy_backward(coeffs.cbegin() + abase*irSize,
-                coeffs.cbegin() + (abase+num_azs)*irSize, coeffs_end);
-            delays_end = std::copy_backward(delays.cbegin() + abase,
-                delays.cbegin() + (abase+num_azs), delays_end);
-
-            return ebase + num_evs;
-        };
-        std::accumulate(evCount.cbegin(), evCount.cend(), ptrdiff_t{0}, copy_irs);
-        assert(coeffs_.begin() == coeffs_end);
-        assert(delays_.begin() == delays_end);
-
-        distance = std::move(distance_);
-        evCount = std::move(evCount_);
-        azCount = std::move(azCount_);
-        evOffset = std::move(evOffset_);
-        coeffs = std::move(coeffs_);
-        delays = std::move(delays_);
-    }
-
-    return CreateHrtfStore(rate, irSize, fdCount, evCount.data(), distance.data(), azCount.data(),
-        evOffset.data(), irTotal, &reinterpret_cast<ALfloat(&)[2]>(coeffs[0]),
-        &reinterpret_cast<ALubyte(&)[2]>(delays[0]), filename);
-}
-
-
-bool checkName(al::vector<EnumeratedHrtf> &list, const std::string &name)
-{
-    return std::find_if(list.cbegin(), list.cend(),
-        [&name](const EnumeratedHrtf &entry)
-        { return name == entry.name; }
-    ) != list.cend();
-}
-
-void AddFileEntry(al::vector<EnumeratedHrtf> &list, const std::string &filename)
-{
-    /* Check if this file has already been loaded globally. */
-    auto loaded_entry = LoadedHrtfs.begin();
-    for(;loaded_entry != LoadedHrtfs.end();++loaded_entry)
-    {
-        if(filename != (*loaded_entry)->mFilename.data())
-            continue;
-
-        /* Check if this entry has already been added to the list. */
-        auto iter = std::find_if(list.cbegin(), list.cend(),
-            [loaded_entry](const EnumeratedHrtf &entry) -> bool
-            { return loaded_entry->get() == entry.hrtf; }
-        );
-        if(iter != list.cend())
-        {
-            TRACE("Skipping duplicate file entry %s\n", filename.c_str());
-            return;
-        }
-
-        break;
-    }
-
-    const char *new_mark{""};
-    if(loaded_entry == LoadedHrtfs.end())
-    {
-        new_mark = " (new)";
-
-        LoadedHrtfs.emplace_back(HrtfHandle::Create(filename.length()+1));
-        loaded_entry = LoadedHrtfs.end()-1;
-        std::copy(filename.begin(), filename.end(), (*loaded_entry)->mFilename.begin());
-        (*loaded_entry)->mFilename.back() = '\0';
-    }
-
-    /* TODO: Get a human-readable name from the HRTF data (possibly coming in a
-     * format update). */
-    size_t namepos = filename.find_last_of('/')+1;
-    if(!namepos) namepos = filename.find_last_of('\\')+1;
-
-    size_t extpos{filename.find_last_of('.')};
-    if(extpos <= namepos) extpos = std::string::npos;
-
-    const std::string basename{(extpos == std::string::npos) ?
-        filename.substr(namepos) : filename.substr(namepos, extpos-namepos)};
-    std::string newname{basename};
-    int count{1};
-    while(checkName(list, newname))
-    {
-        newname = basename;
-        newname += " #";
-        newname += std::to_string(++count);
-    }
-    list.emplace_back(EnumeratedHrtf{newname, loaded_entry->get()});
-    const EnumeratedHrtf &entry = list.back();
-
-    TRACE("Adding file entry \"%s\"%s\n", entry.name.c_str(), new_mark);
-}
-
-/* Unfortunate that we have to duplicate AddFileEntry to take a memory buffer
- * for input instead of opening the given filename.
- */
-void AddBuiltInEntry(al::vector<EnumeratedHrtf> &list, const std::string &filename, ALuint residx)
-{
-    auto loaded_entry = LoadedHrtfs.begin();
-    for(;loaded_entry != LoadedHrtfs.end();++loaded_entry)
-    {
-        if(filename != (*loaded_entry)->mFilename.data())
-            continue;
-
-        /* Check if this entry has already been added to the list. */
-        auto iter = std::find_if(list.cbegin(), list.cend(),
-            [loaded_entry](const EnumeratedHrtf &entry) -> bool
-            { return loaded_entry->get() == entry.hrtf; }
-        );
-        if(iter != list.cend())
-        {
-            TRACE("Skipping duplicate file entry %s\n", filename.c_str());
-            return;
-        }
-
-        break;
-    }
-
-    const char *new_mark{""};
-    if(loaded_entry == LoadedHrtfs.end())
-    {
-        new_mark = " (new)";
-
-        LoadedHrtfs.emplace_back(HrtfHandle::Create(filename.length()+32));
-        loaded_entry = LoadedHrtfs.end()-1;
-        snprintf((*loaded_entry)->mFilename.data(), (*loaded_entry)->mFilename.size(), "!%u_%s",
-            residx, filename.c_str());
-    }
-
-    /* TODO: Get a human-readable name from the HRTF data (possibly coming in a
-     * format update). */
-
-    std::string newname{filename};
-    int count{1};
-    while(checkName(list, newname))
-    {
-        newname = filename;
-        newname += " #";
-        newname += std::to_string(++count);
-    }
-    list.emplace_back(EnumeratedHrtf{newname, loaded_entry->get()});
-    const EnumeratedHrtf &entry = list.back();
-
-    TRACE("Adding built-in entry \"%s\"%s\n", entry.name.c_str(), new_mark);
-}
-
-
-#define IDR_DEFAULT_44100_MHR 1
-#define IDR_DEFAULT_48000_MHR 2
-
-using ResData = al::span<const char>;
-#ifndef ALSOFT_EMBED_HRTF_DATA
-
-ResData GetResource(int /*name*/)
-{ return ResData{}; }
-
-#else
-
-#include "default-44100.mhr.h"
-#include "default-48000.mhr.h"
-
-ResData GetResource(int name)
-{
-    if(name == IDR_DEFAULT_44100_MHR)
-        return {reinterpret_cast<const char*>(hrtf_default_44100), sizeof(hrtf_default_44100)};
-    if(name == IDR_DEFAULT_48000_MHR)
-        return {reinterpret_cast<const char*>(hrtf_default_48000), sizeof(hrtf_default_48000)};
-    return ResData{};
-}
-#endif
-
-} // namespace
-
-
-al::vector<EnumeratedHrtf> EnumerateHrtf(const char *devname)
-{
-    al::vector<EnumeratedHrtf> list;
-
-    bool usedefaults{true};
-    if(auto pathopt = ConfigValueStr(devname, nullptr, "hrtf-paths"))
-    {
-        const char *pathlist{pathopt->c_str()};
-        while(pathlist && *pathlist)
-        {
-            const char *next, *end;
-
-            while(isspace(*pathlist) || *pathlist == ',')
-                pathlist++;
-            if(*pathlist == '\0')
-                continue;
-
-            next = strchr(pathlist, ',');
-            if(next)
-                end = next++;
-            else
-            {
-                end = pathlist + strlen(pathlist);
-                usedefaults = false;
-            }
-
-            while(end != pathlist && isspace(*(end-1)))
-                --end;
-            if(end != pathlist)
-            {
-                const std::string pname{pathlist, end};
-                for(const auto &fname : SearchDataFiles(".mhr", pname.c_str()))
-                    AddFileEntry(list, fname);
-            }
-
-            pathlist = next;
-        }
-    }
-
-    if(usedefaults)
-    {
-        for(const auto &fname : SearchDataFiles(".mhr", "openal/hrtf"))
-            AddFileEntry(list, fname);
-
-        if(!GetResource(IDR_DEFAULT_44100_MHR).empty())
-            AddBuiltInEntry(list, "Built-In 44100hz", IDR_DEFAULT_44100_MHR);
-
-        if(!GetResource(IDR_DEFAULT_48000_MHR).empty())
-            AddBuiltInEntry(list, "Built-In 48000hz", IDR_DEFAULT_48000_MHR);
-    }
-
-    if(auto defhrtfopt = ConfigValueStr(devname, nullptr, "default-hrtf"))
-    {
-        auto find_entry = [&defhrtfopt](const EnumeratedHrtf &entry) -> bool
-        { return entry.name == *defhrtfopt; };
-        auto iter = std::find_if(list.begin(), list.end(), find_entry);
-        if(iter == list.end())
-            WARN("Failed to find default HRTF \"%s\"\n", defhrtfopt->c_str());
-        else if(iter != list.begin())
-            std::rotate(list.begin(), iter, iter+1);
-    }
-
-    return list;
-}
-
-HrtfEntry *GetLoadedHrtf(HrtfHandle *handle)
-{
-    std::lock_guard<std::mutex> _{LoadedHrtfLock};
-
-    if(handle->mEntry)
-    {
-        HrtfEntry *hrtf{handle->mEntry.get()};
-        hrtf->IncRef();
-        return hrtf;
-    }
-
-    std::unique_ptr<std::istream> stream;
-    const char *name{""};
-    ALint residx{};
-    char ch{};
-    if(sscanf(handle->mFilename.data(), "!%d%c", &residx, &ch) == 2 && ch == '_')
-    {
-        name = strchr(handle->mFilename.data(), ch)+1;
-
-        TRACE("Loading %s...\n", name);
-        ResData res{GetResource(residx)};
-        if(res.empty())
-        {
-            ERR("Could not get resource %u, %s\n", residx, name);
-            return nullptr;
-        }
-        stream = al::make_unique<idstream>(res.begin(), res.end());
-    }
-    else
-    {
-        name = handle->mFilename.data();
-
-        TRACE("Loading %s...\n", handle->mFilename.data());
-        auto fstr = al::make_unique<al::ifstream>(handle->mFilename.data(), std::ios::binary);
-        if(!fstr->is_open())
-        {
-            ERR("Could not open %s\n", handle->mFilename.data());
-            return nullptr;
-        }
-        stream = std::move(fstr);
-    }
-
-    std::unique_ptr<HrtfEntry> hrtf;
-    char magic[sizeof(magicMarker02)];
-    stream->read(magic, sizeof(magic));
-    if(stream->gcount() < static_cast<std::streamsize>(sizeof(magicMarker02)))
-        ERR("%s data is too short (%zu bytes)\n", name, stream->gcount());
-    else if(memcmp(magic, magicMarker02, sizeof(magicMarker02)) == 0)
-    {
-        TRACE("Detected data set format v2\n");
-        hrtf = LoadHrtf02(*stream, name);
-    }
-    else if(memcmp(magic, magicMarker01, sizeof(magicMarker01)) == 0)
-    {
-        TRACE("Detected data set format v1\n");
-        hrtf = LoadHrtf01(*stream, name);
-    }
-    else if(memcmp(magic, magicMarker00, sizeof(magicMarker00)) == 0)
-    {
-        TRACE("Detected data set format v0\n");
-        hrtf = LoadHrtf00(*stream, name);
-    }
-    else
-        ERR("Invalid header in %s: \"%.8s\"\n", name, magic);
-    stream.reset();
-
-    if(!hrtf)
-    {
-        ERR("Failed to load %s\n", name);
-        return nullptr;
-    }
-
-    TRACE("Loaded HRTF support for sample rate: %uhz\n", hrtf->sampleRate);
-    handle->mEntry = std::move(hrtf);
-
-    return handle->mEntry.get();
-}
-
-
-void HrtfEntry::IncRef()
-{
-    auto ref = IncrementRef(mRef);
-    TRACE("HrtfEntry %p increasing refcount to %u\n", decltype(std::declval<void*>()){this}, ref);
-}
-
-void HrtfEntry::DecRef()
-{
-    auto ref = DecrementRef(mRef);
-    TRACE("HrtfEntry %p decreasing refcount to %u\n", decltype(std::declval<void*>()){this}, ref);
-    if(ref == 0)
-    {
-        std::lock_guard<std::mutex> _{LoadedHrtfLock};
-
-        /* Go through and clear all unused HRTFs. */
-        auto delete_unused = [](HrtfHandlePtr &handle) -> void
-        {
-            HrtfEntry *entry{handle->mEntry.get()};
-            if(entry && ReadRef(entry->mRef) == 0)
-            {
-                TRACE("Unloading unused HRTF %s\n", handle->mFilename.data());
-                handle->mEntry = nullptr;
-            }
-        };
-        std::for_each(LoadedHrtfs.begin(), LoadedHrtfs.end(), delete_unused);
-    }
-}
diff --git a/alc/hrtf.h b/alc/hrtf.h
deleted file mode 100644
index 98df801b..00000000
--- a/alc/hrtf.h
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef ALC_HRTF_H
-#define ALC_HRTF_H
-
-#include <array>
-#include <cstddef>
-#include <memory>
-#include <string>
-
-#include "AL/al.h"
-
-#include "almalloc.h"
-#include "alspan.h"
-#include "ambidefs.h"
-#include "atomic.h"
-#include "vector.h"
-
-struct HrtfHandle;
-
-
-#define HRTF_HISTORY_BITS   (6)
-#define HRTF_HISTORY_LENGTH (1<<HRTF_HISTORY_BITS)
-#define HRTF_HISTORY_MASK   (HRTF_HISTORY_LENGTH-1)
-
-#define HRIR_BITS        (7)
-#define HRIR_LENGTH      (1<<HRIR_BITS)
-#define HRIR_MASK        (HRIR_LENGTH-1)
-
-
-struct HrtfEntry {
-    RefCount mRef;
-
-    ALuint sampleRate;
-    ALuint irSize;
-
-    struct Field {
-        ALfloat distance;
-        ALubyte evCount;
-    };
-    /* NOTE: Fields are stored *backwards*. field[0] is the farthest field, and
-     * field[fdCount-1] is the nearest.
-     */
-    ALuint fdCount;
-    const Field *field;
-
-    struct Elevation {
-        ALushort azCount;
-        ALushort irOffset;
-    };
-    Elevation *elev;
-    const ALfloat (*coeffs)[2];
-    const ALubyte (*delays)[2];
-
-    void IncRef();
-    void DecRef();
-
-    DEF_PLACE_NEWDEL()
-};
-
-struct EnumeratedHrtf {
-    std::string name;
-
-    HrtfHandle *hrtf;
-};
-
-
-using float2 = std::array<float,2>;
-using HrirArray = std::array<float2,HRIR_LENGTH>;
-
-struct HrtfState {
-    alignas(16) std::array<ALfloat,HRTF_HISTORY_LENGTH> History;
-};
-
-struct HrtfFilter {
-    alignas(16) HrirArray Coeffs;
-    ALsizei Delay[2];
-    ALfloat Gain;
-};
-
-struct DirectHrtfState {
-    /* HRTF filter state for dry buffer content */
-    ALuint IrSize{0};
-    al::FlexArray<HrirArray,16> Coeffs;
-
-    DirectHrtfState(size_t numchans) : Coeffs{numchans} { }
-
-    static std::unique_ptr<DirectHrtfState> Create(size_t num_chans);
-
-    DEF_FAM_NEWDEL(DirectHrtfState, Coeffs)
-};
-
-struct ElevRadius { float value; };
-struct AzimRadius { float value; };
-struct AngularPoint {
-    ElevRadius Elev;
-    AzimRadius Azim;
-};
-
-
-al::vector<EnumeratedHrtf> EnumerateHrtf(const char *devname);
-HrtfEntry *GetLoadedHrtf(HrtfHandle *handle);
-
-void GetHrtfCoeffs(const HrtfEntry *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat distance,
-    ALfloat spread, HrirArray &coeffs, ALsizei (&delays)[2]);
-
-/**
- * Produces HRTF filter coefficients for decoding B-Format, given a set of
- * virtual speaker positions, a matching decoding matrix, and per-order high-
- * frequency gains for the decoder. The calculated impulse responses are
- * ordered and scaled according to the matrix input.
- */
-void BuildBFormatHrtf(const HrtfEntry *Hrtf, DirectHrtfState *state,
-    const al::span<const AngularPoint> AmbiPoints, const ALfloat (*AmbiMatrix)[MAX_AMBI_CHANNELS],
-    const ALfloat *AmbiOrderHFGain);
-
-#endif /* ALC_HRTF_H */
diff --git a/alc/inprogext.h b/alc/inprogext.h
index ad3ea288..ccb9a4be 100644
--- a/alc/inprogext.h
+++ b/alc/inprogext.h
@@ -9,25 +9,6 @@
 extern "C" {
 #endif
 
-#ifndef ALC_SOFT_loopback_bformat
-#define ALC_SOFT_loopback_bformat 1
-#define ALC_AMBISONIC_LAYOUT_SOFT                0x1997
-#define ALC_AMBISONIC_SCALING_SOFT               0x1998
-#define ALC_AMBISONIC_ORDER_SOFT                 0x1999
-#define ALC_MAX_AMBISONIC_ORDER_SOFT             0x199B
-
-#define ALC_BFORMAT3D_SOFT                       0x1508
-
-/* Ambisonic layouts */
-#define ALC_FUMA_SOFT                            0x0000
-#define ALC_ACN_SOFT                             0x0001
-
-/* Ambisonic scalings (normalization) */
-/*#define ALC_FUMA_SOFT*/
-#define ALC_SN3D_SOFT                            0x0001
-#define ALC_N3D_SOFT                             0x0002
-#endif
-
 #ifndef AL_SOFT_map_buffer
 #define AL_SOFT_map_buffer 1
 typedef unsigned int ALbitfieldSOFT;
@@ -47,36 +28,44 @@ AL_API void AL_APIENTRY alFlushMappedBufferSOFT(ALuint buffer, ALsizei offset, A
 #endif
 #endif
 
-#ifndef AL_SOFT_events
-#define AL_SOFT_events 1
-#define AL_EVENT_CALLBACK_FUNCTION_SOFT          0x1220
-#define AL_EVENT_CALLBACK_USER_PARAM_SOFT        0x1221
-#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT      0x1222
-#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT  0x1223
-#define AL_EVENT_TYPE_ERROR_SOFT                 0x1224
-#define AL_EVENT_TYPE_PERFORMANCE_SOFT           0x1225
-#define AL_EVENT_TYPE_DEPRECATED_SOFT            0x1226
-#define AL_EVENT_TYPE_DISCONNECTED_SOFT          0x1227
-typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param,
-                                           ALsizei length, const ALchar *message,
-                                           void *userParam);
-typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable);
-typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam);
-typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname);
-typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values);
+#ifndef AL_SOFT_bformat_hoa
+#define AL_SOFT_bformat_hoa
+#define AL_UNPACK_AMBISONIC_ORDER_SOFT           0x199D
+#endif
+
+#ifndef AL_SOFT_convolution_reverb
+#define AL_SOFT_convolution_reverb
+#define AL_EFFECT_CONVOLUTION_REVERB_SOFT        0xA000
+#define AL_EFFECTSLOT_STATE_SOFT                 0x199D
+typedef void (AL_APIENTRY*LPALAUXILIARYEFFECTSLOTPLAYSOFT)(ALuint slotid);
+typedef void (AL_APIENTRY*LPALAUXILIARYEFFECTSLOTPLAYVSOFT)(ALsizei n, const ALuint *slotids);
+typedef void (AL_APIENTRY*LPALAUXILIARYEFFECTSLOTSTOPSOFT)(ALuint slotid);
+typedef void (AL_APIENTRY*LPALAUXILIARYEFFECTSLOTSTOPVSOFT)(ALsizei n, const ALuint *slotids);
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable);
-AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam);
-AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname);
-AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlaySOFT(ALuint slotid);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotPlayvSOFT(ALsizei n, const ALuint *slotids);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopSOFT(ALuint slotid);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotStopvSOFT(ALsizei n, const ALuint *slotids);
 #endif
 #endif
 
-#ifndef AL_SOFT_effect_chain
-#define AL_SOFT_effect_chain
-#define AL_EFFECTSLOT_TARGET_SOFT                0xf000
+#ifndef AL_SOFT_hold_on_disconnect
+#define AL_SOFT_hold_on_disconnect
+#define AL_STOP_SOURCES_ON_DISCONNECT_SOFT       0x19AB
 #endif
 
+
+/* Non-standard export. Not part of any extension. */
+AL_API const ALchar* AL_APIENTRY alsoft_get_version(void);
+
+
+/* Functions from abandoned extensions. Only here for binary compatibility. */
+AL_API void AL_APIENTRY alSourceQueueBufferLayersSOFT(ALuint src, ALsizei nb,
+    const ALuint *buffers);
+
+AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname);
+AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
diff --git a/alc/logging.h b/alc/logging.h
deleted file mode 100644
index ec6023a5..00000000
--- a/alc/logging.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef LOGGING_H
-#define LOGGING_H
-
-#include <stdio.h>
-
-#include "opthelpers.h"
-
-
-#ifdef __GNUC__
-#define DECL_FORMAT(x, y, z) __attribute__((format(x, (y), (z))))
-#else
-#define DECL_FORMAT(x, y, z)
-#endif
-
-
-extern FILE *gLogFile;
-
-void al_print(FILE *logfile, const char *fmt, ...) DECL_FORMAT(printf, 2,3);
-#if !defined(_WIN32)
-#define AL_PRINT fprintf
-#else
-#define AL_PRINT al_print
-#endif
-
-#ifdef __ANDROID__
-#include <android/log.h>
-#define LOG_ANDROID(T, ...) __android_log_print(T, "openal", "AL lib: " __VA_ARGS__)
-#else
-#define LOG_ANDROID(T, ...) ((void)0)
-#endif
-
-enum LogLevel {
-    NoLog,
-    LogError,
-    LogWarning,
-    LogTrace,
-    LogRef
-};
-extern LogLevel gLogLevel;
-
-#define TRACE(...) do {                                                       \
-    if UNLIKELY(gLogLevel >= LogTrace)                                        \
-        AL_PRINT(gLogFile, "AL lib: (II) " __VA_ARGS__);                      \
-    LOG_ANDROID(ANDROID_LOG_DEBUG, __VA_ARGS__);                              \
-} while(0)
-
-#define WARN(...) do {                                                        \
-    if UNLIKELY(gLogLevel >= LogWarning)                                      \
-        AL_PRINT(gLogFile, "AL lib: (WW) " __VA_ARGS__);                      \
-    LOG_ANDROID(ANDROID_LOG_WARN, __VA_ARGS__);                               \
-} while(0)
-
-#define ERR(...) do {                                                         \
-    if UNLIKELY(gLogLevel >= LogError)                                        \
-        AL_PRINT(gLogFile, "AL lib: (EE) " __VA_ARGS__);                      \
-    LOG_ANDROID(ANDROID_LOG_ERROR, __VA_ARGS__);                              \
-} while(0)
-
-#endif /* LOGGING_H */
diff --git a/alc/mastering.h b/alc/mastering.h
deleted file mode 100644
index 851381e9..00000000
--- a/alc/mastering.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef MASTERING_H
-#define MASTERING_H
-
-#include <memory>
-
-#include "AL/al.h"
-
-/* For FloatBufferLine/BUFFERSIZE. */
-#include "alcmain.h"
-#include "almalloc.h"
-
-struct SlidingHold;
-
-
-/* General topology and basic automation was based on the following paper:
- *
- *   D. Giannoulis, M. Massberg and J. D. Reiss,
- *   "Parameter Automation in a Dynamic Range Compressor,"
- *   Journal of the Audio Engineering Society, v61 (10), Oct. 2013
- *
- * Available (along with supplemental reading) at:
- *
- *   http://c4dm.eecs.qmul.ac.uk/audioengineering/compressors/
- */
-struct Compressor {
-    ALuint mNumChans{0u};
-
-    struct {
-        bool Knee : 1;
-        bool Attack : 1;
-        bool Release : 1;
-        bool PostGain : 1;
-        bool Declip : 1;
-    } mAuto{};
-
-    ALuint mLookAhead{0};
-
-    ALfloat mPreGain{0.0f};
-    ALfloat mPostGain{0.0f};
-
-    ALfloat mThreshold{0.0f};
-    ALfloat mSlope{0.0f};
-    ALfloat mKnee{0.0f};
-
-    ALfloat mAttack{0.0f};
-    ALfloat mRelease{0.0f};
-
-    alignas(16) ALfloat mSideChain[2*BUFFERSIZE]{};
-    alignas(16) ALfloat mCrestFactor[BUFFERSIZE]{};
-
-    SlidingHold *mHold{nullptr};
-    FloatBufferLine *mDelay{nullptr};
-
-    ALfloat mCrestCoeff{0.0f};
-    ALfloat mGainEstimate{0.0f};
-    ALfloat mAdaptCoeff{0.0f};
-
-    ALfloat mLastPeakSq{0.0f};
-    ALfloat mLastRmsSq{0.0f};
-    ALfloat mLastRelease{0.0f};
-    ALfloat mLastAttack{0.0f};
-    ALfloat mLastGainDev{0.0f};
-
-
-    ~Compressor();
-    void process(const ALuint SamplesToDo, FloatBufferLine *OutBuffer);
-    ALsizei getLookAhead() const noexcept { return static_cast<ALsizei>(mLookAhead); }
-
-    DEF_PLACE_NEWDEL()
-};
-
-/* The compressor is initialized with the following settings:
- *
- *   NumChans       - Number of channels to process.
- *   SampleRate     - Sample rate to process.
- *   AutoKnee       - Whether to automate the knee width parameter.
- *   AutoAttack     - Whether to automate the attack time parameter.
- *   AutoRelease    - Whether to automate the release time parameter.
- *   AutoPostGain   - Whether to automate the make-up (post) gain parameter.
- *   AutoDeclip     - Whether to automate clipping reduction.  Ignored when
- *                    not automating make-up gain.
- *   LookAheadTime  - Look-ahead time (in seconds).
- *   HoldTime       - Peak hold-time (in seconds).
- *   PreGainDb      - Gain applied before detection (in dB).
- *   PostGainDb     - Make-up gain applied after compression (in dB).
- *   ThresholdDb    - Triggering threshold (in dB).
- *   Ratio          - Compression ratio (x:1).  Set to INFINIFTY for true
- *                    limiting.  Ignored when automating knee width.
- *   KneeDb         - Knee width (in dB).  Ignored when automating knee
- *                    width.
- *   AttackTimeMin  - Attack time (in seconds).  Acts as a maximum when
- *                    automating attack time.
- *   ReleaseTimeMin - Release time (in seconds).  Acts as a maximum when
- *                    automating release time.
- */
-std::unique_ptr<Compressor> CompressorInit(const ALuint NumChans, const ALfloat SampleRate,
-    const ALboolean AutoKnee, const ALboolean AutoAttack, const ALboolean AutoRelease,
-    const ALboolean AutoPostGain, const ALboolean AutoDeclip, const ALfloat LookAheadTime,
-    const ALfloat HoldTime, const ALfloat PreGainDb, const ALfloat PostGainDb,
-    const ALfloat ThresholdDb, const ALfloat Ratio, const ALfloat KneeDb, const ALfloat AttackTime,
-    const ALfloat ReleaseTime);
-
-#endif /* MASTERING_H */
diff --git a/alc/mixer/defs.h b/alc/mixer/defs.h
deleted file mode 100644
index 1e5b40d8..00000000
--- a/alc/mixer/defs.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef MIXER_DEFS_H
-#define MIXER_DEFS_H
-
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "alspan.h"
-#include "hrtf.h"
-
-union InterpState;
-struct MixHrtfFilter;
-
-
-enum InstSetType {
-    CTag,
-    SSETag,
-    SSE2Tag,
-    SSE3Tag,
-    SSE4Tag,
-    NEONTag
-};
-
-enum ResampleType {
-    CopyTag,
-    PointTag,
-    LerpTag,
-    CubicTag,
-    BSincTag,
-    FastBSincTag
-};
-
-template<ResampleType TypeTag, InstSetType InstTag>
-const ALfloat *Resample_(const InterpState *state, const ALfloat *RESTRICT src, ALuint frac,
-    ALuint increment, const al::span<float> dst);
-
-template<InstSetType InstTag>
-void Mix_(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
-    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos);
-template<InstSetType InstTag>
-void MixRow_(const al::span<float> OutBuffer, const al::span<const float> Gains,
-    const float *InSamples, const size_t InStride);
-
-template<InstSetType InstTag>
-void MixHrtf_(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize);
-template<InstSetType InstTag>
-void MixHrtfBlend_(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    const HrtfFilter *oldparams, MixHrtfFilter *newparams, const size_t BufferSize);
-template<InstSetType InstTag>
-void MixDirectHrtf_(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
-    const size_t BufferSize);
-
-/* Vectorized resampler helpers */
-inline void InitPosArrays(ALuint frac, ALuint increment, ALuint *frac_arr, ALuint *pos_arr,
-    size_t size)
-{
-    pos_arr[0] = 0;
-    frac_arr[0] = frac;
-    for(size_t i{1};i < size;i++)
-    {
-        const ALuint frac_tmp{frac_arr[i-1] + increment};
-        pos_arr[i] = pos_arr[i-1] + (frac_tmp>>FRACTIONBITS);
-        frac_arr[i] = frac_tmp&FRACTIONMASK;
-    }
-}
-
-#endif /* MIXER_DEFS_H */
diff --git a/alc/mixer/hrtfbase.h b/alc/mixer/hrtfbase.h
deleted file mode 100644
index 4a6eab50..00000000
--- a/alc/mixer/hrtfbase.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef MIXER_HRTFBASE_H
-#define MIXER_HRTFBASE_H
-
-#include <algorithm>
-
-#include "alu.h"
-#include "../hrtf.h"
-#include "opthelpers.h"
-#include "voice.h"
-
-
-using ApplyCoeffsT = void(&)(float2 *RESTRICT Values, const ALuint irSize, const HrirArray &Coeffs,
-    const float left, const float right);
-
-template<ApplyCoeffsT ApplyCoeffs>
-inline void MixHrtfBase(const float *InSamples, float2 *RESTRICT AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize)
-{
-    ASSUME(BufferSize > 0);
-
-    const HrirArray &Coeffs = *hrtfparams->Coeffs;
-    const float gainstep{hrtfparams->GainStep};
-    const float gain{hrtfparams->Gain};
-
-    ALsizei Delay[2]{
-        HRTF_HISTORY_LENGTH - hrtfparams->Delay[0],
-        HRTF_HISTORY_LENGTH - hrtfparams->Delay[1] };
-    ASSUME(Delay[0] >= 0 && Delay[1] >= 0);
-    float stepcount{0.0f};
-    for(size_t i{0u};i < BufferSize;++i)
-    {
-        const float g{gain + gainstep*stepcount};
-        const float left{InSamples[Delay[0]++] * g};
-        const float right{InSamples[Delay[1]++] * g};
-        ApplyCoeffs(AccumSamples+i, IrSize, Coeffs, left, right);
-
-        stepcount += 1.0f;
-    }
-
-    hrtfparams->Gain = gain + gainstep*stepcount;
-}
-
-template<ApplyCoeffsT ApplyCoeffs>
-inline void MixHrtfBlendBase(const float *InSamples, float2 *RESTRICT AccumSamples,
-    const ALuint IrSize, const HrtfFilter *oldparams, MixHrtfFilter *newparams,
-    const size_t BufferSize)
-{
-    const auto &OldCoeffs = oldparams->Coeffs;
-    const float oldGain{oldparams->Gain};
-    const float oldGainStep{-oldGain / static_cast<float>(BufferSize)};
-    const auto &NewCoeffs = *newparams->Coeffs;
-    const float newGainStep{newparams->GainStep};
-
-    ASSUME(BufferSize > 0);
-
-    ALsizei Delay[2]{
-        HRTF_HISTORY_LENGTH - oldparams->Delay[0],
-        HRTF_HISTORY_LENGTH - oldparams->Delay[1] };
-    ASSUME(Delay[0] >= 0 && Delay[1] >= 0);
-    float stepcount{0.0f};
-    for(size_t i{0u};i < BufferSize;++i)
-    {
-        const float g{oldGain + oldGainStep*stepcount};
-        const float left{InSamples[Delay[0]++] * g};
-        const float right{InSamples[Delay[1]++] * g};
-        ApplyCoeffs(AccumSamples+i, IrSize, OldCoeffs, left, right);
-
-        stepcount += 1.0f;
-    }
-
-    Delay[0] = HRTF_HISTORY_LENGTH - newparams->Delay[0];
-    Delay[1] = HRTF_HISTORY_LENGTH - newparams->Delay[1];
-    ASSUME(Delay[0] >= 0 && Delay[1] >= 0);
-    stepcount = 0.0f;
-    for(size_t i{0u};i < BufferSize;++i)
-    {
-        const float g{newGainStep*stepcount};
-        const float left{InSamples[Delay[0]++] * g};
-        const float right{InSamples[Delay[1]++] * g};
-        ApplyCoeffs(AccumSamples+i, IrSize, NewCoeffs, left, right);
-
-        stepcount += 1.0f;
-    }
-
-    newparams->Gain = newGainStep*stepcount;
-}
-
-template<ApplyCoeffsT ApplyCoeffs>
-inline void MixDirectHrtfBase(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *RESTRICT AccumSamples,
-    DirectHrtfState *State, const size_t BufferSize)
-{
-    ASSUME(BufferSize > 0);
-
-    const ALuint IrSize{State->IrSize};
-
-    auto coeff_iter = State->Coeffs.begin();
-    for(const FloatBufferLine &input : InSamples)
-    {
-        const auto &Coeffs = *(coeff_iter++);
-        for(size_t i{0u};i < BufferSize;++i)
-        {
-            const float insample{input[i]};
-            ApplyCoeffs(AccumSamples+i, IrSize, Coeffs, insample, insample);
-        }
-    }
-    for(size_t i{0u};i < BufferSize;++i)
-        LeftOut[i]  += AccumSamples[i][0];
-    for(size_t i{0u};i < BufferSize;++i)
-        RightOut[i] += AccumSamples[i][1];
-
-    /* Copy the new in-progress accumulation values to the front and clear the
-     * following samples for the next mix.
-     */
-    auto accum_iter = std::copy_n(AccumSamples+BufferSize, HRIR_LENGTH, AccumSamples);
-    std::fill_n(accum_iter, BufferSize, float2{});
-}
-
-#endif /* MIXER_HRTFBASE_H */
diff --git a/alc/mixer/mixer_c.cpp b/alc/mixer/mixer_c.cpp
deleted file mode 100644
index fad33746..00000000
--- a/alc/mixer/mixer_c.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-#include "config.h"
-
-#include <cassert>
-
-#include <limits>
-
-#include "alcmain.h"
-#include "alu.h"
-
-#include "defs.h"
-#include "hrtfbase.h"
-
-
-namespace {
-
-inline float do_point(const InterpState&, const float *RESTRICT vals, const ALuint)
-{ return vals[0]; }
-inline float do_lerp(const InterpState&, const float *RESTRICT vals, const ALuint frac)
-{ return lerp(vals[0], vals[1], static_cast<float>(frac)*(1.0f/FRACTIONONE)); }
-inline float do_cubic(const InterpState&, const float *RESTRICT vals, const ALuint frac)
-{ return cubic(vals[0], vals[1], vals[2], vals[3], static_cast<float>(frac)*(1.0f/FRACTIONONE)); }
-inline float do_bsinc(const InterpState &istate, const float *RESTRICT vals, const ALuint frac)
-{
-    const size_t m{istate.bsinc.m};
-
-    // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-    const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-    const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-        (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-    const float *fil{istate.bsinc.filter + m*pi*4};
-    const float *phd{fil + m};
-    const float *scd{phd + m};
-    const float *spd{scd + m};
-
-    // Apply the scale and phase interpolated filter.
-    float r{0.0f};
-    for(size_t j_f{0};j_f < m;j_f++)
-        r += (fil[j_f] + istate.bsinc.sf*scd[j_f] + pf*(phd[j_f] + istate.bsinc.sf*spd[j_f])) * vals[j_f];
-    return r;
-}
-inline float do_fastbsinc(const InterpState &istate, const float *RESTRICT vals, const ALuint frac)
-{
-    const size_t m{istate.bsinc.m};
-
-    // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-    const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-    const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-        (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-    const float *fil{istate.bsinc.filter + m*pi*4};
-    const float *phd{fil + m};
-
-    // Apply the phase interpolated filter.
-    float r{0.0f};
-    for(size_t j_f{0};j_f < m;j_f++)
-        r += (fil[j_f] + pf*phd[j_f]) * vals[j_f];
-    return r;
-}
-
-using SamplerT = float(&)(const InterpState&, const float*RESTRICT, const ALuint);
-template<SamplerT Sampler>
-const float *DoResample(const InterpState *state, const float *RESTRICT src, ALuint frac,
-    ALuint increment, const al::span<float> dst)
-{
-    const InterpState istate{*state};
-    auto proc_sample = [&src,&frac,istate,increment]() -> float
-    {
-        const float ret{Sampler(istate, src, frac)};
-
-        frac += increment;
-        src  += frac>>FRACTIONBITS;
-        frac &= FRACTIONMASK;
-
-        return ret;
-    };
-    std::generate(dst.begin(), dst.end(), proc_sample);
-
-    return dst.begin();
-}
-
-inline void ApplyCoeffs(float2 *RESTRICT Values, const ALuint IrSize, const HrirArray &Coeffs,
-    const float left, const float right)
-{
-    ASSUME(IrSize >= 4);
-    for(ALuint c{0};c < IrSize;++c)
-    {
-        Values[c][0] += Coeffs[c][0] * left;
-        Values[c][1] += Coeffs[c][1] * right;
-    }
-}
-
-} // namespace
-
-template<>
-const ALfloat *Resample_<CopyTag,CTag>(const InterpState*, const ALfloat *RESTRICT src, ALuint,
-    ALuint, const al::span<float> dst)
-{
-#if defined(HAVE_SSE) || defined(HAVE_NEON)
-    /* Avoid copying the source data if it's aligned like the destination. */
-    if((reinterpret_cast<intptr_t>(src)&15) == (reinterpret_cast<intptr_t>(dst.data())&15))
-        return src;
-#endif
-    std::copy_n(src, dst.size(), dst.begin());
-    return dst.begin();
-}
-
-template<>
-const ALfloat *Resample_<PointTag,CTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{ return DoResample<do_point>(state, src, frac, increment, dst); }
-
-template<>
-const ALfloat *Resample_<LerpTag,CTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{ return DoResample<do_lerp>(state, src, frac, increment, dst); }
-
-template<>
-const ALfloat *Resample_<CubicTag,CTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{ return DoResample<do_cubic>(state, src-1, frac, increment, dst); }
-
-template<>
-const ALfloat *Resample_<BSincTag,CTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{ return DoResample<do_bsinc>(state, src-state->bsinc.l, frac, increment, dst); }
-
-template<>
-const ALfloat *Resample_<FastBSincTag,CTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{ return DoResample<do_fastbsinc>(state, src-state->bsinc.l, frac, increment, dst); }
-
-
-template<>
-void MixHrtf_<CTag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize)
-{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
-
-template<>
-void MixHrtfBlend_<CTag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    const HrtfFilter *oldparams, MixHrtfFilter *newparams, const size_t BufferSize)
-{
-    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
-        BufferSize);
-}
-
-template<>
-void MixDirectHrtf_<CTag>(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
-    const size_t BufferSize)
-{ MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, State, BufferSize); }
-
-
-template<>
-void Mix_<CTag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
-    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
-{
-    const ALfloat delta{(Counter > 0) ? 1.0f / static_cast<ALfloat>(Counter) : 0.0f};
-    const bool reached_target{InSamples.size() >= Counter};
-    const auto min_end = reached_target ? InSamples.begin() + Counter : InSamples.end();
-    for(FloatBufferLine &output : OutBuffer)
-    {
-        ALfloat *RESTRICT dst{al::assume_aligned<16>(output.data()+OutPos)};
-        ALfloat gain{*CurrentGains};
-        const ALfloat diff{*TargetGains - gain};
-
-        auto in_iter = InSamples.begin();
-        if(std::fabs(diff) > std::numeric_limits<float>::epsilon())
-        {
-            const ALfloat step{diff * delta};
-            ALfloat step_count{0.0f};
-            while(in_iter != min_end)
-            {
-                *(dst++) += *(in_iter++) * (gain + step*step_count);
-                step_count += 1.0f;
-            }
-            if(reached_target)
-                gain = *TargetGains;
-            else
-                gain += step*step_count;
-            *CurrentGains = gain;
-        }
-        ++CurrentGains;
-        ++TargetGains;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-        while(in_iter != InSamples.end())
-            *(dst++) += *(in_iter++) * gain;
-    }
-}
-
-/* Basically the inverse of the above. Rather than one input going to multiple
- * outputs (each with its own gain), it's multiple inputs (each with its own
- * gain) going to one output. This applies one row (vs one column) of a matrix
- * transform. And as the matrices are more or less static once set up, no
- * stepping is necessary.
- */
-template<>
-void MixRow_<CTag>(const al::span<float> OutBuffer, const al::span<const float> Gains,
-    const float *InSamples, const size_t InStride)
-{
-    for(const float gain : Gains)
-    {
-        const float *RESTRICT input{InSamples};
-        InSamples += InStride;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-
-        auto do_mix = [gain](const float cur, const float src) noexcept -> float
-        { return cur + src*gain; };
-        std::transform(OutBuffer.begin(), OutBuffer.end(), input, OutBuffer.begin(), do_mix);
-    }
-}
diff --git a/alc/mixer/mixer_neon.cpp b/alc/mixer/mixer_neon.cpp
deleted file mode 100644
index 67bf9c71..00000000
--- a/alc/mixer/mixer_neon.cpp
+++ /dev/null
@@ -1,324 +0,0 @@
-#include "config.h"
-
-#include <arm_neon.h>
-
-#include <limits>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "alcmain.h"
-#include "alu.h"
-#include "hrtf.h"
-#include "defs.h"
-#include "hrtfbase.h"
-
-
-namespace {
-
-inline void ApplyCoeffs(float2 *RESTRICT Values, const ALuint IrSize, const HrirArray &Coeffs,
-    const float left, const float right)
-{
-    float32x4_t leftright4;
-    {
-        float32x2_t leftright2 = vdup_n_f32(0.0);
-        leftright2 = vset_lane_f32(left, leftright2, 0);
-        leftright2 = vset_lane_f32(right, leftright2, 1);
-        leftright4 = vcombine_f32(leftright2, leftright2);
-    }
-
-    ASSUME(IrSize >= 4);
-    for(ALuint c{0};c < IrSize;c += 2)
-    {
-        float32x4_t vals = vld1q_f32(&Values[c][0]);
-        float32x4_t coefs = vld1q_f32(&Coeffs[c][0]);
-
-        vals = vmlaq_f32(vals, coefs, leftright4);
-
-        vst1q_f32(&Values[c][0], vals);
-    }
-}
-
-} // namespace
-
-template<>
-const ALfloat *Resample_<LerpTag,NEONTag>(const InterpState*, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{
-    const int32x4_t increment4 = vdupq_n_s32(static_cast<int>(increment*4));
-    const float32x4_t fracOne4 = vdupq_n_f32(1.0f/FRACTIONONE);
-    const int32x4_t fracMask4 = vdupq_n_s32(FRACTIONMASK);
-    alignas(16) ALuint pos_[4], frac_[4];
-    int32x4_t pos4, frac4;
-
-    InitPosArrays(frac, increment, frac_, pos_, 4);
-    frac4 = vld1q_s32(reinterpret_cast<int*>(frac_));
-    pos4 = vld1q_s32(reinterpret_cast<int*>(pos_));
-
-    auto dst_iter = dst.begin();
-    const auto aligned_end = (dst.size()&~3u) + dst_iter;
-    while(dst_iter != aligned_end)
-    {
-        const int pos0{vgetq_lane_s32(pos4, 0)};
-        const int pos1{vgetq_lane_s32(pos4, 1)};
-        const int pos2{vgetq_lane_s32(pos4, 2)};
-        const int pos3{vgetq_lane_s32(pos4, 3)};
-        const float32x4_t val1{src[pos0], src[pos1], src[pos2], src[pos3]};
-        const float32x4_t val2{src[pos0+1], src[pos1+1], src[pos2+1], src[pos3+1]};
-
-        /* val1 + (val2-val1)*mu */
-        const float32x4_t r0{vsubq_f32(val2, val1)};
-        const float32x4_t mu{vmulq_f32(vcvtq_f32_s32(frac4), fracOne4)};
-        const float32x4_t out{vmlaq_f32(val1, mu, r0)};
-
-        vst1q_f32(dst_iter, out);
-        dst_iter += 4;
-
-        frac4 = vaddq_s32(frac4, increment4);
-        pos4 = vaddq_s32(pos4, vshrq_n_s32(frac4, FRACTIONBITS));
-        frac4 = vandq_s32(frac4, fracMask4);
-    }
-
-    if(dst_iter != dst.end())
-    {
-        src += static_cast<ALuint>(vgetq_lane_s32(pos4, 0));
-        frac = static_cast<ALuint>(vgetq_lane_s32(frac4, 0));
-
-        do {
-            *(dst_iter++) = lerp(src[0], src[1], static_cast<float>(frac) * (1.0f/FRACTIONONE));
-
-            frac += increment;
-            src  += frac>>FRACTIONBITS;
-            frac &= FRACTIONMASK;
-        } while(dst_iter != dst.end());
-    }
-    return dst.begin();
-}
-
-template<>
-const ALfloat *Resample_<BSincTag,NEONTag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{
-    const float *const filter{state->bsinc.filter};
-    const float32x4_t sf4{vdupq_n_f32(state->bsinc.sf)};
-    const size_t m{state->bsinc.m};
-
-    src -= state->bsinc.l;
-    for(float &out_sample : dst)
-    {
-        // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-        const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-        const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-            (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-        // Apply the scale and phase interpolated filter.
-        float32x4_t r4{vdupq_n_f32(0.0f)};
-        {
-            const float32x4_t pf4{vdupq_n_f32(pf)};
-            const float *fil{filter + m*pi*4};
-            const float *phd{fil + m};
-            const float *scd{phd + m};
-            const float *spd{scd + m};
-            size_t td{m >> 2};
-            size_t j{0u};
-
-            do {
-                /* f = ((fil + sf*scd) + pf*(phd + sf*spd)) */
-                const float32x4_t f4 = vmlaq_f32(
-                    vmlaq_f32(vld1q_f32(fil), sf4, vld1q_f32(scd)),
-                    pf4, vmlaq_f32(vld1q_f32(phd), sf4, vld1q_f32(spd)));
-                fil += 4; scd += 4; phd += 4; spd += 4;
-                /* r += f*src */
-                r4 = vmlaq_f32(r4, f4, vld1q_f32(&src[j]));
-                j += 4;
-            } while(--td);
-        }
-        r4 = vaddq_f32(r4, vrev64q_f32(r4));
-        out_sample = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
-
-        frac += increment;
-        src  += frac>>FRACTIONBITS;
-        frac &= FRACTIONMASK;
-    }
-    return dst.begin();
-}
-
-template<>
-const ALfloat *Resample_<FastBSincTag,NEONTag>(const InterpState *state,
-    const ALfloat *RESTRICT src, ALuint frac, ALuint increment, const al::span<float> dst)
-{
-    const float *const filter{state->bsinc.filter};
-    const size_t m{state->bsinc.m};
-
-    src -= state->bsinc.l;
-    for(float &out_sample : dst)
-    {
-        // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-        const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-        const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-            (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-        // Apply the phase interpolated filter.
-        float32x4_t r4{vdupq_n_f32(0.0f)};
-        {
-            const float32x4_t pf4{vdupq_n_f32(pf)};
-            const float *fil{filter + m*pi*4};
-            const float *phd{fil + m};
-            size_t td{m >> 2};
-            size_t j{0u};
-
-            do {
-                /* f = fil + pf*phd */
-                const float32x4_t f4 = vmlaq_f32(vld1q_f32(fil), pf4, vld1q_f32(phd));
-                /* r += f*src */
-                r4 = vmlaq_f32(r4, f4, vld1q_f32(&src[j]));
-                fil += 4; phd += 4; j += 4;
-            } while(--td);
-        }
-        r4 = vaddq_f32(r4, vrev64q_f32(r4));
-        out_sample = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
-
-        frac += increment;
-        src  += frac>>FRACTIONBITS;
-        frac &= FRACTIONMASK;
-    }
-    return dst.begin();
-}
-
-
-template<>
-void MixHrtf_<NEONTag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize)
-{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
-
-template<>
-void MixHrtfBlend_<NEONTag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    const HrtfFilter *oldparams, MixHrtfFilter *newparams, const size_t BufferSize)
-{
-    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
-        BufferSize);
-}
-
-template<>
-void MixDirectHrtf_<NEONTag>(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
-    const size_t BufferSize)
-{ MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, State, BufferSize); }
-
-
-template<>
-void Mix_<NEONTag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
-    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
-{
-    const ALfloat delta{(Counter > 0) ? 1.0f / static_cast<ALfloat>(Counter) : 0.0f};
-    const bool reached_target{InSamples.size() >= Counter};
-    const auto min_end = reached_target ? InSamples.begin() + Counter : InSamples.end();
-    const auto aligned_end = minz(static_cast<uintptr_t>(min_end-InSamples.begin()+3) & ~3u,
-        InSamples.size()) + InSamples.begin();
-    for(FloatBufferLine &output : OutBuffer)
-    {
-        ALfloat *RESTRICT dst{al::assume_aligned<16>(output.data()+OutPos)};
-        ALfloat gain{*CurrentGains};
-        const ALfloat diff{*TargetGains - gain};
-
-        auto in_iter = InSamples.begin();
-        if(std::fabs(diff) > std::numeric_limits<float>::epsilon())
-        {
-            const ALfloat step{diff * delta};
-            ALfloat step_count{0.0f};
-            /* Mix with applying gain steps in aligned multiples of 4. */
-            if(ptrdiff_t todo{(min_end-in_iter) >> 2})
-            {
-                const float32x4_t four4{vdupq_n_f32(4.0f)};
-                const float32x4_t step4{vdupq_n_f32(step)};
-                const float32x4_t gain4{vdupq_n_f32(gain)};
-                float32x4_t step_count4{vsetq_lane_f32(0.0f,
-                    vsetq_lane_f32(1.0f,
-                    vsetq_lane_f32(2.0f,
-                    vsetq_lane_f32(3.0f, vdupq_n_f32(0.0f), 3),
-                    2), 1), 0
-                )};
-                do {
-                    const float32x4_t val4 = vld1q_f32(in_iter);
-                    float32x4_t dry4 = vld1q_f32(dst);
-                    dry4 = vmlaq_f32(dry4, val4, vmlaq_f32(gain4, step4, step_count4));
-                    step_count4 = vaddq_f32(step_count4, four4);
-                    vst1q_f32(dst, dry4);
-                    in_iter += 4; dst += 4;
-                } while(--todo);
-                /* NOTE: step_count4 now represents the next four counts after
-                 * the last four mixed samples, so the lowest element
-                 * represents the next step count to apply.
-                 */
-                step_count = vgetq_lane_f32(step_count4, 0);
-            }
-            /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
-            while(in_iter != min_end)
-            {
-                *(dst++) += *(in_iter++) * (gain + step*step_count);
-                step_count += 1.0f;
-            }
-            if(reached_target)
-                gain = *TargetGains;
-            else
-                gain += step*step_count;
-            *CurrentGains = gain;
-
-            /* Mix until pos is aligned with 4 or the mix is done. */
-            while(in_iter != aligned_end)
-                *(dst++) += *(in_iter++) * gain;
-        }
-        ++CurrentGains;
-        ++TargetGains;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-        if(ptrdiff_t todo{(InSamples.end()-in_iter) >> 2})
-        {
-            const float32x4_t gain4 = vdupq_n_f32(gain);
-            do {
-                const float32x4_t val4 = vld1q_f32(in_iter);
-                float32x4_t dry4 = vld1q_f32(dst);
-                dry4 = vmlaq_f32(dry4, val4, gain4);
-                vst1q_f32(dst, dry4);
-                in_iter += 4; dst += 4;
-            } while(--todo);
-        }
-        while(in_iter != InSamples.end())
-            *(dst++) += *(in_iter++) * gain;
-    }
-}
-
-template<>
-void MixRow_<NEONTag>(const al::span<float> OutBuffer, const al::span<const float> Gains,
-    const float *InSamples, const size_t InStride)
-{
-    for(const ALfloat gain : Gains)
-    {
-        const ALfloat *RESTRICT input{InSamples};
-        InSamples += InStride;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-
-        auto out_iter = OutBuffer.begin();
-        if(size_t todo{OutBuffer.size() >> 2})
-        {
-            const float32x4_t gain4{vdupq_n_f32(gain)};
-            do {
-                const float32x4_t val4 = vld1q_f32(input);
-                float32x4_t dry4 = vld1q_f32(out_iter);
-                dry4 = vmlaq_f32(dry4, val4, gain4);
-                vst1q_f32(out_iter, dry4);
-                out_iter += 4; input += 4;
-            } while(--todo);
-        }
-
-        auto do_mix = [gain](const float cur, const float src) noexcept -> float
-        { return cur + src*gain; };
-        std::transform(out_iter, OutBuffer.end(), input, out_iter, do_mix);
-    }
-}
diff --git a/alc/mixer/mixer_sse.cpp b/alc/mixer/mixer_sse.cpp
deleted file mode 100644
index aaf37df6..00000000
--- a/alc/mixer/mixer_sse.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-#include "config.h"
-
-#include <xmmintrin.h>
-
-#include <limits>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "alcmain.h"
-
-#include "alu.h"
-#include "defs.h"
-#include "hrtfbase.h"
-
-
-namespace {
-
-inline void ApplyCoeffs(float2 *RESTRICT Values, const ALuint IrSize, const HrirArray &Coeffs,
-    const float left, const float right)
-{
-    const __m128 lrlr{_mm_setr_ps(left, right, left, right)};
-
-    ASSUME(IrSize >= 4);
-    /* This isn't technically correct to test alignment, but it's true for
-     * systems that support SSE, which is the only one that needs to know the
-     * alignment of Values (which alternates between 8- and 16-byte aligned).
-     */
-    if(reinterpret_cast<intptr_t>(Values)&0x8)
-    {
-        __m128 imp0, imp1;
-        __m128 coeffs{_mm_load_ps(&Coeffs[0][0])};
-        __m128 vals{_mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64*>(&Values[0][0]))};
-        imp0 = _mm_mul_ps(lrlr, coeffs);
-        vals = _mm_add_ps(imp0, vals);
-        _mm_storel_pi(reinterpret_cast<__m64*>(&Values[0][0]), vals);
-        ALuint i{1};
-        for(;i < IrSize-1;i += 2)
-        {
-            coeffs = _mm_load_ps(&Coeffs[i+1][0]);
-            vals = _mm_load_ps(&Values[i][0]);
-            imp1 = _mm_mul_ps(lrlr, coeffs);
-            imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
-            vals = _mm_add_ps(imp0, vals);
-            _mm_store_ps(&Values[i][0], vals);
-            imp0 = imp1;
-        }
-        vals = _mm_loadl_pi(vals, reinterpret_cast<__m64*>(&Values[i][0]));
-        imp0 = _mm_movehl_ps(imp0, imp0);
-        vals = _mm_add_ps(imp0, vals);
-        _mm_storel_pi(reinterpret_cast<__m64*>(&Values[i][0]), vals);
-    }
-    else
-    {
-        for(ALuint i{0};i < IrSize;i += 2)
-        {
-            __m128 coeffs{_mm_load_ps(&Coeffs[i][0])};
-            __m128 vals{_mm_load_ps(&Values[i][0])};
-            vals = _mm_add_ps(vals, _mm_mul_ps(lrlr, coeffs));
-            _mm_store_ps(&Values[i][0], vals);
-        }
-    }
-}
-
-} // namespace
-
-template<>
-const ALfloat *Resample_<BSincTag,SSETag>(const InterpState *state, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
-{
-    const float *const filter{state->bsinc.filter};
-    const __m128 sf4{_mm_set1_ps(state->bsinc.sf)};
-    const size_t m{state->bsinc.m};
-
-    src -= state->bsinc.l;
-    for(float &out_sample : dst)
-    {
-        // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-        const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-        const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-            (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-        // Apply the scale and phase interpolated filter.
-        __m128 r4{_mm_setzero_ps()};
-        {
-            const __m128 pf4{_mm_set1_ps(pf)};
-            const float *fil{filter + m*pi*4};
-            const float *phd{fil + m};
-            const float *scd{phd + m};
-            const float *spd{scd + m};
-            size_t td{m >> 2};
-            size_t j{0u};
-
-#define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z))
-            do {
-                /* f = ((fil + sf*scd) + pf*(phd + sf*spd)) */
-                const __m128 f4 = MLA4(
-                    MLA4(_mm_load_ps(fil), sf4, _mm_load_ps(scd)),
-                    pf4, MLA4(_mm_load_ps(phd), sf4, _mm_load_ps(spd)));
-                fil += 4; scd += 4; phd += 4; spd += 4;
-                /* r += f*src */
-                r4 = MLA4(r4, f4, _mm_loadu_ps(&src[j]));
-                j += 4;
-            } while(--td);
-#undef MLA4
-        }
-        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
-        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
-        out_sample = _mm_cvtss_f32(r4);
-
-        frac += increment;
-        src  += frac>>FRACTIONBITS;
-        frac &= FRACTIONMASK;
-    }
-    return dst.begin();
-}
-
-template<>
-const ALfloat *Resample_<FastBSincTag,SSETag>(const InterpState *state,
-    const ALfloat *RESTRICT src, ALuint frac, ALuint increment, const al::span<float> dst)
-{
-    const float *const filter{state->bsinc.filter};
-    const size_t m{state->bsinc.m};
-
-    src -= state->bsinc.l;
-    for(float &out_sample : dst)
-    {
-        // Calculate the phase index and factor.
-#define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
-        const ALuint pi{frac >> FRAC_PHASE_BITDIFF};
-        const float pf{static_cast<float>(frac & ((1<<FRAC_PHASE_BITDIFF)-1)) *
-            (1.0f/(1<<FRAC_PHASE_BITDIFF))};
-#undef FRAC_PHASE_BITDIFF
-
-        // Apply the phase interpolated filter.
-        __m128 r4{_mm_setzero_ps()};
-        {
-            const __m128 pf4{_mm_set1_ps(pf)};
-            const float *fil{filter + m*pi*4};
-            const float *phd{fil + m};
-            size_t td{m >> 2};
-            size_t j{0u};
-
-#define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z))
-            do {
-                /* f = fil + pf*phd */
-                const __m128 f4 = MLA4(_mm_load_ps(fil), pf4, _mm_load_ps(phd));
-                /* r += f*src */
-                r4 = MLA4(r4, f4, _mm_loadu_ps(&src[j]));
-                fil += 4; phd += 4; j += 4;
-            } while(--td);
-#undef MLA4
-        }
-        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
-        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
-        out_sample = _mm_cvtss_f32(r4);
-
-        frac += increment;
-        src  += frac>>FRACTIONBITS;
-        frac &= FRACTIONMASK;
-    }
-    return dst.begin();
-}
-
-
-template<>
-void MixHrtf_<SSETag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize)
-{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
-
-template<>
-void MixHrtfBlend_<SSETag>(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    const HrtfFilter *oldparams, MixHrtfFilter *newparams, const size_t BufferSize)
-{
-    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
-        BufferSize);
-}
-
-template<>
-void MixDirectHrtf_<SSETag>(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
-    const size_t BufferSize)
-{ MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, State, BufferSize); }
-
-
-template<>
-void Mix_<SSETag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
-    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
-{
-    const ALfloat delta{(Counter > 0) ? 1.0f / static_cast<ALfloat>(Counter) : 0.0f};
-    const bool reached_target{InSamples.size() >= Counter};
-    const auto min_end = reached_target ? InSamples.begin() + Counter : InSamples.end();
-    const auto aligned_end = minz(static_cast<uintptr_t>(min_end-InSamples.begin()+3) & ~3u,
-        InSamples.size()) + InSamples.begin();
-    for(FloatBufferLine &output : OutBuffer)
-    {
-        ALfloat *RESTRICT dst{al::assume_aligned<16>(output.data()+OutPos)};
-        ALfloat gain{*CurrentGains};
-        const ALfloat diff{*TargetGains - gain};
-
-        auto in_iter = InSamples.begin();
-        if(std::fabs(diff) > std::numeric_limits<float>::epsilon())
-        {
-            const ALfloat step{diff * delta};
-            ALfloat step_count{0.0f};
-            /* Mix with applying gain steps in aligned multiples of 4. */
-            if(ptrdiff_t todo{(min_end-in_iter) >> 2})
-            {
-                const __m128 four4{_mm_set1_ps(4.0f)};
-                const __m128 step4{_mm_set1_ps(step)};
-                const __m128 gain4{_mm_set1_ps(gain)};
-                __m128 step_count4{_mm_setr_ps(0.0f, 1.0f, 2.0f, 3.0f)};
-                do {
-                    const __m128 val4{_mm_load_ps(in_iter)};
-                    __m128 dry4{_mm_load_ps(dst)};
-#define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z))
-                    /* dry += val * (gain + step*step_count) */
-                    dry4 = MLA4(dry4, val4, MLA4(gain4, step4, step_count4));
-#undef MLA4
-                    _mm_store_ps(dst, dry4);
-                    step_count4 = _mm_add_ps(step_count4, four4);
-                    in_iter += 4; dst += 4;
-                } while(--todo);
-                /* NOTE: step_count4 now represents the next four counts after
-                 * the last four mixed samples, so the lowest element
-                 * represents the next step count to apply.
-                 */
-                step_count = _mm_cvtss_f32(step_count4);
-            }
-            /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
-            while(in_iter != min_end)
-            {
-                *(dst++) += *(in_iter++) * (gain + step*step_count);
-                step_count += 1.0f;
-            }
-            if(reached_target)
-                gain = *TargetGains;
-            else
-                gain += step*step_count;
-            *CurrentGains = gain;
-
-            /* Mix until pos is aligned with 4 or the mix is done. */
-            while(in_iter != aligned_end)
-                *(dst++) += *(in_iter++) * gain;
-        }
-        ++CurrentGains;
-        ++TargetGains;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-        if(ptrdiff_t todo{(InSamples.end()-in_iter) >> 2})
-        {
-            const __m128 gain4{_mm_set1_ps(gain)};
-            do {
-                const __m128 val4{_mm_load_ps(in_iter)};
-                __m128 dry4{_mm_load_ps(dst)};
-                dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
-                _mm_store_ps(dst, dry4);
-                in_iter += 4; dst += 4;
-            } while(--todo);
-        }
-        while(in_iter != InSamples.end())
-            *(dst++) += *(in_iter++) * gain;
-    }
-}
-
-template<>
-void MixRow_<SSETag>(const al::span<float> OutBuffer, const al::span<const float> Gains,
-    const float *InSamples, const size_t InStride)
-{
-    for(const float gain : Gains)
-    {
-        const float *RESTRICT input{InSamples};
-        InSamples += InStride;
-
-        if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
-            continue;
-
-        auto out_iter = OutBuffer.begin();
-        if(size_t todo{OutBuffer.size() >> 2})
-        {
-            const __m128 gain4 = _mm_set1_ps(gain);
-            do {
-                const __m128 val4{_mm_load_ps(input)};
-                __m128 dry4{_mm_load_ps(out_iter)};
-                dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
-                _mm_store_ps(out_iter, dry4);
-                out_iter += 4; input += 4;
-            } while(--todo);
-        }
-
-        auto do_mix = [gain](const float cur, const float src) noexcept -> float
-        { return cur + src*gain; };
-        std::transform(out_iter, OutBuffer.end(), input, out_iter, do_mix);
-    }
-}
diff --git a/alc/panning.cpp b/alc/panning.cpp
index e85222bd..d118f99c 100644
--- a/alc/panning.cpp
+++ b/alc/panning.cpp
@@ -22,6 +22,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cassert>
 #include <chrono>
 #include <cmath>
 #include <cstdio>
@@ -38,33 +39,27 @@
 #include "AL/alext.h"
 
 #include "al/auxeffectslot.h"
-#include "alcmain.h"
+#include "albit.h"
 #include "alconfig.h"
+#include "alc/context.h"
 #include "almalloc.h"
+#include "alnumbers.h"
 #include "alnumeric.h"
 #include "aloptional.h"
 #include "alspan.h"
 #include "alstring.h"
 #include "alu.h"
-#include "ambdec.h"
-#include "ambidefs.h"
-#include "bformatdec.h"
-#include "bs2b.h"
-#include "devformat.h"
-#include "hrtf.h"
-#include "logging.h"
-#include "math_defs.h"
+#include "core/ambdec.h"
+#include "core/ambidefs.h"
+#include "core/bformatdec.h"
+#include "core/bs2b.h"
+#include "core/devformat.h"
+#include "core/front_stablizer.h"
+#include "core/hrtf.h"
+#include "core/logging.h"
+#include "core/uhjfilter.h"
+#include "device.h"
 #include "opthelpers.h"
-#include "uhjfilter.h"
-
-
-constexpr std::array<float,MAX_AMBI_CHANNELS> AmbiScale::FromN3D;
-constexpr std::array<float,MAX_AMBI_CHANNELS> AmbiScale::FromSN3D;
-constexpr std::array<float,MAX_AMBI_CHANNELS> AmbiScale::FromFuMa;
-constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> AmbiIndex::FromFuMa;
-constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> AmbiIndex::FromACN;
-constexpr std::array<uint8_t,MAX_AMBI2D_CHANNELS> AmbiIndex::From2D;
-constexpr std::array<uint8_t,MAX_AMBI_CHANNELS> AmbiIndex::From3D;
 
 
 namespace {
@@ -87,31 +82,30 @@ inline const char *GetLabelFromChannel(Channel channel)
         case SideLeft: return "side-left";
         case SideRight: return "side-right";
 
-        case UpperFrontLeft: return "upper-front-left";
-        case UpperFrontRight: return "upper-front-right";
-        case UpperBackLeft: return "upper-back-left";
-        case UpperBackRight: return "upper-back-right";
-        case LowerFrontLeft: return "lower-front-left";
-        case LowerFrontRight: return "lower-front-right";
-        case LowerBackLeft: return "lower-back-left";
-        case LowerBackRight: return "lower-back-right";
-
-        case Aux0: return "aux-0";
-        case Aux1: return "aux-1";
-        case Aux2: return "aux-2";
-        case Aux3: return "aux-3";
-        case Aux4: return "aux-4";
-        case Aux5: return "aux-5";
-        case Aux6: return "aux-6";
-        case Aux7: return "aux-7";
-        case Aux8: return "aux-8";
-        case Aux9: return "aux-9";
-        case Aux10: return "aux-10";
-        case Aux11: return "aux-11";
-        case Aux12: return "aux-12";
-        case Aux13: return "aux-13";
-        case Aux14: return "aux-14";
-        case Aux15: return "aux-15";
+        case TopFrontLeft: return "top-front-left";
+        case TopFrontCenter: return "top-front-center";
+        case TopFrontRight: return "top-front-right";
+        case TopCenter: return "top-center";
+        case TopBackLeft: return "top-back-left";
+        case TopBackCenter: return "top-back-center";
+        case TopBackRight: return "top-back-right";
+
+        case Aux0: return "Aux0";
+        case Aux1: return "Aux1";
+        case Aux2: return "Aux2";
+        case Aux3: return "Aux3";
+        case Aux4: return "Aux4";
+        case Aux5: return "Aux5";
+        case Aux6: return "Aux6";
+        case Aux7: return "Aux7";
+        case Aux8: return "Aux8";
+        case Aux9: return "Aux9";
+        case Aux10: return "Aux10";
+        case Aux11: return "Aux11";
+        case Aux12: return "Aux12";
+        case Aux13: return "Aux13";
+        case Aux14: return "Aux14";
+        case Aux15: return "Aux15";
 
         case MaxChannels: break;
     }
@@ -119,17 +113,31 @@ inline const char *GetLabelFromChannel(Channel channel)
 }
 
 
-void AllocChannels(ALCdevice *device, const ALuint main_chans, const ALuint real_chans)
+std::unique_ptr<FrontStablizer> CreateStablizer(const size_t outchans, const uint srate)
 {
-    TRACE("Channel config, Main: %u, Real: %u\n", main_chans, real_chans);
+    auto stablizer = FrontStablizer::Create(outchans);
+
+    /* Initialize band-splitting filter for the mid signal, with a crossover at
+     * 5khz (could be higher).
+     */
+    stablizer->MidFilter.init(5000.0f / static_cast<float>(srate));
+    for(auto &filter : stablizer->ChannelFilters)
+        filter = stablizer->MidFilter;
+
+    return stablizer;
+}
+
+void AllocChannels(ALCdevice *device, const size_t main_chans, const size_t real_chans)
+{
+    TRACE("Channel config, Main: %zu, Real: %zu\n", main_chans, real_chans);
 
     /* Allocate extra channels for any post-filter output. */
-    const ALuint num_chans{main_chans + real_chans};
+    const size_t num_chans{main_chans + real_chans};
 
-    TRACE("Allocating %u channels, %zu bytes\n", num_chans,
+    TRACE("Allocating %zu channels, %zu bytes\n", num_chans,
         num_chans*sizeof(device->MixBuffer[0]));
     device->MixBuffer.resize(num_chans);
-    al::span<FloatBufferLine> buffer{device->MixBuffer.data(), device->MixBuffer.size()};
+    al::span<FloatBufferLine> buffer{device->MixBuffer};
 
     device->Dry.Buffer = buffer.first(main_chans);
     buffer = buffer.subspan(main_chans);
@@ -143,168 +151,122 @@ void AllocChannels(ALCdevice *device, const ALuint main_chans, const ALuint real
 }
 
 
-struct ChannelMap {
-    Channel ChanName;
-    ALfloat Config[MAX_AMBI2D_CHANNELS];
+using ChannelCoeffs = std::array<float,MaxAmbiChannels>;
+enum DecoderMode : bool {
+    SingleBand = false,
+    DualBand = true
 };
 
-bool MakeSpeakerMap(ALCdevice *device, const AmbDecConf *conf, ALuint (&speakermap)[MAX_OUTPUT_CHANNELS])
-{
-    auto map_spkr = [device](const AmbDecConf::SpeakerConf &speaker) -> ALuint
-    {
-        /* NOTE: AmbDec does not define any standard speaker names, however
-         * for this to work we have to by able to find the output channel
-         * the speaker definition corresponds to. Therefore, OpenAL Soft
-         * requires these channel labels to be recognized:
-         *
-         * LF = Front left
-         * RF = Front right
-         * LS = Side left
-         * RS = Side right
-         * LB = Back left
-         * RB = Back right
-         * CE = Front center
-         * CB = Back center
-         *
-         * Additionally, surround51 will acknowledge back speakers for side
-         * channels, and surround51rear will acknowledge side speakers for
-         * back channels, to avoid issues with an ambdec expecting 5.1 to
-         * use the side channels when the device is configured for back,
-         * and vice-versa.
-         */
-        Channel ch{};
-        if(speaker.Name == "LF")
-            ch = FrontLeft;
-        else if(speaker.Name == "RF")
-            ch = FrontRight;
-        else if(speaker.Name == "CE")
-            ch = FrontCenter;
-        else if(speaker.Name == "LS")
-        {
-            if(device->FmtChans == DevFmtX51Rear)
-                ch = BackLeft;
-            else
-                ch = SideLeft;
-        }
-        else if(speaker.Name == "RS")
-        {
-            if(device->FmtChans == DevFmtX51Rear)
-                ch = BackRight;
-            else
-                ch = SideRight;
-        }
-        else if(speaker.Name == "LB")
-        {
-            if(device->FmtChans == DevFmtX51)
-                ch = SideLeft;
-            else
-                ch = BackLeft;
-        }
-        else if(speaker.Name == "RB")
-        {
-            if(device->FmtChans == DevFmtX51)
-                ch = SideRight;
-            else
-                ch = BackRight;
-        }
-        else if(speaker.Name == "CB")
-            ch = BackCenter;
-        else
-        {
-            const char *name{speaker.Name.c_str()};
-            unsigned int n;
-            char c;
+template<DecoderMode Mode, size_t N>
+struct DecoderConfig;
+
+template<size_t N>
+struct DecoderConfig<SingleBand, N> {
+    uint8_t mOrder{};
+    bool mIs3D{};
+    std::array<Channel,N> mChannels{};
+    DevAmbiScaling mScaling{};
+    std::array<float,MaxAmbiOrder+1> mOrderGain{};
+    std::array<ChannelCoeffs,N> mCoeffs{};
+};
 
-            if(sscanf(name, "AUX%u%c", &n, &c) == 1 && n < 16)
-                ch = static_cast<Channel>(Aux0+n);
-            else
-            {
-                ERR("AmbDec speaker label \"%s\" not recognized\n", name);
-                return INVALID_CHANNEL_INDEX;
-            }
-        }
-        const ALuint chidx{GetChannelIdxByName(device->RealOut, ch)};
-        if(chidx == INVALID_CHANNEL_INDEX)
-            ERR("Failed to lookup AmbDec speaker label %s\n", speaker.Name.c_str());
-        return chidx;
-    };
-    std::transform(conf->Speakers.begin(), conf->Speakers.end(), std::begin(speakermap), map_spkr);
-    /* Return success if no invalid entries are found. */
-    auto spkrmap_end = std::begin(speakermap) + conf->Speakers.size();
-    return std::find(std::begin(speakermap), spkrmap_end, INVALID_CHANNEL_INDEX) == spkrmap_end;
-}
+template<size_t N>
+struct DecoderConfig<DualBand, N> {
+    uint8_t mOrder{};
+    bool mIs3D{};
+    std::array<Channel,N> mChannels{};
+    DevAmbiScaling mScaling{};
+    std::array<float,MaxAmbiOrder+1> mOrderGain{};
+    std::array<ChannelCoeffs,N> mCoeffs{};
+    std::array<float,MaxAmbiOrder+1> mOrderGainLF{};
+    std::array<ChannelCoeffs,N> mCoeffsLF{};
+};
+
+template<>
+struct DecoderConfig<DualBand, 0> {
+    uint8_t mOrder{};
+    bool mIs3D{};
+    al::span<const Channel> mChannels;
+    DevAmbiScaling mScaling{};
+    al::span<const float> mOrderGain;
+    al::span<const ChannelCoeffs> mCoeffs;
+    al::span<const float> mOrderGainLF;
+    al::span<const ChannelCoeffs> mCoeffsLF;
+
+    template<size_t N>
+    DecoderConfig& operator=(const DecoderConfig<SingleBand,N> &rhs) noexcept
+    {
+        mOrder = rhs.mOrder;
+        mIs3D = rhs.mIs3D;
+        mChannels = rhs.mChannels;
+        mScaling = rhs.mScaling;
+        mOrderGain = rhs.mOrderGain;
+        mCoeffs = rhs.mCoeffs;
+        mOrderGainLF = {};
+        mCoeffsLF = {};
+        return *this;
+    }
 
+    template<size_t N>
+    DecoderConfig& operator=(const DecoderConfig<DualBand,N> &rhs) noexcept
+    {
+        mOrder = rhs.mOrder;
+        mIs3D = rhs.mIs3D;
+        mChannels = rhs.mChannels;
+        mScaling = rhs.mScaling;
+        mOrderGain = rhs.mOrderGain;
+        mCoeffs = rhs.mCoeffs;
+        mOrderGainLF = rhs.mOrderGainLF;
+        mCoeffsLF = rhs.mCoeffsLF;
+        return *this;
+    }
 
-constexpr ChannelMap MonoCfg[1] = {
-    { FrontCenter, { 1.0f } },
-}, StereoCfg[2] = {
-    { FrontLeft,   { 5.00000000e-1f,  2.88675135e-1f,  5.52305643e-2f } },
-    { FrontRight,  { 5.00000000e-1f, -2.88675135e-1f,  5.52305643e-2f } },
-}, QuadCfg[4] = {
-    { BackLeft,    { 3.53553391e-1f,  2.04124145e-1f, -2.04124145e-1f } },
-    { FrontLeft,   { 3.53553391e-1f,  2.04124145e-1f,  2.04124145e-1f } },
-    { FrontRight,  { 3.53553391e-1f, -2.04124145e-1f,  2.04124145e-1f } },
-    { BackRight,   { 3.53553391e-1f, -2.04124145e-1f, -2.04124145e-1f } },
-}, X51SideCfg[4] = {
-    { SideLeft,    { 3.33000782e-1f,  1.89084803e-1f, -2.00042375e-1f, -2.12307769e-2f, -1.14579885e-2f } },
-    { FrontLeft,   { 1.88542860e-1f,  1.27709292e-1f,  1.66295695e-1f,  7.30571517e-2f,  2.10901184e-2f } },
-    { FrontRight,  { 1.88542860e-1f, -1.27709292e-1f,  1.66295695e-1f, -7.30571517e-2f,  2.10901184e-2f } },
-    { SideRight,   { 3.33000782e-1f, -1.89084803e-1f, -2.00042375e-1f,  2.12307769e-2f, -1.14579885e-2f } },
-}, X51RearCfg[4] = {
-    { BackLeft,    { 3.33000782e-1f,  1.89084803e-1f, -2.00042375e-1f, -2.12307769e-2f, -1.14579885e-2f } },
-    { FrontLeft,   { 1.88542860e-1f,  1.27709292e-1f,  1.66295695e-1f,  7.30571517e-2f,  2.10901184e-2f } },
-    { FrontRight,  { 1.88542860e-1f, -1.27709292e-1f,  1.66295695e-1f, -7.30571517e-2f,  2.10901184e-2f } },
-    { BackRight,   { 3.33000782e-1f, -1.89084803e-1f, -2.00042375e-1f,  2.12307769e-2f, -1.14579885e-2f } },
-}, X61Cfg[6] = {
-    { SideLeft,    { 2.04460341e-1f,  2.17177926e-1f, -4.39996780e-2f, -2.60790269e-2f, -6.87239792e-2f } },
-    { FrontLeft,   { 1.58923161e-1f,  9.21772680e-2f,  1.59658796e-1f,  6.66278083e-2f,  3.84686854e-2f } },
-    { FrontRight,  { 1.58923161e-1f, -9.21772680e-2f,  1.59658796e-1f, -6.66278083e-2f,  3.84686854e-2f } },
-    { SideRight,   { 2.04460341e-1f, -2.17177926e-1f, -4.39996780e-2f,  2.60790269e-2f, -6.87239792e-2f } },
-    { BackCenter,  { 2.50001688e-1f,  0.00000000e+0f, -2.50000094e-1f,  0.00000000e+0f,  6.05133395e-2f } },
-}, X71Cfg[6] = {
-    { BackLeft,    { 2.04124145e-1f,  1.08880247e-1f, -1.88586120e-1f, -1.29099444e-1f,  7.45355993e-2f,  3.73460789e-2f,  0.00000000e+0f } },
-    { SideLeft,    { 2.04124145e-1f,  2.17760495e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.49071198e-1f, -3.73460789e-2f,  0.00000000e+0f } },
-    { FrontLeft,   { 2.04124145e-1f,  1.08880247e-1f,  1.88586120e-1f,  1.29099444e-1f,  7.45355993e-2f,  3.73460789e-2f,  0.00000000e+0f } },
-    { FrontRight,  { 2.04124145e-1f, -1.08880247e-1f,  1.88586120e-1f, -1.29099444e-1f,  7.45355993e-2f, -3.73460789e-2f,  0.00000000e+0f } },
-    { SideRight,   { 2.04124145e-1f, -2.17760495e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.49071198e-1f,  3.73460789e-2f,  0.00000000e+0f } },
-    { BackRight,   { 2.04124145e-1f, -1.08880247e-1f, -1.88586120e-1f,  1.29099444e-1f,  7.45355993e-2f, -3.73460789e-2f,  0.00000000e+0f } },
+    explicit operator bool() const noexcept { return !mChannels.empty(); }
 };
+using DecoderView = DecoderConfig<DualBand, 0>;
 
-void InitNearFieldCtrl(ALCdevice *device, ALfloat ctrl_dist, ALuint order,
-    const al::span<const ALuint,MAX_AMBI_ORDER+1> chans_per_order)
+
+void InitNearFieldCtrl(ALCdevice *device, float ctrl_dist, uint order, bool is3d)
 {
+    static const uint chans_per_order2d[MaxAmbiOrder+1]{ 1, 2, 2, 2 };
+    static const uint chans_per_order3d[MaxAmbiOrder+1]{ 1, 3, 5, 7 };
+
     /* NFC is only used when AvgSpeakerDist is greater than 0. */
-    const char *devname{device->DeviceName.c_str()};
-    if(!GetConfigValueBool(devname, "decoder", "nfc", 0) || !(ctrl_dist > 0.0f))
+    if(!device->getConfigValueBool("decoder", "nfc", false) || !(ctrl_dist > 0.0f))
         return;
 
     device->AvgSpeakerDist = clampf(ctrl_dist, 0.1f, 10.0f);
     TRACE("Using near-field reference distance: %.2f meters\n", device->AvgSpeakerDist);
 
-    auto iter = std::copy(chans_per_order.begin(), chans_per_order.begin()+order+1,
+    const float w1{SpeedOfSoundMetersPerSec /
+        (device->AvgSpeakerDist * static_cast<float>(device->Frequency))};
+    device->mNFCtrlFilter.init(w1);
+
+    auto iter = std::copy_n(is3d ? chans_per_order3d : chans_per_order2d, order+1u,
         std::begin(device->NumChannelsPerOrder));
     std::fill(iter, std::end(device->NumChannelsPerOrder), 0u);
 }
 
-void InitDistanceComp(ALCdevice *device, const AmbDecConf *conf,
-    const ALuint (&speakermap)[MAX_OUTPUT_CHANNELS])
+void InitDistanceComp(ALCdevice *device, const al::span<const Channel> channels,
+    const al::span<const float,MAX_OUTPUT_CHANNELS> dists)
 {
-    auto get_max = std::bind(maxf, _1,
-        std::bind(std::mem_fn(&AmbDecConf::SpeakerConf::Distance), _2));
-    const ALfloat maxdist{
-        std::accumulate(conf->Speakers.begin(), conf->Speakers.end(), float{0.0f}, get_max)};
+    const float maxdist{std::accumulate(std::begin(dists), std::end(dists), 0.0f, maxf)};
 
-    const char *devname{device->DeviceName.c_str()};
-    if(!GetConfigValueBool(devname, "decoder", "distance-comp", 1) || !(maxdist > 0.0f))
+    if(!device->getConfigValueBool("decoder", "distance-comp", true) || !(maxdist > 0.0f))
         return;
 
-    const auto distSampleScale = static_cast<ALfloat>(device->Frequency)/SPEEDOFSOUNDMETRESPERSEC;
-    const auto ChanDelay = device->ChannelDelay.as_span();
+    const auto distSampleScale = static_cast<float>(device->Frequency) / SpeedOfSoundMetersPerSec;
+    std::vector<DistanceComp::ChanData> ChanDelay;
+    ChanDelay.reserve(device->RealOut.Buffer.size());
     size_t total{0u};
-    for(size_t i{0u};i < conf->Speakers.size();i++)
+    for(size_t chidx{0};chidx < channels.size();++chidx)
     {
-        const AmbDecConf::SpeakerConf &speaker = conf->Speakers[i];
-        const ALuint chan{speakermap[i]};
+        const Channel ch{channels[chidx]};
+        const uint idx{device->RealOut.ChannelIndex[ch]};
+        if(idx == InvalidChannelIndex)
+            continue;
+
+        const float distance{dists[chidx]};
 
         /* Distance compensation only delays in steps of the sample rate. This
          * is a bit less accurate since the delay time falls to the nearest
@@ -312,259 +274,495 @@ void InitDistanceComp(ALCdevice *device, const AmbDecConf *conf,
          * phase offsets. This means at 48khz, for instance, the distance delay
          * will be in steps of about 7 millimeters.
          */
-        ALfloat delay{std::floor((maxdist - speaker.Distance)*distSampleScale + 0.5f)};
-        if(delay > ALfloat{MAX_DELAY_LENGTH-1})
+        float delay{std::floor((maxdist - distance)*distSampleScale + 0.5f)};
+        if(delay > float{DistanceComp::MaxDelay-1})
         {
-            ERR("Delay for speaker \"%s\" exceeds buffer length (%f > %d)\n",
-                speaker.Name.c_str(), delay, MAX_DELAY_LENGTH-1);
-            delay = ALfloat{MAX_DELAY_LENGTH-1};
+            ERR("Delay for channel %u (%s) exceeds buffer length (%f > %d)\n", idx,
+                GetLabelFromChannel(ch), delay, DistanceComp::MaxDelay-1);
+            delay = float{DistanceComp::MaxDelay-1};
         }
 
-        ChanDelay[chan].Length = static_cast<ALuint>(delay);
-        ChanDelay[chan].Gain = speaker.Distance / maxdist;
-        TRACE("Channel %u \"%s\" distance compensation: %u samples, %f gain\n", chan,
-            speaker.Name.c_str(), ChanDelay[chan].Length, ChanDelay[chan].Gain);
+        ChanDelay.resize(maxz(ChanDelay.size(), idx+1));
+        ChanDelay[idx].Length = static_cast<uint>(delay);
+        ChanDelay[idx].Gain = distance / maxdist;
+        TRACE("Channel %s distance comp: %u samples, %f gain\n", GetLabelFromChannel(ch),
+            ChanDelay[idx].Length, ChanDelay[idx].Gain);
 
         /* Round up to the next 4th sample, so each channel buffer starts
          * 16-byte aligned.
          */
-        total += RoundUp(ChanDelay[chan].Length, 4);
+        total += RoundUp(ChanDelay[idx].Length, 4);
     }
 
     if(total > 0)
     {
-        device->ChannelDelay.setSampleCount(total);
-        ChanDelay[0].Buffer = device->ChannelDelay.getSamples();
-        auto set_bufptr = [](const DistanceComp::DistData &last, const DistanceComp::DistData &cur) -> DistanceComp::DistData
+        auto chandelays = DistanceComp::Create(total);
+
+        ChanDelay[0].Buffer = chandelays->mSamples.data();
+        auto set_bufptr = [](const DistanceComp::ChanData &last, const DistanceComp::ChanData &cur)
+            -> DistanceComp::ChanData
         {
-            DistanceComp::DistData ret{cur};
+            DistanceComp::ChanData ret{cur};
             ret.Buffer = last.Buffer + RoundUp(last.Length, 4);
             return ret;
         };
-        std::partial_sum(ChanDelay.begin(), ChanDelay.end(), ChanDelay.begin(), set_bufptr);
+        std::partial_sum(ChanDelay.begin(), ChanDelay.end(), chandelays->mChannels.begin(),
+            set_bufptr);
+        device->ChannelDelays = std::move(chandelays);
     }
 }
 
 
-auto GetAmbiScales(AmbiNorm scaletype) noexcept -> const std::array<float,MAX_AMBI_CHANNELS>&
+inline auto& GetAmbiScales(DevAmbiScaling scaletype) noexcept
 {
-    if(scaletype == AmbiNorm::FuMa) return AmbiScale::FromFuMa;
-    if(scaletype == AmbiNorm::SN3D) return AmbiScale::FromSN3D;
-    return AmbiScale::FromN3D;
+    if(scaletype == DevAmbiScaling::FuMa) return AmbiScale::FromFuMa();
+    if(scaletype == DevAmbiScaling::SN3D) return AmbiScale::FromSN3D();
+    return AmbiScale::FromN3D();
 }
 
-auto GetAmbiLayout(AmbiLayout layouttype) noexcept -> const std::array<uint8_t,MAX_AMBI_CHANNELS>&
+inline auto& GetAmbiLayout(DevAmbiLayout layouttype) noexcept
 {
-    if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa;
-    return AmbiIndex::FromACN;
+    if(layouttype == DevAmbiLayout::FuMa) return AmbiIndex::FromFuMa();
+    return AmbiIndex::FromACN();
 }
 
 
-void InitPanning(ALCdevice *device)
+DecoderView MakeDecoderView(ALCdevice *device, const AmbDecConf *conf,
+    DecoderConfig<DualBand, MAX_OUTPUT_CHANNELS> &decoder)
 {
-    al::span<const ChannelMap> chanmap;
-    ALuint coeffcount{};
-
-    switch(device->FmtChans)
-    {
-        case DevFmtMono:
-            chanmap = MonoCfg;
-            coeffcount = 1;
-            break;
+    DecoderView ret{};
 
-        case DevFmtStereo:
-            chanmap = StereoCfg;
-            coeffcount = 3;
-            break;
-
-        case DevFmtQuad:
-            chanmap = QuadCfg;
-            coeffcount = 3;
-            break;
-
-        case DevFmtX51:
-            chanmap = X51SideCfg;
-            coeffcount = 5;
-            break;
-
-        case DevFmtX51Rear:
-            chanmap = X51RearCfg;
-            coeffcount = 5;
-            break;
+    decoder.mOrder = (conf->ChanMask > Ambi3OrderMask) ? uint8_t{4} :
+        (conf->ChanMask > Ambi2OrderMask) ? uint8_t{3} :
+        (conf->ChanMask > Ambi1OrderMask) ? uint8_t{2} : uint8_t{1};
+    decoder.mIs3D = (conf->ChanMask&AmbiPeriphonicMask) != 0;
 
-        case DevFmtX61:
-            chanmap = X61Cfg;
-            coeffcount = 5;
-            break;
+    switch(conf->CoeffScale)
+    {
+    case AmbDecScale::Unset: ASSUME(false); break;
+    case AmbDecScale::N3D: decoder.mScaling = DevAmbiScaling::N3D; break;
+    case AmbDecScale::SN3D: decoder.mScaling = DevAmbiScaling::SN3D; break;
+    case AmbDecScale::FuMa: decoder.mScaling = DevAmbiScaling::FuMa; break;
+    }
 
-        case DevFmtX71:
-            chanmap = X71Cfg;
-            coeffcount = 7;
-            break;
+    std::copy_n(std::begin(conf->HFOrderGain),
+        std::min(al::size(conf->HFOrderGain), al::size(decoder.mOrderGain)),
+        std::begin(decoder.mOrderGain));
+    std::copy_n(std::begin(conf->LFOrderGain),
+        std::min(al::size(conf->LFOrderGain), al::size(decoder.mOrderGainLF)),
+        std::begin(decoder.mOrderGainLF));
+
+    const auto num_coeffs = decoder.mIs3D ? AmbiChannelsFromOrder(decoder.mOrder)
+        : Ambi2DChannelsFromOrder(decoder.mOrder);
+    const auto idx_map = decoder.mIs3D ? AmbiIndex::FromACN().data()
+        : AmbiIndex::FromACN2D().data();
+    const auto hfmatrix = conf->HFMatrix;
+    const auto lfmatrix = conf->LFMatrix;
+
+    uint chan_count{0};
+    using const_speaker_span = al::span<const AmbDecConf::SpeakerConf>;
+    for(auto &speaker : const_speaker_span{conf->Speakers.get(), conf->NumSpeakers})
+    {
+        /* NOTE: AmbDec does not define any standard speaker names, however
+         * for this to work we have to by able to find the output channel
+         * the speaker definition corresponds to. Therefore, OpenAL Soft
+         * requires these channel labels to be recognized:
+         *
+         * LF = Front left
+         * RF = Front right
+         * LS = Side left
+         * RS = Side right
+         * LB = Back left
+         * RB = Back right
+         * CE = Front center
+         * CB = Back center
+         * LFT = Top front left
+         * RFT = Top front right
+         * LBT = Top back left
+         * RBT = Top back right
+         *
+         * Additionally, surround51 will acknowledge back speakers for side
+         * channels, to avoid issues with an ambdec expecting 5.1 to use the
+         * back channels.
+         */
+        Channel ch{};
+        if(speaker.Name == "LF")
+            ch = FrontLeft;
+        else if(speaker.Name == "RF")
+            ch = FrontRight;
+        else if(speaker.Name == "CE")
+            ch = FrontCenter;
+        else if(speaker.Name == "LS")
+            ch = SideLeft;
+        else if(speaker.Name == "RS")
+            ch = SideRight;
+        else if(speaker.Name == "LB")
+            ch = (device->FmtChans == DevFmtX51) ? SideLeft : BackLeft;
+        else if(speaker.Name == "RB")
+            ch = (device->FmtChans == DevFmtX51) ? SideRight : BackRight;
+        else if(speaker.Name == "CB")
+            ch = BackCenter;
+        else if(speaker.Name == "LFT")
+            ch = TopFrontLeft;
+        else if(speaker.Name == "RFT")
+            ch = TopFrontRight;
+        else if(speaker.Name == "LBT")
+            ch = TopBackLeft;
+        else if(speaker.Name == "RBT")
+            ch = TopBackRight;
+        else
+        {
+            int idx{};
+            char c{};
+            if(sscanf(speaker.Name.c_str(), "AUX%d%c", &idx, &c) != 1 || idx < 0
+                || idx >= MaxChannels-Aux0)
+            {
+                ERR("AmbDec speaker label \"%s\" not recognized\n", speaker.Name.c_str());
+                continue;
+            }
+            ch = static_cast<Channel>(Aux0+idx);
+        }
 
-        case DevFmtAmbi3D:
-            break;
+        decoder.mChannels[chan_count] = ch;
+        for(size_t dst{0};dst < num_coeffs;++dst)
+        {
+            const size_t src{idx_map[dst]};
+            decoder.mCoeffs[chan_count][dst] = hfmatrix[chan_count][src];
+        }
+        if(conf->FreqBands > 1)
+        {
+            for(size_t dst{0};dst < num_coeffs;++dst)
+            {
+                const size_t src{idx_map[dst]};
+                decoder.mCoeffsLF[chan_count][dst] = lfmatrix[chan_count][src];
+            }
+        }
+        ++chan_count;
     }
 
-    if(device->FmtChans == DevFmtAmbi3D)
+    if(chan_count > 0)
     {
-        const char *devname{device->DeviceName.c_str()};
-        const std::array<uint8_t,MAX_AMBI_CHANNELS> &acnmap = GetAmbiLayout(device->mAmbiLayout);
-        const std::array<float,MAX_AMBI_CHANNELS> &n3dscale = GetAmbiScales(device->mAmbiScale);
-
-        /* For DevFmtAmbi3D, the ambisonic order is already set. */
-        const size_t count{AmbiChannelsFromOrder(device->mAmbiOrder)};
-        std::transform(acnmap.begin(), acnmap.begin()+count, std::begin(device->Dry.AmbiMap),
-            [&n3dscale](const uint8_t &acn) noexcept -> BFChannelConfig
-            { return BFChannelConfig{1.0f/n3dscale[acn], acn}; }
-        );
-        AllocChannels(device, static_cast<ALuint>(count), 0);
-
-        ALfloat nfc_delay{ConfigValueFloat(devname, "decoder", "nfc-ref-delay").value_or(0.0f)};
-        if(nfc_delay > 0.0f)
+        ret.mOrder = decoder.mOrder;
+        ret.mIs3D = decoder.mIs3D;
+        ret.mScaling = decoder.mScaling;
+        ret.mChannels = {decoder.mChannels.data(), chan_count};
+        ret.mOrderGain = decoder.mOrderGain;
+        ret.mCoeffs = {decoder.mCoeffs.data(), chan_count};
+        if(conf->FreqBands > 1)
         {
-            static const ALuint chans_per_order[MAX_AMBI_ORDER+1]{ 1, 3, 5, 7 };
-            InitNearFieldCtrl(device, nfc_delay * SPEEDOFSOUNDMETRESPERSEC, device->mAmbiOrder,
-                chans_per_order);
+            ret.mOrderGainLF = decoder.mOrderGainLF;
+            ret.mCoeffsLF = {decoder.mCoeffsLF.data(), chan_count};
         }
     }
-    else
+    return ret;
+}
+
+constexpr DecoderConfig<SingleBand, 1> MonoConfig{
+    0, false, {{FrontCenter}},
+    DevAmbiScaling::N3D,
+    {{1.0f}},
+    {{ {{1.0f}} }}
+};
+constexpr DecoderConfig<SingleBand, 2> StereoConfig{
+    1, false, {{FrontLeft, FrontRight}},
+    DevAmbiScaling::N3D,
+    {{1.0f, 1.0f}},
+    {{
+        {{5.00000000e-1f,  2.88675135e-1f,  5.52305643e-2f}},
+        {{5.00000000e-1f, -2.88675135e-1f,  5.52305643e-2f}},
+    }}
+};
+constexpr DecoderConfig<DualBand, 4> QuadConfig{
+    1, false, {{BackLeft, FrontLeft, FrontRight, BackRight}},
+    DevAmbiScaling::N3D,
+    /*HF*/{{1.41421356e+0f, 1.00000000e+0f}},
+    {{
+        {{2.50000000e-1f,  2.04124145e-1f, -2.04124145e-1f}},
+        {{2.50000000e-1f,  2.04124145e-1f,  2.04124145e-1f}},
+        {{2.50000000e-1f, -2.04124145e-1f,  2.04124145e-1f}},
+        {{2.50000000e-1f, -2.04124145e-1f, -2.04124145e-1f}},
+    }},
+    /*LF*/{{1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{2.50000000e-1f,  2.04124145e-1f, -2.04124145e-1f}},
+        {{2.50000000e-1f,  2.04124145e-1f,  2.04124145e-1f}},
+        {{2.50000000e-1f, -2.04124145e-1f,  2.04124145e-1f}},
+        {{2.50000000e-1f, -2.04124145e-1f, -2.04124145e-1f}},
+    }}
+};
+constexpr DecoderConfig<DualBand, 5> X51Config{
+    2, false, {{SideLeft, FrontLeft, FrontCenter, FrontRight, SideRight}},
+    DevAmbiScaling::FuMa,
+    /*HF*/{{1.00000000e+0f, 1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{5.67316000e-1f,  4.22920000e-1f, -3.15495000e-1f, -6.34490000e-2f, -2.92380000e-2f}},
+        {{3.68584000e-1f,  2.72349000e-1f,  3.21616000e-1f,  1.92645000e-1f,  4.82600000e-2f}},
+        {{1.83579000e-1f,  0.00000000e+0f,  1.99588000e-1f,  0.00000000e+0f,  9.62820000e-2f}},
+        {{3.68584000e-1f, -2.72349000e-1f,  3.21616000e-1f, -1.92645000e-1f,  4.82600000e-2f}},
+        {{5.67316000e-1f, -4.22920000e-1f, -3.15495000e-1f,  6.34490000e-2f, -2.92380000e-2f}},
+    }},
+    /*LF*/{{1.00000000e+0f, 1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{4.90109850e-1f,  3.77305010e-1f, -3.73106990e-1f, -1.25914530e-1f,  1.45133000e-2f}},
+        {{1.49085730e-1f,  3.03561680e-1f,  1.53290060e-1f,  2.45112480e-1f, -1.50753130e-1f}},
+        {{1.37654920e-1f,  0.00000000e+0f,  4.49417940e-1f,  0.00000000e+0f,  2.57844070e-1f}},
+        {{1.49085730e-1f, -3.03561680e-1f,  1.53290060e-1f, -2.45112480e-1f, -1.50753130e-1f}},
+        {{4.90109850e-1f, -3.77305010e-1f, -3.73106990e-1f,  1.25914530e-1f,  1.45133000e-2f}},
+    }}
+};
+constexpr DecoderConfig<SingleBand, 5> X61Config{
+    2, false, {{SideLeft, FrontLeft, FrontRight, SideRight, BackCenter}},
+    DevAmbiScaling::N3D,
+    {{1.0f, 1.0f, 1.0f}},
+    {{
+        {{2.04460341e-1f,  2.17177926e-1f, -4.39996780e-2f, -2.60790269e-2f, -6.87239792e-2f}},
+        {{1.58923161e-1f,  9.21772680e-2f,  1.59658796e-1f,  6.66278083e-2f,  3.84686854e-2f}},
+        {{1.58923161e-1f, -9.21772680e-2f,  1.59658796e-1f, -6.66278083e-2f,  3.84686854e-2f}},
+        {{2.04460341e-1f, -2.17177926e-1f, -4.39996780e-2f,  2.60790269e-2f, -6.87239792e-2f}},
+        {{2.50001688e-1f,  0.00000000e+0f, -2.50000094e-1f,  0.00000000e+0f,  6.05133395e-2f}},
+    }}
+};
+constexpr DecoderConfig<DualBand, 6> X71Config{
+    2, false, {{BackLeft, SideLeft, FrontLeft, FrontRight, SideRight, BackRight}},
+    DevAmbiScaling::N3D,
+    /*HF*/{{1.41421356e+0f, 1.22474487e+0f, 7.07106781e-1f}},
+    {{
+        {{1.66666667e-1f,  9.62250449e-2f, -1.66666667e-1f, -1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f,  1.92450090e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.72132593e-1f}},
+        {{1.66666667e-1f,  9.62250449e-2f,  1.66666667e-1f,  1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f, -9.62250449e-2f,  1.66666667e-1f, -1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f, -1.92450090e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.72132593e-1f}},
+        {{1.66666667e-1f, -9.62250449e-2f, -1.66666667e-1f,  1.49071198e-1f,  8.60662966e-2f}},
+    }},
+    /*LF*/{{1.00000000e+0f, 1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{1.66666667e-1f,  9.62250449e-2f, -1.66666667e-1f, -1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f,  1.92450090e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.72132593e-1f}},
+        {{1.66666667e-1f,  9.62250449e-2f,  1.66666667e-1f,  1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f, -9.62250449e-2f,  1.66666667e-1f, -1.49071198e-1f,  8.60662966e-2f}},
+        {{1.66666667e-1f, -1.92450090e-1f,  0.00000000e+0f,  0.00000000e+0f, -1.72132593e-1f}},
+        {{1.66666667e-1f, -9.62250449e-2f, -1.66666667e-1f,  1.49071198e-1f,  8.60662966e-2f}},
+    }}
+};
+constexpr DecoderConfig<DualBand, 6> X3D71Config{
+    1, true, {{Aux0, SideLeft, FrontLeft, FrontRight, SideRight, Aux1}},
+    DevAmbiScaling::N3D,
+    /*HF*/{{1.73205081e+0f, 1.00000000e+0f}},
+    {{
+        {{1.666666667e-01f,  0.000000000e+00f,  2.356640879e-01f, -1.667265410e-01f}},
+        {{1.666666667e-01f,  2.033043281e-01f, -1.175581508e-01f, -1.678904388e-01f}},
+        {{1.666666667e-01f,  2.033043281e-01f,  1.175581508e-01f,  1.678904388e-01f}},
+        {{1.666666667e-01f, -2.033043281e-01f,  1.175581508e-01f,  1.678904388e-01f}},
+        {{1.666666667e-01f, -2.033043281e-01f, -1.175581508e-01f, -1.678904388e-01f}},
+        {{1.666666667e-01f,  0.000000000e+00f, -2.356640879e-01f,  1.667265410e-01f}},
+    }},
+    /*LF*/{{1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{1.666666667e-01f,  0.000000000e+00f,  2.356640879e-01f, -1.667265410e-01f}},
+        {{1.666666667e-01f,  2.033043281e-01f, -1.175581508e-01f, -1.678904388e-01f}},
+        {{1.666666667e-01f,  2.033043281e-01f,  1.175581508e-01f,  1.678904388e-01f}},
+        {{1.666666667e-01f, -2.033043281e-01f,  1.175581508e-01f,  1.678904388e-01f}},
+        {{1.666666667e-01f, -2.033043281e-01f, -1.175581508e-01f, -1.678904388e-01f}},
+        {{1.666666667e-01f,  0.000000000e+00f, -2.356640879e-01f,  1.667265410e-01f}},
+    }}
+};
+constexpr DecoderConfig<SingleBand, 10> X714Config{
+    1, true, {{FrontLeft, FrontRight, SideLeft, SideRight, BackLeft, BackRight, TopFrontLeft, TopFrontRight, TopBackLeft, TopBackRight }},
+    DevAmbiScaling::N3D,
+    {{1.00000000e+0f, 1.00000000e+0f, 1.00000000e+0f}},
+    {{
+        {{1.27149251e-01f,  7.63047539e-02f, -3.64373750e-02f,  1.59700680e-01f}},
+        {{1.07005418e-01f, -7.67638760e-02f, -4.92129762e-02f,  1.29012797e-01f}},
+        {{1.26400196e-01f,  1.77494694e-01f, -3.71203389e-02f,  0.00000000e+00f}},
+        {{1.26396516e-01f, -1.77488059e-01f, -3.71297878e-02f,  0.00000000e+00f}},
+        {{1.06996956e-01f,  7.67615256e-02f, -4.92166307e-02f, -1.29001640e-01f}},
+        {{1.27145671e-01f, -7.63003471e-02f, -3.64353304e-02f, -1.59697510e-01f}},
+        {{8.80919747e-02f,  7.48940670e-02f,  9.08786244e-02f,  6.22527183e-02f}},
+        {{1.57880745e-01f, -7.28755272e-02f,  1.82364187e-01f,  8.74240284e-02f}},
+        {{1.57892225e-01f,  7.28944768e-02f,  1.82363474e-01f, -8.74301086e-02f}},
+        {{8.80892603e-02f, -7.48948724e-02f,  9.08779842e-02f, -6.22480443e-02f}},
+    }}
+};
+
+void InitPanning(ALCdevice *device, const bool hqdec=false, const bool stablize=false,
+    DecoderView decoder={})
+{
+    if(!decoder)
     {
-        ChannelDec chancoeffs[MAX_OUTPUT_CHANNELS]{};
-        ALuint idxmap[MAX_OUTPUT_CHANNELS]{};
-        for(size_t i{0u};i < chanmap.size();++i)
+        switch(device->FmtChans)
         {
-            const ALuint idx{GetChannelIdxByName(device->RealOut, chanmap[i].ChanName)};
-            if(idx == INVALID_CHANNEL_INDEX)
+        case DevFmtMono: decoder = MonoConfig; break;
+        case DevFmtStereo: decoder = StereoConfig; break;
+        case DevFmtQuad: decoder = QuadConfig; break;
+        case DevFmtX51: decoder = X51Config; break;
+        case DevFmtX61: decoder = X61Config; break;
+        case DevFmtX71: decoder = X71Config; break;
+        case DevFmtX714: decoder = X714Config; break;
+        case DevFmtX3D71: decoder = X3D71Config; break;
+        case DevFmtAmbi3D:
+            auto&& acnmap = GetAmbiLayout(device->mAmbiLayout);
+            auto&& n3dscale = GetAmbiScales(device->mAmbiScale);
+
+            /* For DevFmtAmbi3D, the ambisonic order is already set. */
+            const size_t count{AmbiChannelsFromOrder(device->mAmbiOrder)};
+            std::transform(acnmap.begin(), acnmap.begin()+count, std::begin(device->Dry.AmbiMap),
+                [&n3dscale](const uint8_t &acn) noexcept -> BFChannelConfig
+                { return BFChannelConfig{1.0f/n3dscale[acn], acn}; });
+            AllocChannels(device, count, 0);
+            device->m2DMixing = false;
+
+            float avg_dist{};
+            if(auto distopt = device->configValue<float>("decoder", "speaker-dist"))
+                avg_dist = *distopt;
+            else if(auto delayopt = device->configValue<float>("decoder", "nfc-ref-delay"))
             {
-                ERR("Failed to find %s channel in device\n",
-                    GetLabelFromChannel(chanmap[i].ChanName));
-                continue;
+                WARN("nfc-ref-delay is deprecated, use speaker-dist instead\n");
+                avg_dist = *delayopt * SpeedOfSoundMetersPerSec;
             }
-            idxmap[i] = idx;
-            std::copy_n(chanmap[i].Config, coeffcount, chancoeffs[i]);
-        }
 
-        /* For non-DevFmtAmbi3D, set the ambisonic order given the mixing
-         * channel count. Built-in speaker decoders are always 2D, so just
-         * reverse that calculation.
-         */
-        device->mAmbiOrder = (coeffcount-1) / 2;
-
-        std::transform(AmbiIndex::From2D.begin(), AmbiIndex::From2D.begin()+coeffcount,
-            std::begin(device->Dry.AmbiMap),
-            [](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
-        );
-        AllocChannels(device, coeffcount, device->channelsFromFmt());
-
-        TRACE("Enabling %s-order%s ambisonic decoder\n",
-            (coeffcount > 5) ? "third" :
-            (coeffcount > 3) ? "second" : "first",
-            ""
-        );
-        device->AmbiDecoder = al::make_unique<BFormatDec>(coeffcount,
-            static_cast<ALsizei>(chanmap.size()), chancoeffs, idxmap);
+            InitNearFieldCtrl(device, avg_dist, device->mAmbiOrder, true);
+            return;
+        }
     }
-}
 
-void InitCustomPanning(ALCdevice *device, bool hqdec, const AmbDecConf *conf,
-    const ALuint (&speakermap)[MAX_OUTPUT_CHANNELS])
-{
-    static const ALuint chans_per_order2d[MAX_AMBI_ORDER+1] = { 1, 2, 2, 2 };
-    static const ALuint chans_per_order3d[MAX_AMBI_ORDER+1] = { 1, 3, 5, 7 };
+    const size_t ambicount{decoder.mIs3D ? AmbiChannelsFromOrder(decoder.mOrder) :
+        Ambi2DChannelsFromOrder(decoder.mOrder)};
+    const bool dual_band{hqdec && !decoder.mCoeffsLF.empty()};
+    al::vector<ChannelDec> chancoeffs, chancoeffslf;
+    for(size_t i{0u};i < decoder.mChannels.size();++i)
+    {
+        const uint idx{device->channelIdxByName(decoder.mChannels[i])};
+        if(idx == InvalidChannelIndex)
+        {
+            ERR("Failed to find %s channel in device\n",
+                GetLabelFromChannel(decoder.mChannels[i]));
+            continue;
+        }
 
-    if(!hqdec && conf->FreqBands != 1)
-        ERR("Basic renderer uses the high-frequency matrix as single-band (xover_freq = %.0fhz)\n",
-            conf->XOverFreq);
+        auto ordermap = decoder.mIs3D ? AmbiIndex::OrderFromChannel().data()
+            : AmbiIndex::OrderFrom2DChannel().data();
 
-    const ALuint order{(conf->ChanMask > AMBI_2ORDER_MASK) ? 3u :
-        (conf->ChanMask > AMBI_1ORDER_MASK) ? 2u : 1u};
-    device->mAmbiOrder = order;
+        chancoeffs.resize(maxz(chancoeffs.size(), idx+1u), ChannelDec{});
+        al::span<const float,MaxAmbiChannels> src{decoder.mCoeffs[i]};
+        al::span<float,MaxAmbiChannels> dst{chancoeffs[idx]};
+        for(size_t ambichan{0};ambichan < ambicount;++ambichan)
+            dst[ambichan] = src[ambichan] * decoder.mOrderGain[ordermap[ambichan]];
 
-    ALuint count;
-    if((conf->ChanMask&AMBI_PERIPHONIC_MASK))
-    {
-        count = static_cast<ALuint>(AmbiChannelsFromOrder(order));
-        std::transform(AmbiIndex::From3D.begin(), AmbiIndex::From3D.begin()+count,
-            std::begin(device->Dry.AmbiMap),
-            [](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
-        );
+        if(!dual_band)
+            continue;
+
+        chancoeffslf.resize(maxz(chancoeffslf.size(), idx+1u), ChannelDec{});
+        src = decoder.mCoeffsLF[i];
+        dst = chancoeffslf[idx];
+        for(size_t ambichan{0};ambichan < ambicount;++ambichan)
+            dst[ambichan] = src[ambichan] * decoder.mOrderGainLF[ordermap[ambichan]];
     }
-    else
+
+    /* For non-DevFmtAmbi3D, set the ambisonic order. */
+    device->mAmbiOrder = decoder.mOrder;
+    device->m2DMixing = !decoder.mIs3D;
+
+    const al::span<const uint8_t> acnmap{decoder.mIs3D ? AmbiIndex::FromACN().data() :
+        AmbiIndex::FromACN2D().data(), ambicount};
+    auto&& coeffscale = GetAmbiScales(decoder.mScaling);
+    std::transform(acnmap.begin(), acnmap.end(), std::begin(device->Dry.AmbiMap),
+        [&coeffscale](const uint8_t &acn) noexcept
+        { return BFChannelConfig{1.0f/coeffscale[acn], acn}; });
+    AllocChannels(device, ambicount, device->channelsFromFmt());
+
+    std::unique_ptr<FrontStablizer> stablizer;
+    if(stablize)
     {
-        count = static_cast<ALuint>(Ambi2DChannelsFromOrder(order));
-        std::transform(AmbiIndex::From2D.begin(), AmbiIndex::From2D.begin()+count,
-            std::begin(device->Dry.AmbiMap),
-            [](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
-        );
+        /* Only enable the stablizer if the decoder does not output to the
+         * front-center channel.
+         */
+        const auto cidx = device->RealOut.ChannelIndex[FrontCenter];
+        bool hasfc{false};
+        if(cidx < chancoeffs.size())
+        {
+            for(const auto &coeff : chancoeffs[cidx])
+                hasfc |= coeff != 0.0f;
+        }
+        if(!hasfc && cidx < chancoeffslf.size())
+        {
+            for(const auto &coeff : chancoeffslf[cidx])
+                hasfc |= coeff != 0.0f;
+        }
+        if(!hasfc)
+        {
+            stablizer = CreateStablizer(device->channelsFromFmt(), device->Frequency);
+            TRACE("Front stablizer enabled\n");
+        }
     }
-    AllocChannels(device, count, device->channelsFromFmt());
 
     TRACE("Enabling %s-band %s-order%s ambisonic decoder\n",
-        (!hqdec || conf->FreqBands == 1) ? "single" : "dual",
-        (conf->ChanMask > AMBI_2ORDER_MASK) ? "third" :
-        (conf->ChanMask > AMBI_1ORDER_MASK) ? "second" : "first",
-        (conf->ChanMask&AMBI_PERIPHONIC_MASK) ? " periphonic" : ""
-    );
-    device->AmbiDecoder = al::make_unique<BFormatDec>(conf, hqdec, count, device->Frequency,
-        speakermap);
-
-    auto accum_spkr_dist = std::bind(std::plus<float>{}, _1,
-        std::bind(std::mem_fn(&AmbDecConf::SpeakerConf::Distance), _2));
-    const ALfloat avg_dist{
-        std::accumulate(conf->Speakers.begin(), conf->Speakers.end(), 0.0f, accum_spkr_dist) /
-        static_cast<ALfloat>(conf->Speakers.size())};
-    InitNearFieldCtrl(device, avg_dist, order,
-        (conf->ChanMask&AMBI_PERIPHONIC_MASK) ? chans_per_order3d : chans_per_order2d);
-
-    InitDistanceComp(device, conf, speakermap);
+        !dual_band ? "single" : "dual",
+        (decoder.mOrder > 3) ? "fourth" :
+        (decoder.mOrder > 2) ? "third" :
+        (decoder.mOrder > 1) ? "second" : "first",
+        decoder.mIs3D ? " periphonic" : "");
+    device->AmbiDecoder = BFormatDec::Create(ambicount, chancoeffs, chancoeffslf,
+        device->mXOverFreq/static_cast<float>(device->Frequency), std::move(stablizer));
 }
 
 void InitHrtfPanning(ALCdevice *device)
 {
-    constexpr float PI{al::MathDefs<float>::Pi()};
-    constexpr float PI_2{al::MathDefs<float>::Pi() / 2.0f};
-    constexpr float PI_4{al::MathDefs<float>::Pi() / 4.0f};
-    constexpr float PI3_4{al::MathDefs<float>::Pi() * 3.0f / 4.0f};
-    const float CornerElev{static_cast<float>(std::atan2(1.0, std::sqrt(2.0)))};
+    constexpr float Deg180{al::numbers::pi_v<float>};
+    constexpr float Deg_90{Deg180 / 2.0f /* 90 degrees*/};
+    constexpr float Deg_45{Deg_90 / 2.0f /* 45 degrees*/};
+    constexpr float Deg135{Deg_45 * 3.0f /*135 degrees*/};
+    constexpr float Deg_21{3.648638281e-01f /* 20~ 21 degrees*/};
+    constexpr float Deg_32{5.535743589e-01f /* 31~ 32 degrees*/};
+    constexpr float Deg_35{6.154797087e-01f /* 35~ 36 degrees*/};
+    constexpr float Deg_58{1.017221968e+00f /* 58~ 59 degrees*/};
+    constexpr float Deg_69{1.205932499e+00f /* 69~ 70 degrees*/};
+    constexpr float Deg111{1.935660155e+00f /*110~111 degrees*/};
+    constexpr float Deg122{2.124370686e+00f /*121~122 degrees*/};
     static const AngularPoint AmbiPoints1O[]{
-        { ElevRadius{ CornerElev}, AzimRadius{ -PI_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{-PI3_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{  PI_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{ PI3_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{ -PI_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{-PI3_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{  PI_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{ PI3_4} },
+        { EvRadians{ Deg_35}, AzRadians{-Deg_45} },
+        { EvRadians{ Deg_35}, AzRadians{-Deg135} },
+        { EvRadians{ Deg_35}, AzRadians{ Deg_45} },
+        { EvRadians{ Deg_35}, AzRadians{ Deg135} },
+        { EvRadians{-Deg_35}, AzRadians{-Deg_45} },
+        { EvRadians{-Deg_35}, AzRadians{-Deg135} },
+        { EvRadians{-Deg_35}, AzRadians{ Deg_45} },
+        { EvRadians{-Deg_35}, AzRadians{ Deg135} },
     }, AmbiPoints2O[]{
-        { ElevRadius{       0.0f}, AzimRadius{  0.0f} },
-        { ElevRadius{       0.0f}, AzimRadius{    PI} },
-        { ElevRadius{       0.0f}, AzimRadius{ -PI_2} },
-        { ElevRadius{       0.0f}, AzimRadius{  PI_2} },
-        { ElevRadius{       PI_2}, AzimRadius{  0.0f} },
-        { ElevRadius{      -PI_2}, AzimRadius{  0.0f} },
-        { ElevRadius{       PI_4}, AzimRadius{ -PI_2} },
-        { ElevRadius{       PI_4}, AzimRadius{  PI_2} },
-        { ElevRadius{      -PI_4}, AzimRadius{ -PI_2} },
-        { ElevRadius{      -PI_4}, AzimRadius{  PI_2} },
-        { ElevRadius{       PI_4}, AzimRadius{  0.0f} },
-        { ElevRadius{       PI_4}, AzimRadius{    PI} },
-        { ElevRadius{      -PI_4}, AzimRadius{  0.0f} },
-        { ElevRadius{      -PI_4}, AzimRadius{    PI} },
-        { ElevRadius{       0.0f}, AzimRadius{ -PI_4} },
-        { ElevRadius{       0.0f}, AzimRadius{-PI3_4} },
-        { ElevRadius{       0.0f}, AzimRadius{  PI_4} },
-        { ElevRadius{       0.0f}, AzimRadius{ PI3_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{ -PI_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{-PI3_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{  PI_4} },
-        { ElevRadius{ CornerElev}, AzimRadius{ PI3_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{ -PI_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{-PI3_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{  PI_4} },
-        { ElevRadius{-CornerElev}, AzimRadius{ PI3_4} },
+        { EvRadians{-Deg_32}, AzRadians{   0.0f} },
+        { EvRadians{   0.0f}, AzRadians{ Deg_58} },
+        { EvRadians{ Deg_58}, AzRadians{ Deg_90} },
+        { EvRadians{ Deg_32}, AzRadians{   0.0f} },
+        { EvRadians{   0.0f}, AzRadians{ Deg122} },
+        { EvRadians{-Deg_58}, AzRadians{-Deg_90} },
+        { EvRadians{-Deg_32}, AzRadians{ Deg180} },
+        { EvRadians{   0.0f}, AzRadians{-Deg122} },
+        { EvRadians{ Deg_58}, AzRadians{-Deg_90} },
+        { EvRadians{ Deg_32}, AzRadians{ Deg180} },
+        { EvRadians{   0.0f}, AzRadians{-Deg_58} },
+        { EvRadians{-Deg_58}, AzRadians{ Deg_90} },
+    }, AmbiPoints3O[]{
+        { EvRadians{ Deg_69}, AzRadians{-Deg_90} },
+        { EvRadians{ Deg_69}, AzRadians{ Deg_90} },
+        { EvRadians{-Deg_69}, AzRadians{-Deg_90} },
+        { EvRadians{-Deg_69}, AzRadians{ Deg_90} },
+        { EvRadians{   0.0f}, AzRadians{-Deg_69} },
+        { EvRadians{   0.0f}, AzRadians{-Deg111} },
+        { EvRadians{   0.0f}, AzRadians{ Deg_69} },
+        { EvRadians{   0.0f}, AzRadians{ Deg111} },
+        { EvRadians{ Deg_21}, AzRadians{   0.0f} },
+        { EvRadians{ Deg_21}, AzRadians{ Deg180} },
+        { EvRadians{-Deg_21}, AzRadians{   0.0f} },
+        { EvRadians{-Deg_21}, AzRadians{ Deg180} },
+        { EvRadians{ Deg_35}, AzRadians{-Deg_45} },
+        { EvRadians{ Deg_35}, AzRadians{-Deg135} },
+        { EvRadians{ Deg_35}, AzRadians{ Deg_45} },
+        { EvRadians{ Deg_35}, AzRadians{ Deg135} },
+        { EvRadians{-Deg_35}, AzRadians{-Deg_45} },
+        { EvRadians{-Deg_35}, AzRadians{-Deg135} },
+        { EvRadians{-Deg_35}, AzRadians{ Deg_45} },
+        { EvRadians{-Deg_35}, AzRadians{ Deg135} },
     };
-    static const float AmbiMatrix1O[][MAX_AMBI_CHANNELS]{
+    static const float AmbiMatrix1O[][MaxAmbiChannels]{
         { 1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f },
         { 1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f },
         { 1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f },
@@ -573,64 +771,91 @@ void InitHrtfPanning(ALCdevice *device)
         { 1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f },
         { 1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f },
         { 1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f },
-    }, AmbiMatrix2O[][MAX_AMBI_CHANNELS]{
-        { 3.846153846e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  8.606629658e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  8.606629658e-02f },
-        { 3.846153846e-02f,  6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f, -8.606629658e-02f },
-        { 3.846153846e-02f, -6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f, -8.606629658e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f,  6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  9.938079900e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f,  0.000000000e+00f, -6.661733875e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  9.938079900e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f,  4.710557198e-02f,  4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.834676493e-02f,  2.484519975e-02f,  0.000000000e+00f, -4.303314829e-02f },
-        { 3.846153846e-02f, -4.710557198e-02f,  4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.834676493e-02f,  2.484519975e-02f,  0.000000000e+00f, -4.303314829e-02f },
-        { 3.846153846e-02f,  4.710557198e-02f, -4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.834676493e-02f,  2.484519975e-02f,  0.000000000e+00f, -4.303314829e-02f },
-        { 3.846153846e-02f, -4.710557198e-02f, -4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.834676493e-02f,  2.484519975e-02f,  0.000000000e+00f, -4.303314829e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f,  4.710557198e-02f,  4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  2.484519975e-02f,  6.834676493e-02f,  4.303314829e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f,  4.710557198e-02f, -4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  2.484519975e-02f, -6.834676493e-02f,  4.303314829e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f, -4.710557198e-02f,  4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  2.484519975e-02f, -6.834676493e-02f,  4.303314829e-02f },
-        { 3.846153846e-02f,  0.000000000e+00f, -4.710557198e-02f, -4.710557198e-02f,  0.000000000e+00f,  0.000000000e+00f,  2.484519975e-02f,  6.834676493e-02f,  4.303314829e-02f },
-        { 3.846153846e-02f,  4.710557198e-02f,  0.000000000e+00f,  4.710557198e-02f,  6.834676493e-02f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f,  4.710557198e-02f,  0.000000000e+00f, -4.710557198e-02f, -6.834676493e-02f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f, -4.710557198e-02f,  0.000000000e+00f,  4.710557198e-02f, -6.834676493e-02f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f, -4.710557198e-02f,  0.000000000e+00f, -4.710557198e-02f,  6.834676493e-02f,  0.000000000e+00f, -4.969039950e-02f,  0.000000000e+00f,  0.000000000e+00f },
-        { 3.846153846e-02f,  3.846153846e-02f,  3.846153846e-02f,  3.846153846e-02f,  4.556450996e-02f,  4.556450996e-02f,  0.000000000e+00f,  4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f,  3.846153846e-02f,  3.846153846e-02f, -3.846153846e-02f, -4.556450996e-02f,  4.556450996e-02f,  0.000000000e+00f, -4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f, -3.846153846e-02f,  3.846153846e-02f,  3.846153846e-02f, -4.556450996e-02f, -4.556450996e-02f,  0.000000000e+00f,  4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f, -3.846153846e-02f,  3.846153846e-02f, -3.846153846e-02f,  4.556450996e-02f, -4.556450996e-02f,  0.000000000e+00f, -4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f,  3.846153846e-02f, -3.846153846e-02f,  3.846153846e-02f,  4.556450996e-02f, -4.556450996e-02f,  0.000000000e+00f, -4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f,  3.846153846e-02f, -3.846153846e-02f, -3.846153846e-02f, -4.556450996e-02f, -4.556450996e-02f,  0.000000000e+00f,  4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f, -3.846153846e-02f, -3.846153846e-02f,  3.846153846e-02f, -4.556450996e-02f,  4.556450996e-02f,  0.000000000e+00f, -4.556450996e-02f,  0.000000000e+00f },
-        { 3.846153846e-02f, -3.846153846e-02f, -3.846153846e-02f, -3.846153846e-02f,  4.556450996e-02f,  4.556450996e-02f,  0.000000000e+00f,  4.556450996e-02f,  0.000000000e+00f },
+    }, AmbiMatrix2O[][MaxAmbiChannels]{
+        { 8.333333333e-02f,  0.000000000e+00f, -7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f, -1.443375673e-01f,  1.167715449e-01f, },
+        { 8.333333333e-02f, -1.227808683e-01f,  0.000000000e+00f,  7.588274978e-02f, -1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, },
+        { 8.333333333e-02f, -7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, },
+        { 8.333333333e-02f,  0.000000000e+00f,  7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f,  1.443375673e-01f,  1.167715449e-01f, },
+        { 8.333333333e-02f, -1.227808683e-01f,  0.000000000e+00f, -7.588274978e-02f,  1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, },
+        { 8.333333333e-02f,  7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, },
+        { 8.333333333e-02f,  0.000000000e+00f, -7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f,  1.443375673e-01f,  1.167715449e-01f, },
+        { 8.333333333e-02f,  1.227808683e-01f,  0.000000000e+00f, -7.588274978e-02f, -1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, },
+        { 8.333333333e-02f,  7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f,  1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, },
+        { 8.333333333e-02f,  0.000000000e+00f,  7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f, -1.443375673e-01f,  1.167715449e-01f, },
+        { 8.333333333e-02f,  1.227808683e-01f,  0.000000000e+00f,  7.588274978e-02f,  1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, },
+        { 8.333333333e-02f, -7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f,  1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, },
+    }, AmbiMatrix3O[][MaxAmbiChannels]{
+        { 5.000000000e-02f,  3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f, -1.256118221e-01f,  0.000000000e+00f,  1.126112056e-01f,  7.944389175e-02f,  0.000000000e+00f,  2.421151497e-02f,  0.000000000e+00f, },
+        { 5.000000000e-02f, -3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f,  1.256118221e-01f,  0.000000000e+00f, -1.126112056e-01f,  7.944389175e-02f,  0.000000000e+00f,  2.421151497e-02f,  0.000000000e+00f, },
+        { 5.000000000e-02f,  3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f, -1.256118221e-01f,  0.000000000e+00f,  1.126112056e-01f, -7.944389175e-02f,  0.000000000e+00f, -2.421151497e-02f,  0.000000000e+00f, },
+        { 5.000000000e-02f, -3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f,  1.256118221e-01f,  0.000000000e+00f, -1.126112056e-01f, -7.944389175e-02f,  0.000000000e+00f, -2.421151497e-02f,  0.000000000e+00f, },
+        { 5.000000000e-02f,  8.090169944e-02f,  0.000000000e+00f,  3.090169944e-02f,  6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f, -7.763237543e-02f,  0.000000000e+00f, -2.950836627e-02f,  0.000000000e+00f, -1.497759251e-01f,  0.000000000e+00f, -7.763237543e-02f, },
+        { 5.000000000e-02f,  8.090169944e-02f,  0.000000000e+00f, -3.090169944e-02f, -6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f, -7.763237543e-02f,  0.000000000e+00f, -2.950836627e-02f,  0.000000000e+00f,  1.497759251e-01f,  0.000000000e+00f,  7.763237543e-02f, },
+        { 5.000000000e-02f, -8.090169944e-02f,  0.000000000e+00f,  3.090169944e-02f, -6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f,  7.763237543e-02f,  0.000000000e+00f,  2.950836627e-02f,  0.000000000e+00f, -1.497759251e-01f,  0.000000000e+00f, -7.763237543e-02f, },
+        { 5.000000000e-02f, -8.090169944e-02f,  0.000000000e+00f, -3.090169944e-02f,  6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f,  7.763237543e-02f,  0.000000000e+00f,  2.950836627e-02f,  0.000000000e+00f,  1.497759251e-01f,  0.000000000e+00f,  7.763237543e-02f, },
+        { 5.000000000e-02f,  0.000000000e+00f,  3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f,  6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  3.034486645e-02f, -6.779013272e-02f,  1.659481923e-01f,  4.797944664e-02f, },
+        { 5.000000000e-02f,  0.000000000e+00f,  3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f, -6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  3.034486645e-02f,  6.779013272e-02f,  1.659481923e-01f, -4.797944664e-02f, },
+        { 5.000000000e-02f,  0.000000000e+00f, -3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f, -6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -3.034486645e-02f, -6.779013272e-02f, -1.659481923e-01f,  4.797944664e-02f, },
+        { 5.000000000e-02f,  0.000000000e+00f, -3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f,  6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -3.034486645e-02f,  6.779013272e-02f, -1.659481923e-01f, -4.797944664e-02f, },
+        { 5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f,  6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f,  6.338656910e-02f, -1.092600649e-02f, -7.364853795e-02f,  1.011266756e-01f, -7.086833869e-02f, -1.482646439e-02f, },
+        { 5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f, -6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f, -6.338656910e-02f, -1.092600649e-02f, -7.364853795e-02f, -1.011266756e-01f, -7.086833869e-02f,  1.482646439e-02f, },
+        { 5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f, -6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f, -6.338656910e-02f,  1.092600649e-02f, -7.364853795e-02f,  1.011266756e-01f, -7.086833869e-02f, -1.482646439e-02f, },
+        { 5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f,  6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f,  6.338656910e-02f,  1.092600649e-02f, -7.364853795e-02f, -1.011266756e-01f, -7.086833869e-02f,  1.482646439e-02f, },
+        { 5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f,  6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f, -6.338656910e-02f, -1.092600649e-02f,  7.364853795e-02f,  1.011266756e-01f,  7.086833869e-02f, -1.482646439e-02f, },
+        { 5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f, -6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f,  6.338656910e-02f, -1.092600649e-02f,  7.364853795e-02f, -1.011266756e-01f,  7.086833869e-02f,  1.482646439e-02f, },
+        { 5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f, -6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f,  6.338656910e-02f,  1.092600649e-02f,  7.364853795e-02f,  1.011266756e-01f,  7.086833869e-02f, -1.482646439e-02f, },
+        { 5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f,  6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f, -6.338656910e-02f,  1.092600649e-02f,  7.364853795e-02f, -1.011266756e-01f,  7.086833869e-02f,  1.482646439e-02f, },
     };
-    static const float AmbiOrderHFGain1O[MAX_AMBI_ORDER+1]{
-        2.000000000e+00f, 1.154700538e+00f
-    }, AmbiOrderHFGain2O[MAX_AMBI_ORDER+1]{
-        2.687419249e+00f, 2.081665999e+00f, 1.074967700e+00f
+    static const float AmbiOrderHFGain1O[MaxAmbiOrder+1]{
+        /*ENRGY*/ 2.000000000e+00f, 1.154700538e+00f
+    }, AmbiOrderHFGain2O[MaxAmbiOrder+1]{
+        /*ENRGY*/ 1.825741858e+00f, 1.414213562e+00f, 7.302967433e-01f
+        /*AMP   1.000000000e+00f, 7.745966692e-01f, 4.000000000e-01f*/
+        /*RMS   9.128709292e-01f, 7.071067812e-01f, 3.651483717e-01f*/
+    }, AmbiOrderHFGain3O[MaxAmbiOrder+1]{
+        /*ENRGY 1.865086714e+00f, 1.606093894e+00f, 1.142055301e+00f, 5.683795528e-01f*/
+        /*AMP*/ 1.000000000e+00f, 8.611363116e-01f, 6.123336207e-01f, 3.047469850e-01f
+        /*RMS   8.340921354e-01f, 7.182670250e-01f, 5.107426573e-01f, 2.541870634e-01f*/
     };
-    static const ALuint ChansPerOrder[MAX_AMBI_ORDER+1]{ 1, 3, 5, 7 };
 
     static_assert(al::size(AmbiPoints1O) == al::size(AmbiMatrix1O), "First-Order Ambisonic HRTF mismatch");
     static_assert(al::size(AmbiPoints2O) == al::size(AmbiMatrix2O), "Second-Order Ambisonic HRTF mismatch");
+    static_assert(al::size(AmbiPoints3O) == al::size(AmbiMatrix3O), "Third-Order Ambisonic HRTF mismatch");
+
+    /* A 700hz crossover frequency provides tighter sound imaging at the sweet
+     * spot with ambisonic decoding, as the distance between the ears is closer
+     * to half this frequency wavelength, which is the optimal point where the
+     * response should change between optimizing phase vs volume. Normally this
+     * tighter imaging is at the cost of a smaller sweet spot, but since the
+     * listener is fixed in the center of the HRTF responses for the decoder,
+     * we don't have to worry about ever being out of the sweet spot.
+     *
+     * A better option here may be to have the head radius as part of the HRTF
+     * data set and calculate the optimal crossover frequency from that.
+     */
+    device->mXOverFreq = 700.0f;
 
     /* Don't bother with HOA when using full HRTF rendering. Nothing needs it,
      * and it eases the CPU/memory load.
      */
-    device->mRenderMode = HrtfRender;
-    ALuint ambi_order{1};
-    if(auto modeopt = ConfigValueStr(device->DeviceName.c_str(), nullptr, "hrtf-mode"))
+    device->mRenderMode = RenderMode::Hrtf;
+    uint ambi_order{1};
+    if(auto modeopt = device->configValue<std::string>(nullptr, "hrtf-mode"))
     {
         struct HrtfModeEntry {
             char name[8];
             RenderMode mode;
-            ALuint order;
+            uint order;
         };
         static const HrtfModeEntry hrtf_modes[]{
-            { "full", HrtfRender, 1 },
-            { "ambi1", NormalRender, 1 },
-            { "ambi2", NormalRender, 2 },
+            { "full", RenderMode::Hrtf, 1 },
+            { "ambi1", RenderMode::Normal, 1 },
+            { "ambi2", RenderMode::Normal, 2 },
+            { "ambi3", RenderMode::Normal, 3 },
         };
 
         const char *mode{modeopt->c_str()};
-        if(al::strcasecmp(mode, "basic") == 0 || al::strcasecmp(mode, "ambi3") == 0)
+        if(al::strcasecmp(mode, "basic") == 0)
         {
             ERR("HRTF mode \"%s\" deprecated, substituting \"%s\"\n", mode, "ambi2");
             mode = "ambi2";
@@ -652,40 +877,43 @@ void InitHrtfPanning(ALCdevice *device)
         ((ambi_order%10) == 1) ? "st" :
         ((ambi_order%10) == 2) ? "nd" :
         ((ambi_order%10) == 3) ? "rd" : "th",
-        (device->mRenderMode == HrtfRender) ? "+ Full " : "",
-        device->HrtfName.c_str());
-
-    al::span<const AngularPoint> AmbiPoints{};
-    const float (*AmbiMatrix)[MAX_AMBI_CHANNELS]{};
-    const float *AmbiOrderHFGain{};
-    if(ambi_order >= 2)
+        (device->mRenderMode == RenderMode::Hrtf) ? "+ Full " : "",
+        device->mHrtfName.c_str());
+
+    bool perHrirMin{false};
+    al::span<const AngularPoint> AmbiPoints{AmbiPoints1O};
+    const float (*AmbiMatrix)[MaxAmbiChannels]{AmbiMatrix1O};
+    al::span<const float,MaxAmbiOrder+1> AmbiOrderHFGain{AmbiOrderHFGain1O};
+    if(ambi_order >= 3)
+    {
+        perHrirMin = true;
+        AmbiPoints = AmbiPoints3O;
+        AmbiMatrix = AmbiMatrix3O;
+        AmbiOrderHFGain = AmbiOrderHFGain3O;
+    }
+    else if(ambi_order == 2)
     {
         AmbiPoints = AmbiPoints2O;
         AmbiMatrix = AmbiMatrix2O;
         AmbiOrderHFGain = AmbiOrderHFGain2O;
     }
-    else /*if(ambi_order == 1)*/
-    {
-        AmbiPoints = AmbiPoints1O;
-        AmbiMatrix = AmbiMatrix1O;
-        AmbiOrderHFGain = AmbiOrderHFGain1O;
-    }
     device->mAmbiOrder = ambi_order;
+    device->m2DMixing = false;
 
     const size_t count{AmbiChannelsFromOrder(ambi_order)};
-    device->mHrtfState = DirectHrtfState::Create(count);
-
-    std::transform(AmbiIndex::From3D.begin(), AmbiIndex::From3D.begin()+count,
+    std::transform(AmbiIndex::FromACN().begin(), AmbiIndex::FromACN().begin()+count,
         std::begin(device->Dry.AmbiMap),
         [](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
     );
-    AllocChannels(device, static_cast<ALuint>(count), device->channelsFromFmt());
+    AllocChannels(device, count, device->channelsFromFmt());
 
-    BuildBFormatHrtf(device->mHrtf, device->mHrtfState.get(), AmbiPoints, AmbiMatrix,
+    HrtfStore *Hrtf{device->mHrtf.get()};
+    auto hrtfstate = DirectHrtfState::Create(count);
+    hrtfstate->build(Hrtf, device->mIrSize, perHrirMin, AmbiPoints, AmbiMatrix, device->mXOverFreq,
         AmbiOrderHFGain);
+    device->mHrtfState = std::move(hrtfstate);
 
-    HrtfEntry *Hrtf{device->mHrtf};
-    InitNearFieldCtrl(device, Hrtf->field[0].distance, ambi_order, ChansPerOrder);
+    InitNearFieldCtrl(device, Hrtf->mFields[0].distance, ambi_order, true);
 }
 
 void InitUhjPanning(ALCdevice *device)
@@ -694,179 +922,204 @@ void InitUhjPanning(ALCdevice *device)
     constexpr size_t count{Ambi2DChannelsFromOrder(1)};
 
     device->mAmbiOrder = 1;
+    device->m2DMixing = true;
 
-    auto acnmap_end = AmbiIndex::FromFuMa.begin() + count;
-    std::transform(AmbiIndex::FromFuMa.begin(), acnmap_end, std::begin(device->Dry.AmbiMap),
+    auto acnmap_begin = AmbiIndex::FromFuMa2D().begin();
+    std::transform(acnmap_begin, acnmap_begin + count, std::begin(device->Dry.AmbiMap),
         [](const uint8_t &acn) noexcept -> BFChannelConfig
-        { return BFChannelConfig{1.0f/AmbiScale::FromFuMa[acn], acn}; }
-    );
-    AllocChannels(device, ALuint{count}, device->channelsFromFmt());
+        { return BFChannelConfig{1.0f/AmbiScale::FromUHJ()[acn], acn}; });
+    AllocChannels(device, count, device->channelsFromFmt());
 }
 
 } // namespace
 
-void aluInitRenderer(ALCdevice *device, ALint hrtf_id, HrtfRequestMode hrtf_appreq, HrtfRequestMode hrtf_userreq)
+void aluInitRenderer(ALCdevice *device, int hrtf_id, al::optional<StereoEncoding> stereomode)
 {
     /* Hold the HRTF the device last used, in case it's used again. */
-    HrtfEntry *old_hrtf{device->mHrtf};
+    HrtfStorePtr old_hrtf{std::move(device->mHrtf)};
 
     device->mHrtfState = nullptr;
     device->mHrtf = nullptr;
-    device->HrtfName.clear();
-    device->mRenderMode = NormalRender;
+    device->mIrSize = 0;
+    device->mHrtfName.clear();
+    device->mXOverFreq = 400.0f;
+    device->m2DMixing = false;
+    device->mRenderMode = RenderMode::Normal;
 
     if(device->FmtChans != DevFmtStereo)
     {
-        if(old_hrtf)
-            old_hrtf->DecRef();
         old_hrtf = nullptr;
-        if(hrtf_appreq == Hrtf_Enable)
-            device->HrtfStatus = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
+        if(stereomode && *stereomode == StereoEncoding::Hrtf)
+            device->mHrtfStatus = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
 
         const char *layout{nullptr};
         switch(device->FmtChans)
         {
-            case DevFmtQuad: layout = "quad"; break;
-            case DevFmtX51: /* fall-through */
-            case DevFmtX51Rear: layout = "surround51"; break;
-            case DevFmtX61: layout = "surround61"; break;
-            case DevFmtX71: layout = "surround71"; break;
-            /* Mono, Stereo, and Ambisonics output don't use custom decoders. */
-            case DevFmtMono:
-            case DevFmtStereo:
-            case DevFmtAmbi3D:
-                break;
+        case DevFmtQuad: layout = "quad"; break;
+        case DevFmtX51: layout = "surround51"; break;
+        case DevFmtX61: layout = "surround61"; break;
+        case DevFmtX71: layout = "surround71"; break;
+        case DevFmtX714: layout = "surround714"; break;
+        case DevFmtX3D71: layout = "surround3d71"; break;
+        /* Mono, Stereo, and Ambisonics output don't use custom decoders. */
+        case DevFmtMono:
+        case DevFmtStereo:
+        case DevFmtAmbi3D:
+            break;
         }
 
-        const char *devname{device->DeviceName.c_str()};
-        ALuint speakermap[MAX_OUTPUT_CHANNELS];
-        AmbDecConf *pconf{nullptr};
-        AmbDecConf conf{};
-        if(layout)
+        std::unique_ptr<DecoderConfig<DualBand,MAX_OUTPUT_CHANNELS>> decoder_store;
+        DecoderView decoder{};
+        float speakerdists[MAX_OUTPUT_CHANNELS]{};
+        auto load_config = [device,&decoder_store,&decoder,&speakerdists](const char *config)
         {
-            if(auto decopt = ConfigValueStr(devname, "decoder", layout))
+            AmbDecConf conf{};
+            if(auto err = conf.load(config))
             {
-                if(!conf.load(decopt->c_str()))
-                    ERR("Failed to load layout file %s\n", decopt->c_str());
-                else if(conf.Speakers.size() > MAX_OUTPUT_CHANNELS)
-                    ERR("Unsupported speaker count %zu (max %d)\n", conf.Speakers.size(),
-                        MAX_OUTPUT_CHANNELS);
-                else if(conf.ChanMask > AMBI_3ORDER_MASK)
-                    ERR("Unsupported channel mask 0x%04x (max 0x%x)\n", conf.ChanMask,
-                        AMBI_3ORDER_MASK);
-                else if(MakeSpeakerMap(device, &conf, speakermap))
-                    pconf = &conf;
+                ERR("Failed to load layout file %s\n", config);
+                ERR("  %s\n", err->c_str());
             }
-        }
+            else if(conf.NumSpeakers > MAX_OUTPUT_CHANNELS)
+                ERR("Unsupported decoder speaker count %zu (max %d)\n", conf.NumSpeakers,
+                    MAX_OUTPUT_CHANNELS);
+            else if(conf.ChanMask > Ambi3OrderMask)
+                ERR("Unsupported decoder channel mask 0x%04x (max 0x%x)\n", conf.ChanMask,
+                    Ambi3OrderMask);
+            else
+            {
+                device->mXOverFreq = clampf(conf.XOverFreq, 100.0f, 1000.0f);
 
-        if(!pconf)
-            InitPanning(device);
-        else
+                decoder_store = std::make_unique<DecoderConfig<DualBand,MAX_OUTPUT_CHANNELS>>();
+                decoder = MakeDecoderView(device, &conf, *decoder_store);
+                for(size_t i{0};i < decoder.mChannels.size();++i)
+                    speakerdists[i] = conf.Speakers[i].Distance;
+            }
+        };
+        if(layout)
         {
-            int hqdec{GetConfigValueBool(devname, "decoder", "hq-mode", 1)};
-            InitCustomPanning(device, !!hqdec, pconf, speakermap);
+            if(auto decopt = device->configValue<std::string>("decoder", layout))
+                load_config(decopt->c_str());
         }
-        if(device->AmbiDecoder)
-            device->PostProcess = &ALCdevice::ProcessAmbiDec;
-        return;
-    }
 
-    bool headphones{device->IsHeadphones != AL_FALSE};
-    if(device->Type != Loopback)
-    {
-        if(auto modeopt = ConfigValueStr(device->DeviceName.c_str(), nullptr, "stereo-mode"))
+        /* Enable the stablizer only for formats that have front-left, front-
+         * right, and front-center outputs.
+         */
+        const bool stablize{device->RealOut.ChannelIndex[FrontCenter] != InvalidChannelIndex
+            && device->RealOut.ChannelIndex[FrontLeft] != InvalidChannelIndex
+            && device->RealOut.ChannelIndex[FrontRight] != InvalidChannelIndex
+            && device->getConfigValueBool(nullptr, "front-stablizer", false) != 0};
+        const bool hqdec{device->getConfigValueBool("decoder", "hq-mode", true) != 0};
+        InitPanning(device, hqdec, stablize, decoder);
+        if(decoder)
         {
-            const char *mode{modeopt->c_str()};
-            if(al::strcasecmp(mode, "headphones") == 0)
-                headphones = true;
-            else if(al::strcasecmp(mode, "speakers") == 0)
-                headphones = false;
-            else if(al::strcasecmp(mode, "auto") != 0)
-                ERR("Unexpected stereo-mode: %s\n", mode);
-        }
-    }
+            float accum_dist{0.0f}, spkr_count{0.0f};
+            for(auto dist : speakerdists)
+            {
+                if(dist > 0.0f)
+                {
+                    accum_dist += dist;
+                    spkr_count += 1.0f;
+                }
+            }
 
-    if(hrtf_userreq == Hrtf_Default)
-    {
-        bool usehrtf = (headphones && hrtf_appreq != Hrtf_Disable) ||
-                       (hrtf_appreq == Hrtf_Enable);
-        if(!usehrtf) goto no_hrtf;
+            const float avg_dist{(accum_dist > 0.0f && spkr_count > 0) ? accum_dist/spkr_count :
+                device->configValue<float>("decoder", "speaker-dist").value_or(1.0f)};
+            InitNearFieldCtrl(device, avg_dist, decoder.mOrder, decoder.mIs3D);
 
-        device->HrtfStatus = ALC_HRTF_ENABLED_SOFT;
-        if(headphones && hrtf_appreq != Hrtf_Disable)
-            device->HrtfStatus = ALC_HRTF_HEADPHONES_DETECTED_SOFT;
-    }
-    else
-    {
-        if(hrtf_userreq != Hrtf_Enable)
+            if(spkr_count > 0)
+                InitDistanceComp(device, decoder.mChannels, speakerdists);
+        }
+        if(auto *ambidec{device->AmbiDecoder.get()})
         {
-            if(hrtf_appreq == Hrtf_Enable)
-                device->HrtfStatus = ALC_HRTF_DENIED_SOFT;
-            goto no_hrtf;
+            device->PostProcess = ambidec->hasStablizer() ? &ALCdevice::ProcessAmbiDecStablized
+                : &ALCdevice::ProcessAmbiDec;
         }
-        device->HrtfStatus = ALC_HRTF_REQUIRED_SOFT;
+        return;
     }
 
-    if(device->HrtfList.empty())
-        device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
 
-    if(hrtf_id >= 0 && static_cast<ALuint>(hrtf_id) < device->HrtfList.size())
+    /* If HRTF is explicitly requested, or if there's no explicit request and
+     * the device is headphones, try to enable it.
+     */
+    if(stereomode.value_or(StereoEncoding::Default) == StereoEncoding::Hrtf
+        || (!stereomode && device->Flags.test(DirectEar)))
     {
-        const EnumeratedHrtf &entry = device->HrtfList[static_cast<ALuint>(hrtf_id)];
-        HrtfEntry *hrtf{GetLoadedHrtf(entry.hrtf)};
-        if(hrtf && hrtf->sampleRate == device->Frequency)
+        if(device->mHrtfList.empty())
+            device->enumerateHrtfs();
+
+        if(hrtf_id >= 0 && static_cast<uint>(hrtf_id) < device->mHrtfList.size())
         {
-            device->mHrtf = hrtf;
-            device->HrtfName = entry.name;
+            const std::string &hrtfname = device->mHrtfList[static_cast<uint>(hrtf_id)];
+            if(HrtfStorePtr hrtf{GetLoadedHrtf(hrtfname, device->Frequency)})
+            {
+                device->mHrtf = std::move(hrtf);
+                device->mHrtfName = hrtfname;
+            }
         }
-        else if(hrtf)
-            hrtf->DecRef();
-    }
 
-    if(!device->mHrtf)
-    {
-        auto find_hrtf = [device](const EnumeratedHrtf &entry) -> bool
+        if(!device->mHrtf)
         {
-            HrtfEntry *hrtf{GetLoadedHrtf(entry.hrtf)};
-            if(!hrtf) return false;
-            if(hrtf->sampleRate != device->Frequency)
+            for(const auto &hrtfname : device->mHrtfList)
             {
-                hrtf->DecRef();
-                return false;
+                if(HrtfStorePtr hrtf{GetLoadedHrtf(hrtfname, device->Frequency)})
+                {
+                    device->mHrtf = std::move(hrtf);
+                    device->mHrtfName = hrtfname;
+                    break;
+                }
             }
-            device->mHrtf = hrtf;
-            device->HrtfName = entry.name;
-            return true;
-        };
-        std::find_if(device->HrtfList.cbegin(), device->HrtfList.cend(), find_hrtf);
+        }
+
+        if(device->mHrtf)
+        {
+            old_hrtf = nullptr;
+
+            HrtfStore *hrtf{device->mHrtf.get()};
+            device->mIrSize = hrtf->mIrSize;
+            if(auto hrtfsizeopt = device->configValue<uint>(nullptr, "hrtf-size"))
+            {
+                if(*hrtfsizeopt > 0 && *hrtfsizeopt < device->mIrSize)
+                    device->mIrSize = maxu(*hrtfsizeopt, MinIrLength);
+            }
+
+            InitHrtfPanning(device);
+            device->PostProcess = &ALCdevice::ProcessHrtf;
+            device->mHrtfStatus = ALC_HRTF_ENABLED_SOFT;
+            return;
+        }
     }
+    old_hrtf = nullptr;
 
-    if(device->mHrtf)
+    if(stereomode.value_or(StereoEncoding::Default) == StereoEncoding::Uhj)
     {
-        if(old_hrtf)
-            old_hrtf->DecRef();
-        old_hrtf = nullptr;
+        switch(UhjEncodeQuality)
+        {
+        case UhjQualityType::IIR:
+            device->mUhjEncoder = std::make_unique<UhjEncoderIIR>();
+            break;
+        case UhjQualityType::FIR256:
+            device->mUhjEncoder = std::make_unique<UhjEncoder<UhjLength256>>();
+            break;
+        case UhjQualityType::FIR512:
+            device->mUhjEncoder = std::make_unique<UhjEncoder<UhjLength512>>();
+            break;
+        }
+        assert(device->mUhjEncoder != nullptr);
 
-        InitHrtfPanning(device);
-        device->PostProcess = &ALCdevice::ProcessHrtf;
+        TRACE("UHJ enabled\n");
+        InitUhjPanning(device);
+        device->PostProcess = &ALCdevice::ProcessUhj;
         return;
     }
-    device->HrtfStatus = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
-
-no_hrtf:
-    if(old_hrtf)
-        old_hrtf->DecRef();
-    old_hrtf = nullptr;
 
-    device->mRenderMode = StereoPair;
-
-    if(device->Type != Loopback)
+    device->mRenderMode = RenderMode::Pairwise;
+    if(device->Type != DeviceType::Loopback)
     {
-        if(auto cflevopt = ConfigValueInt(device->DeviceName.c_str(), nullptr, "cf_level"))
+        if(auto cflevopt = device->configValue<int>(nullptr, "cf_level"))
         {
             if(*cflevopt > 0 && *cflevopt <= 6)
             {
-                device->Bs2b = al::make_unique<bs2b>();
+                device->Bs2b = std::make_unique<bs2b>();
                 bs2b_set_params(device->Bs2b.get(), *cflevopt,
                     static_cast<int>(device->Frequency));
                 TRACE("BS2B enabled\n");
@@ -877,145 +1130,23 @@ no_hrtf:
         }
     }
 
-    if(auto encopt = ConfigValueStr(device->DeviceName.c_str(), nullptr, "stereo-encoding"))
-    {
-        const char *mode{encopt->c_str()};
-        if(al::strcasecmp(mode, "uhj") == 0)
-            device->mRenderMode = NormalRender;
-        else if(al::strcasecmp(mode, "panpot") != 0)
-            ERR("Unexpected stereo-encoding: %s\n", mode);
-    }
-    if(device->mRenderMode == NormalRender)
-    {
-        device->Uhj_Encoder = al::make_unique<Uhj2Encoder>();
-        TRACE("UHJ enabled\n");
-        InitUhjPanning(device);
-        device->PostProcess = &ALCdevice::ProcessUhj;
-        return;
-    }
-
     TRACE("Stereo rendering\n");
     InitPanning(device);
     device->PostProcess = &ALCdevice::ProcessAmbiDec;
 }
 
 
-void aluInitEffectPanning(ALeffectslot *slot, ALCdevice *device)
+void aluInitEffectPanning(EffectSlot *slot, ALCcontext *context)
 {
+    DeviceBase *device{context->mDevice};
     const size_t count{AmbiChannelsFromOrder(device->mAmbiOrder)};
-    slot->MixBuffer.resize(count);
-    slot->MixBuffer.shrink_to_fit();
 
-    auto acnmap_end = AmbiIndex::From3D.begin() + count;
-    auto iter = std::transform(AmbiIndex::From3D.begin(), acnmap_end, slot->Wet.AmbiMap.begin(),
+    slot->mWetBuffer.resize(count);
+
+    auto acnmap_begin = AmbiIndex::FromACN().begin();
+    auto iter = std::transform(acnmap_begin, acnmap_begin + count, slot->Wet.AmbiMap.begin(),
         [](const uint8_t &acn) noexcept -> BFChannelConfig
-        { return BFChannelConfig{1.0f, acn}; }
-    );
+        { return BFChannelConfig{1.0f, acn}; });
     std::fill(iter, slot->Wet.AmbiMap.end(), BFChannelConfig{});
-    slot->Wet.Buffer = {slot->MixBuffer.data(), slot->MixBuffer.size()};
-}
-
-
-void CalcAmbiCoeffs(const float y, const float z, const float x, const float spread,
-    const al::span<float,MAX_AMBI_CHANNELS> coeffs)
-{
-    /* Zeroth-order */
-    coeffs[0]  = 1.0f; /* ACN 0 = 1 */
-    /* First-order */
-    coeffs[1]  = 1.732050808f * y; /* ACN 1 = sqrt(3) * Y */
-    coeffs[2]  = 1.732050808f * z; /* ACN 2 = sqrt(3) * Z */
-    coeffs[3]  = 1.732050808f * x; /* ACN 3 = sqrt(3) * X */
-    /* Second-order */
-    coeffs[4]  = 3.872983346f * x * y;             /* ACN 4 = sqrt(15) * X * Y */
-    coeffs[5]  = 3.872983346f * y * z;             /* ACN 5 = sqrt(15) * Y * Z */
-    coeffs[6]  = 1.118033989f * (z*z*3.0f - 1.0f); /* ACN 6 = sqrt(5)/2 * (3*Z*Z - 1) */
-    coeffs[7]  = 3.872983346f * x * z;             /* ACN 7 = sqrt(15) * X * Z */
-    coeffs[8]  = 1.936491673f * (x*x - y*y);       /* ACN 8 = sqrt(15)/2 * (X*X - Y*Y) */
-    /* Third-order */
-    coeffs[9]  =  2.091650066f * y * (x*x*3.0f - y*y);  /* ACN  9 = sqrt(35/8) * Y * (3*X*X - Y*Y) */
-    coeffs[10] = 10.246950766f * z * x * y;             /* ACN 10 = sqrt(105) * Z * X * Y */
-    coeffs[11] =  1.620185175f * y * (z*z*5.0f - 1.0f); /* ACN 11 = sqrt(21/8) * Y * (5*Z*Z - 1) */
-    coeffs[12] =  1.322875656f * z * (z*z*5.0f - 3.0f); /* ACN 12 = sqrt(7)/2 * Z * (5*Z*Z - 3) */
-    coeffs[13] =  1.620185175f * x * (z*z*5.0f - 1.0f); /* ACN 13 = sqrt(21/8) * X * (5*Z*Z - 1) */
-    coeffs[14] =  5.123475383f * z * (x*x - y*y);       /* ACN 14 = sqrt(105)/2 * Z * (X*X - Y*Y) */
-    coeffs[15] =  2.091650066f * x * (x*x - y*y*3.0f);  /* ACN 15 = sqrt(35/8) * X * (X*X - 3*Y*Y) */
-    /* Fourth-order */
-    /* ACN 16 = sqrt(35)*3/2 * X * Y * (X*X - Y*Y) */
-    /* ACN 17 = sqrt(35/2)*3/2 * (3*X*X - Y*Y) * Y * Z */
-    /* ACN 18 = sqrt(5)*3/2 * X * Y * (7*Z*Z - 1) */
-    /* ACN 19 = sqrt(5/2)*3/2 * Y * Z * (7*Z*Z - 3)  */
-    /* ACN 20 = 3/8 * (35*Z*Z*Z*Z - 30*Z*Z + 3) */
-    /* ACN 21 = sqrt(5/2)*3/2 * X * Z * (7*Z*Z - 3) */
-    /* ACN 22 = sqrt(5)*3/4 * (X*X - Y*Y) * (7*Z*Z - 1) */
-    /* ACN 23 = sqrt(35/2)*3/2 * (X*X - 3*Y*Y) * X * Z */
-    /* ACN 24 = sqrt(35)*3/8 * (X*X*X*X - 6*X*X*Y*Y + Y*Y*Y*Y) */
-
-    if(spread > 0.0f)
-    {
-        /* Implement the spread by using a spherical source that subtends the
-         * angle spread. See:
-         * http://www.ppsloan.org/publications/StupidSH36.pdf - Appendix A3
-         *
-         * When adjusted for N3D normalization instead of SN3D, these
-         * calculations are:
-         *
-         * ZH0 = -sqrt(pi) * (-1+ca);
-         * ZH1 =  0.5*sqrt(pi) * sa*sa;
-         * ZH2 = -0.5*sqrt(pi) * ca*(-1+ca)*(ca+1);
-         * ZH3 = -0.125*sqrt(pi) * (-1+ca)*(ca+1)*(5*ca*ca - 1);
-         * ZH4 = -0.125*sqrt(pi) * ca*(-1+ca)*(ca+1)*(7*ca*ca - 3);
-         * ZH5 = -0.0625*sqrt(pi) * (-1+ca)*(ca+1)*(21*ca*ca*ca*ca - 14*ca*ca + 1);
-         *
-         * The gain of the source is compensated for size, so that the
-         * loudness doesn't depend on the spread. Thus:
-         *
-         * ZH0 = 1.0f;
-         * ZH1 = 0.5f * (ca+1.0f);
-         * ZH2 = 0.5f * (ca+1.0f)*ca;
-         * ZH3 = 0.125f * (ca+1.0f)*(5.0f*ca*ca - 1.0f);
-         * ZH4 = 0.125f * (ca+1.0f)*(7.0f*ca*ca - 3.0f)*ca;
-         * ZH5 = 0.0625f * (ca+1.0f)*(21.0f*ca*ca*ca*ca - 14.0f*ca*ca + 1.0f);
-         */
-        const float ca{std::cos(spread * 0.5f)};
-        /* Increase the source volume by up to +3dB for a full spread. */
-        const float scale{std::sqrt(1.0f + spread/al::MathDefs<float>::Tau())};
-
-        const float ZH0_norm{scale};
-        const float ZH1_norm{scale * 0.5f * (ca+1.f)};
-        const float ZH2_norm{scale * 0.5f * (ca+1.f)*ca};
-        const float ZH3_norm{scale * 0.125f * (ca+1.f)*(5.f*ca*ca-1.f)};
-
-        /* Zeroth-order */
-        coeffs[0]  *= ZH0_norm;
-        /* First-order */
-        coeffs[1]  *= ZH1_norm;
-        coeffs[2]  *= ZH1_norm;
-        coeffs[3]  *= ZH1_norm;
-        /* Second-order */
-        coeffs[4]  *= ZH2_norm;
-        coeffs[5]  *= ZH2_norm;
-        coeffs[6]  *= ZH2_norm;
-        coeffs[7]  *= ZH2_norm;
-        coeffs[8]  *= ZH2_norm;
-        /* Third-order */
-        coeffs[9]  *= ZH3_norm;
-        coeffs[10] *= ZH3_norm;
-        coeffs[11] *= ZH3_norm;
-        coeffs[12] *= ZH3_norm;
-        coeffs[13] *= ZH3_norm;
-        coeffs[14] *= ZH3_norm;
-        coeffs[15] *= ZH3_norm;
-    }
-}
-
-void ComputePanGains(const MixParams *mix, const float*RESTRICT coeffs, const float ingain,
-    const al::span<float,MAX_OUTPUT_CHANNELS> gains)
-{
-    auto ambimap = mix->AmbiMap.cbegin();
-
-    auto iter = std::transform(ambimap, ambimap+mix->Buffer.size(), gains.begin(),
-        [coeffs,ingain](const BFChannelConfig &chanmap) noexcept -> float
-        { return chanmap.Scale * coeffs[chanmap.Index] * ingain; }
-    );
-    std::fill(iter, gains.end(), 0.0f);
+    slot->Wet.Buffer = slot->mWetBuffer;
 }
diff --git a/alc/uhjfilter.cpp b/alc/uhjfilter.cpp
deleted file mode 100644
index 7d01a91f..00000000
--- a/alc/uhjfilter.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-
-#include "config.h"
-
-#include "uhjfilter.h"
-
-#include <algorithm>
-#include <iterator>
-
-#include "AL/al.h"
-
-#include "alnumeric.h"
-#include "opthelpers.h"
-
-
-namespace {
-
-/* This is the maximum number of samples processed for each inner loop
- * iteration. */
-#define MAX_UPDATE_SAMPLES  128
-
-
-constexpr ALfloat Filter1CoeffSqr[4] = {
-    0.479400865589f, 0.876218493539f, 0.976597589508f, 0.997499255936f
-};
-constexpr ALfloat Filter2CoeffSqr[4] = {
-    0.161758498368f, 0.733028932341f, 0.945349700329f, 0.990599156685f
-};
-
-void allpass_process(AllPassState *state, ALfloat *dst, const ALfloat *src, const ALfloat aa,
-    const size_t todo)
-{
-    ALfloat z1{state->z[0]};
-    ALfloat z2{state->z[1]};
-    auto proc_sample = [aa,&z1,&z2](const ALfloat input) noexcept -> ALfloat
-    {
-        const ALfloat output{input*aa + z1};
-        z1 = z2; z2 = output*aa - input;
-        return output;
-    };
-    std::transform(src, src+todo, dst, proc_sample);
-    state->z[0] = z1;
-    state->z[1] = z2;
-}
-
-} // namespace
-
-
-/* NOTE: There seems to be a bit of an inconsistency in how this encoding is
- * supposed to work. Some references, such as
- *
- * http://members.tripod.com/martin_leese/Ambisonic/UHJ_file_format.html
- *
- * specify a pre-scaling of sqrt(2) on the W channel input, while other
- * references, such as
- *
- * https://en.wikipedia.org/wiki/Ambisonic_UHJ_format#Encoding.5B1.5D
- * and
- * https://wiki.xiph.org/Ambisonics#UHJ_format
- *
- * do not. The sqrt(2) scaling is in line with B-Format decoder coefficients
- * which include such a scaling for the W channel input, however the original
- * source for this equation is a 1985 paper by Michael Gerzon, which does not
- * apparently include the scaling. Applying the extra scaling creates a louder
- * result with a narrower stereo image compared to not scaling, and I don't
- * know which is the intended result.
- */
-
-void Uhj2Encoder::encode(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
-    FloatBufferLine *InSamples, const size_t SamplesToDo)
-{
-    alignas(16) ALfloat D[MAX_UPDATE_SAMPLES], S[MAX_UPDATE_SAMPLES];
-    alignas(16) ALfloat temp[MAX_UPDATE_SAMPLES];
-
-    ASSUME(SamplesToDo > 0);
-
-    auto winput = InSamples[0].cbegin();
-    auto xinput = InSamples[1].cbegin();
-    auto yinput = InSamples[2].cbegin();
-    for(size_t base{0};base < SamplesToDo;)
-    {
-        const size_t todo{minz(SamplesToDo - base, MAX_UPDATE_SAMPLES)};
-        ASSUME(todo > 0);
-
-        /* D = 0.6554516*Y */
-        std::transform(yinput, yinput+todo, std::begin(temp),
-            [](const float y) noexcept -> float { return 0.6554516f*y; });
-        allpass_process(&mFilter1_Y[0], temp, temp, Filter1CoeffSqr[0], todo);
-        allpass_process(&mFilter1_Y[1], temp, temp, Filter1CoeffSqr[1], todo);
-        allpass_process(&mFilter1_Y[2], temp, temp, Filter1CoeffSqr[2], todo);
-        allpass_process(&mFilter1_Y[3], temp, temp, Filter1CoeffSqr[3], todo);
-        /* NOTE: Filter1 requires a 1 sample delay for the final output, so
-         * take the last processed sample from the previous run as the first
-         * output sample.
-         */
-        D[0] = mLastY;
-        for(size_t i{1};i < todo;i++)
-            D[i] = temp[i-1];
-        mLastY = temp[todo-1];
-
-        /* D += j(-0.3420201*W + 0.5098604*X) */
-        std::transform(winput, winput+todo, xinput, std::begin(temp),
-            [](const float w, const float x) noexcept -> float
-            { return -0.3420201f*w + 0.5098604f*x; });
-        allpass_process(&mFilter2_WX[0], temp, temp, Filter2CoeffSqr[0], todo);
-        allpass_process(&mFilter2_WX[1], temp, temp, Filter2CoeffSqr[1], todo);
-        allpass_process(&mFilter2_WX[2], temp, temp, Filter2CoeffSqr[2], todo);
-        allpass_process(&mFilter2_WX[3], temp, temp, Filter2CoeffSqr[3], todo);
-        for(size_t i{0};i < todo;i++)
-            D[i] += temp[i];
-
-        /* S = 0.9396926*W + 0.1855740*X */
-        std::transform(winput, winput+todo, xinput, std::begin(temp),
-            [](const float w, const float x) noexcept -> float
-            { return 0.9396926f*w + 0.1855740f*x; });
-        allpass_process(&mFilter1_WX[0], temp, temp, Filter1CoeffSqr[0], todo);
-        allpass_process(&mFilter1_WX[1], temp, temp, Filter1CoeffSqr[1], todo);
-        allpass_process(&mFilter1_WX[2], temp, temp, Filter1CoeffSqr[2], todo);
-        allpass_process(&mFilter1_WX[3], temp, temp, Filter1CoeffSqr[3], todo);
-        S[0] = mLastWX;
-        for(size_t i{1};i < todo;i++)
-            S[i] = temp[i-1];
-        mLastWX = temp[todo-1];
-
-        /* Left = (S + D)/2.0 */
-        ALfloat *RESTRICT left = al::assume_aligned<16>(LeftOut.data()+base);
-        for(size_t i{0};i < todo;i++)
-            left[i] += (S[i] + D[i]) * 0.5f;
-        /* Right = (S - D)/2.0 */
-        ALfloat *RESTRICT right = al::assume_aligned<16>(RightOut.data()+base);
-        for(size_t i{0};i < todo;i++)
-            right[i] += (S[i] - D[i]) * 0.5f;
-
-        winput += todo;
-        xinput += todo;
-        yinput += todo;
-        base += todo;
-    }
-}
diff --git a/alc/uhjfilter.h b/alc/uhjfilter.h
deleted file mode 100644
index 88d30351..00000000
--- a/alc/uhjfilter.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef UHJFILTER_H
-#define UHJFILTER_H
-
-#include "AL/al.h"
-
-#include "alcmain.h"
-#include "almalloc.h"
-
-
-struct AllPassState {
-    ALfloat z[2]{0.0f, 0.0f};
-};
-
-/* Encoding 2-channel UHJ from B-Format is done as:
- *
- * S = 0.9396926*W + 0.1855740*X
- * D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y
- *
- * Left = (S + D)/2.0
- * Right = (S - D)/2.0
- *
- * where j is a wide-band +90 degree phase shift.
- *
- * The phase shift is done using a Hilbert transform, described here:
- * https://web.archive.org/web/20060708031958/http://www.biochem.oulu.fi/~oniemita/dsp/hilbert/
- * It works using 2 sets of 4 chained filters. The first filter chain produces
- * a phase shift of varying magnitude over a wide range of frequencies, while
- * the second filter chain produces a phase shift 90 degrees ahead of the
- * first over the same range.
- *
- * Combining these two stages requires the use of three filter chains. S-
- * channel output uses a Filter1 chain on the W and X channel mix, while the D-
- * channel output uses a Filter1 chain on the Y channel plus a Filter2 chain on
- * the W and X channel mix. This results in the W and X input mix on the D-
- * channel output having the required +90 degree phase shift relative to the
- * other inputs.
- */
-
-struct Uhj2Encoder {
-    AllPassState mFilter1_Y[4];
-    AllPassState mFilter2_WX[4];
-    AllPassState mFilter1_WX[4];
-    ALfloat mLastY{0.0f}, mLastWX{0.0f};
-
-    /* Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
-     * signal. The input must use FuMa channel ordering and scaling.
-     */
-    void encode(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, FloatBufferLine *InSamples,
-        const size_t SamplesToDo);
-
-    DEF_NEWDEL(Uhj2Encoder)
-};
-
-#endif /* UHJFILTER_H */
diff --git a/alc/voice.cpp b/alc/voice.cpp
deleted file mode 100644
index 1c38f36f..00000000
--- a/alc/voice.cpp
+++ /dev/null
@@ -1,837 +0,0 @@
-/**
- * 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 "voice.h"
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cassert>
-#include <climits>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <memory>
-#include <new>
-#include <utility>
-
-#include "AL/al.h"
-#include "AL/alc.h"
-
-#include "al/buffer.h"
-#include "al/event.h"
-#include "al/source.h"
-#include "alcmain.h"
-#include "albyte.h"
-#include "alconfig.h"
-#include "alcontext.h"
-#include "alnumeric.h"
-#include "aloptional.h"
-#include "alspan.h"
-#include "alstring.h"
-#include "alu.h"
-#include "cpu_caps.h"
-#include "devformat.h"
-#include "filters/biquad.h"
-#include "filters/nfc.h"
-#include "filters/splitter.h"
-#include "hrtf.h"
-#include "inprogext.h"
-#include "logging.h"
-#include "mixer/defs.h"
-#include "opthelpers.h"
-#include "ringbuffer.h"
-#include "threads.h"
-#include "vector.h"
-
-
-static_assert((INT_MAX>>FRACTIONBITS)/MAX_PITCH > BUFFERSIZE,
-              "MAX_PITCH and/or BUFFERSIZE are too large for FRACTIONBITS!");
-
-
-Resampler ResamplerDefault{Resampler::Linear};
-
-namespace {
-
-using HrtfMixerFunc = void(*)(const ALfloat *InSamples, float2 *AccumSamples, const ALuint IrSize,
-    MixHrtfFilter *hrtfparams, const size_t BufferSize);
-using HrtfMixerBlendFunc = void(*)(const ALfloat *InSamples, float2 *AccumSamples,
-    const ALuint IrSize, const HrtfFilter *oldparams, MixHrtfFilter *newparams,
-    const size_t BufferSize);
-
-HrtfMixerFunc MixHrtfSamples = MixHrtf_<CTag>;
-HrtfMixerBlendFunc MixHrtfBlendSamples = MixHrtfBlend_<CTag>;
-
-inline HrtfMixerFunc SelectHrtfMixer()
-{
-#ifdef HAVE_NEON
-    if((CPUCapFlags&CPU_CAP_NEON))
-        return MixHrtf_<NEONTag>;
-#endif
-#ifdef HAVE_SSE
-    if((CPUCapFlags&CPU_CAP_SSE))
-        return MixHrtf_<SSETag>;
-#endif
-    return MixHrtf_<CTag>;
-}
-
-inline HrtfMixerBlendFunc SelectHrtfBlendMixer()
-{
-#ifdef HAVE_NEON
-    if((CPUCapFlags&CPU_CAP_NEON))
-        return MixHrtfBlend_<NEONTag>;
-#endif
-#ifdef HAVE_SSE
-    if((CPUCapFlags&CPU_CAP_SSE))
-        return MixHrtfBlend_<SSETag>;
-#endif
-    return MixHrtfBlend_<CTag>;
-}
-
-} // namespace
-
-
-void aluInitMixer()
-{
-    if(auto resopt = ConfigValueStr(nullptr, nullptr, "resampler"))
-    {
-        struct ResamplerEntry {
-            const char name[16];
-            const Resampler resampler;
-        };
-        constexpr ResamplerEntry ResamplerList[]{
-            { "none", Resampler::Point },
-            { "point", Resampler::Point },
-            { "cubic", Resampler::Cubic },
-            { "bsinc12", Resampler::BSinc12 },
-            { "fast_bsinc12", Resampler::FastBSinc12 },
-            { "bsinc24", Resampler::BSinc24 },
-            { "fast_bsinc24", Resampler::FastBSinc24 },
-        };
-
-        const char *str{resopt->c_str()};
-        if(al::strcasecmp(str, "bsinc") == 0)
-        {
-            WARN("Resampler option \"%s\" is deprecated, using bsinc12\n", str);
-            str = "bsinc12";
-        }
-        else if(al::strcasecmp(str, "sinc4") == 0 || al::strcasecmp(str, "sinc8") == 0)
-        {
-            WARN("Resampler option \"%s\" is deprecated, using cubic\n", str);
-            str = "cubic";
-        }
-
-        auto iter = std::find_if(std::begin(ResamplerList), std::end(ResamplerList),
-            [str](const ResamplerEntry &entry) -> bool
-            { return al::strcasecmp(str, entry.name) == 0; });
-        if(iter == std::end(ResamplerList))
-            ERR("Invalid resampler: %s\n", str);
-        else
-            ResamplerDefault = iter->resampler;
-    }
-
-    MixHrtfBlendSamples = SelectHrtfBlendMixer();
-    MixHrtfSamples = SelectHrtfMixer();
-}
-
-
-namespace {
-
-/* A quick'n'dirty lookup table to decode a muLaw-encoded byte sample into a
- * signed 16-bit sample */
-constexpr ALshort muLawDecompressionTable[256] = {
-    -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
-    -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
-    -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
-    -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
-     -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
-     -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
-     -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
-     -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
-     -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
-     -1372, -1308, -1244, -1180, -1116, -1052,  -988,  -924,
-      -876,  -844,  -812,  -780,  -748,  -716,  -684,  -652,
-      -620,  -588,  -556,  -524,  -492,  -460,  -428,  -396,
-      -372,  -356,  -340,  -324,  -308,  -292,  -276,  -260,
-      -244,  -228,  -212,  -196,  -180,  -164,  -148,  -132,
-      -120,  -112,  -104,   -96,   -88,   -80,   -72,   -64,
-       -56,   -48,   -40,   -32,   -24,   -16,    -8,     0,
-     32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
-     23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
-     15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
-     11900, 11388, 10876, 10364,  9852,  9340,  8828,  8316,
-      7932,  7676,  7420,  7164,  6908,  6652,  6396,  6140,
-      5884,  5628,  5372,  5116,  4860,  4604,  4348,  4092,
-      3900,  3772,  3644,  3516,  3388,  3260,  3132,  3004,
-      2876,  2748,  2620,  2492,  2364,  2236,  2108,  1980,
-      1884,  1820,  1756,  1692,  1628,  1564,  1500,  1436,
-      1372,  1308,  1244,  1180,  1116,  1052,   988,   924,
-       876,   844,   812,   780,   748,   716,   684,   652,
-       620,   588,   556,   524,   492,   460,   428,   396,
-       372,   356,   340,   324,   308,   292,   276,   260,
-       244,   228,   212,   196,   180,   164,   148,   132,
-       120,   112,   104,    96,    88,    80,    72,    64,
-        56,    48,    40,    32,    24,    16,     8,     0
-};
-
-/* A quick'n'dirty lookup table to decode an aLaw-encoded byte sample into a
- * signed 16-bit sample */
-constexpr ALshort aLawDecompressionTable[256] = {
-     -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-     -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-     -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
-     -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
-    -22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
-    -30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
-    -11008,-10496,-12032,-11520, -8960, -8448, -9984, -9472,
-    -15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
-      -344,  -328,  -376,  -360,  -280,  -264,  -312,  -296,
-      -472,  -456,  -504,  -488,  -408,  -392,  -440,  -424,
-       -88,   -72,  -120,  -104,   -24,    -8,   -56,   -40,
-      -216,  -200,  -248,  -232,  -152,  -136,  -184,  -168,
-     -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
-     -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
-      -688,  -656,  -752,  -720,  -560,  -528,  -624,  -592,
-      -944,  -912, -1008,  -976,  -816,  -784,  -880,  -848,
-      5504,  5248,  6016,  5760,  4480,  4224,  4992,  4736,
-      7552,  7296,  8064,  7808,  6528,  6272,  7040,  6784,
-      2752,  2624,  3008,  2880,  2240,  2112,  2496,  2368,
-      3776,  3648,  4032,  3904,  3264,  3136,  3520,  3392,
-     22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
-     30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
-     11008, 10496, 12032, 11520,  8960,  8448,  9984,  9472,
-     15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
-       344,   328,   376,   360,   280,   264,   312,   296,
-       472,   456,   504,   488,   408,   392,   440,   424,
-        88,    72,   120,   104,    24,     8,    56,    40,
-       216,   200,   248,   232,   152,   136,   184,   168,
-      1376,  1312,  1504,  1440,  1120,  1056,  1248,  1184,
-      1888,  1824,  2016,  1952,  1632,  1568,  1760,  1696,
-       688,   656,   752,   720,   560,   528,   624,   592,
-       944,   912,  1008,   976,   816,   784,   880,   848
-};
-
-template<FmtType T>
-struct FmtTypeTraits { };
-
-template<>
-struct FmtTypeTraits<FmtUByte> {
-    using Type = ALubyte;
-    static constexpr inline float to_float(const Type val) noexcept
-    { return val*(1.0f/128.0f) - 1.0f; }
-};
-template<>
-struct FmtTypeTraits<FmtShort> {
-    using Type = ALshort;
-    static constexpr inline float to_float(const Type val) noexcept { return val*(1.0f/32768.0f); }
-};
-template<>
-struct FmtTypeTraits<FmtFloat> {
-    using Type = ALfloat;
-    static constexpr inline float to_float(const Type val) noexcept { return val; }
-};
-template<>
-struct FmtTypeTraits<FmtDouble> {
-    using Type = ALdouble;
-    static constexpr inline float to_float(const Type val) noexcept
-    { return static_cast<ALfloat>(val); }
-};
-template<>
-struct FmtTypeTraits<FmtMulaw> {
-    using Type = ALubyte;
-    static constexpr inline float to_float(const Type val) noexcept
-    { return muLawDecompressionTable[val] * (1.0f/32768.0f); }
-};
-template<>
-struct FmtTypeTraits<FmtAlaw> {
-    using Type = ALubyte;
-    static constexpr inline float to_float(const Type val) noexcept
-    { return aLawDecompressionTable[val] * (1.0f/32768.0f); }
-};
-
-
-void SendSourceStoppedEvent(ALCcontext *context, ALuint id)
-{
-    RingBuffer *ring{context->mAsyncEvents.get()};
-    auto evt_vec = ring->getWriteVector();
-    if(evt_vec.first.len < 1) return;
-
-    AsyncEvent *evt{new (evt_vec.first.buf) AsyncEvent{EventType_SourceStateChange}};
-    evt->u.srcstate.id = id;
-    evt->u.srcstate.state = AL_STOPPED;
-
-    ring->writeAdvance(1);
-    context->mEventSem.post();
-}
-
-
-const ALfloat *DoFilters(BiquadFilter *lpfilter, BiquadFilter *hpfilter, ALfloat *dst,
-    const ALfloat *src, const size_t numsamples, int type)
-{
-    switch(type)
-    {
-        case AF_None:
-            lpfilter->clear();
-            hpfilter->clear();
-            break;
-
-        case AF_LowPass:
-            lpfilter->process(dst, src, numsamples);
-            hpfilter->clear();
-            return dst;
-        case AF_HighPass:
-            lpfilter->clear();
-            hpfilter->process(dst, src, numsamples);
-            return dst;
-
-        case AF_BandPass:
-            lpfilter->process(dst, src, numsamples);
-            hpfilter->process(dst, dst, numsamples);
-            return dst;
-    }
-    return src;
-}
-
-
-template<FmtType T>
-inline void LoadSampleArray(ALfloat *RESTRICT dst, const al::byte *src, const size_t srcstep,
-    const size_t samples) noexcept
-{
-    using SampleType = typename FmtTypeTraits<T>::Type;
-
-    const SampleType *RESTRICT ssrc{reinterpret_cast<const SampleType*>(src)};
-    for(size_t i{0u};i < samples;i++)
-        dst[i] = FmtTypeTraits<T>::to_float(ssrc[i*srcstep]);
-}
-
-void LoadSamples(ALfloat *RESTRICT dst, const al::byte *src, const size_t srcstep, FmtType srctype,
-    const size_t samples) noexcept
-{
-#define HANDLE_FMT(T)  case T: LoadSampleArray<T>(dst, src, srcstep, samples); break
-    switch(srctype)
-    {
-        HANDLE_FMT(FmtUByte);
-        HANDLE_FMT(FmtShort);
-        HANDLE_FMT(FmtFloat);
-        HANDLE_FMT(FmtDouble);
-        HANDLE_FMT(FmtMulaw);
-        HANDLE_FMT(FmtAlaw);
-    }
-#undef HANDLE_FMT
-}
-
-ALfloat *LoadBufferStatic(ALbufferlistitem *BufferListItem, ALbufferlistitem *&BufferLoopItem,
-    const size_t NumChannels, const size_t SampleSize, const size_t chan, size_t DataPosInt,
-    al::span<ALfloat> SrcBuffer)
-{
-    const ALbuffer *Buffer{BufferListItem->mBuffer};
-    const ALuint LoopStart{Buffer->LoopStart};
-    const ALuint LoopEnd{Buffer->LoopEnd};
-    ASSUME(LoopEnd > LoopStart);
-
-    /* If current pos is beyond the loop range, do not loop */
-    if(!BufferLoopItem || DataPosInt >= LoopEnd)
-    {
-        BufferLoopItem = nullptr;
-
-        /* Load what's left to play from the buffer */
-        const size_t DataRem{minz(SrcBuffer.size(), Buffer->SampleLen-DataPosInt)};
-
-        const al::byte *Data{Buffer->mData.data()};
-        Data += (DataPosInt*NumChannels + chan)*SampleSize;
-
-        LoadSamples(SrcBuffer.data(), Data, NumChannels, Buffer->mFmtType, DataRem);
-        SrcBuffer = SrcBuffer.subspan(DataRem);
-    }
-    else
-    {
-        /* Load what's left of this loop iteration */
-        const size_t DataRem{minz(SrcBuffer.size(), LoopEnd-DataPosInt)};
-
-        const al::byte *Data{Buffer->mData.data()};
-        Data += (DataPosInt*NumChannels + chan)*SampleSize;
-
-        LoadSamples(SrcBuffer.data(), Data, NumChannels, Buffer->mFmtType, DataRem);
-        SrcBuffer = SrcBuffer.subspan(DataRem);
-
-        /* Load any repeats of the loop we can to fill the buffer. */
-        const auto LoopSize = static_cast<size_t>(LoopEnd - LoopStart);
-        while(!SrcBuffer.empty())
-        {
-            const size_t DataSize{minz(SrcBuffer.size(), LoopSize)};
-
-            Data = Buffer->mData.data() + (LoopStart*NumChannels + chan)*SampleSize;
-
-            LoadSamples(SrcBuffer.data(), Data, NumChannels, Buffer->mFmtType, DataSize);
-            SrcBuffer = SrcBuffer.subspan(DataSize);
-        }
-    }
-    return SrcBuffer.begin();
-}
-
-ALfloat *LoadBufferQueue(ALbufferlistitem *BufferListItem, ALbufferlistitem *BufferLoopItem,
-    const size_t NumChannels, const size_t SampleSize, const size_t chan, size_t DataPosInt,
-    al::span<ALfloat> SrcBuffer)
-{
-    /* Crawl the buffer queue to fill in the temp buffer */
-    while(BufferListItem && !SrcBuffer.empty())
-    {
-        ALbuffer *Buffer{BufferListItem->mBuffer};
-        if(!(Buffer && DataPosInt < Buffer->SampleLen))
-        {
-            if(Buffer) DataPosInt -= Buffer->SampleLen;
-            BufferListItem = BufferListItem->mNext.load(std::memory_order_acquire);
-            if(!BufferListItem) BufferListItem = BufferLoopItem;
-            continue;
-        }
-
-        const size_t DataSize{minz(SrcBuffer.size(), Buffer->SampleLen-DataPosInt)};
-
-        const al::byte *Data{Buffer->mData.data()};
-        Data += (DataPosInt*NumChannels + chan)*SampleSize;
-
-        LoadSamples(SrcBuffer.data(), Data, NumChannels, Buffer->mFmtType, DataSize);
-        SrcBuffer = SrcBuffer.subspan(DataSize);
-        if(SrcBuffer.empty()) break;
-
-        DataPosInt = 0;
-        BufferListItem = BufferListItem->mNext.load(std::memory_order_acquire);
-        if(!BufferListItem) BufferListItem = BufferLoopItem;
-    }
-
-    return SrcBuffer.begin();
-}
-
-
-void DoHrtfMix(const float TargetGain, DirectParams &parms, const float *samples,
-    const ALuint DstBufferSize, const ALuint Counter, ALuint OutPos, const ALuint IrSize,
-    ALCdevice *Device)
-{
-    auto &HrtfSamples = Device->HrtfSourceData;
-    auto &AccumSamples = Device->HrtfAccumData;
-
-    /* Copy the HRTF history and new input samples into a temp buffer. */
-    auto src_iter = std::copy(parms.Hrtf.State.History.begin(), parms.Hrtf.State.History.end(),
-        std::begin(HrtfSamples));
-    std::copy_n(samples, DstBufferSize, src_iter);
-    /* Copy the last used samples back into the history buffer for later. */
-    std::copy_n(std::begin(HrtfSamples) + DstBufferSize, parms.Hrtf.State.History.size(),
-        parms.Hrtf.State.History.begin());
-
-    /* If fading, the old gain is not silence, and this is the first mixing
-     * pass, fade between the IRs.
-     */
-    ALuint fademix{0u};
-    if(Counter && parms.Hrtf.Old.Gain > GAIN_SILENCE_THRESHOLD && OutPos == 0)
-    {
-        fademix = minu(DstBufferSize, 128);
-
-        float gain{TargetGain};
-
-        /* The new coefficients need to fade in completely since they're
-         * replacing the old ones. To keep the gain fading consistent,
-         * interpolate between the old and new target gains given how much of
-         * the fade time this mix handles.
-         */
-        if LIKELY(Counter > fademix)
-        {
-            const ALfloat a{static_cast<float>(fademix) / static_cast<float>(Counter)};
-            gain = lerp(parms.Hrtf.Old.Gain, TargetGain, a);
-        }
-        MixHrtfFilter hrtfparams;
-        hrtfparams.Coeffs = &parms.Hrtf.Target.Coeffs;
-        hrtfparams.Delay[0] = parms.Hrtf.Target.Delay[0];
-        hrtfparams.Delay[1] = parms.Hrtf.Target.Delay[1];
-        hrtfparams.Gain = 0.0f;
-        hrtfparams.GainStep = gain / static_cast<float>(fademix);
-
-        MixHrtfBlendSamples(HrtfSamples, AccumSamples+OutPos, IrSize, &parms.Hrtf.Old, &hrtfparams,
-            fademix);
-        /* Update the old parameters with the result. */
-        parms.Hrtf.Old = parms.Hrtf.Target;
-        if(fademix < Counter)
-            parms.Hrtf.Old.Gain = hrtfparams.Gain;
-        else
-            parms.Hrtf.Old.Gain = TargetGain;
-        OutPos += fademix;
-    }
-
-    if LIKELY(fademix < DstBufferSize)
-    {
-        const ALuint todo{DstBufferSize - fademix};
-        float gain{TargetGain};
-
-        /* Interpolate the target gain if the gain fading lasts longer than
-         * this mix.
-         */
-        if(Counter > DstBufferSize)
-        {
-            const float a{static_cast<float>(todo) / static_cast<float>(Counter-fademix)};
-            gain = lerp(parms.Hrtf.Old.Gain, TargetGain, a);
-        }
-
-        MixHrtfFilter hrtfparams;
-        hrtfparams.Coeffs = &parms.Hrtf.Target.Coeffs;
-        hrtfparams.Delay[0] = parms.Hrtf.Target.Delay[0];
-        hrtfparams.Delay[1] = parms.Hrtf.Target.Delay[1];
-        hrtfparams.Gain = parms.Hrtf.Old.Gain;
-        hrtfparams.GainStep = (gain - parms.Hrtf.Old.Gain) / static_cast<float>(todo);
-        MixHrtfSamples(HrtfSamples+fademix, AccumSamples+OutPos, IrSize, &hrtfparams, todo);
-        /* Store the interpolated gain or the final target gain depending if
-         * the fade is done.
-         */
-        if(DstBufferSize < Counter)
-            parms.Hrtf.Old.Gain = gain;
-        else
-            parms.Hrtf.Old.Gain = TargetGain;
-    }
-}
-
-void DoNfcMix(ALvoice::TargetData &Direct, const float *TargetGains, DirectParams &parms,
-    const float *samples, const ALuint DstBufferSize, const ALuint Counter, const ALuint OutPos,
-    ALCdevice *Device)
-{
-    const size_t outcount{Device->NumChannelsPerOrder[0]};
-    MixSamples({samples, DstBufferSize}, Direct.Buffer.first(outcount),
-        parms.Gains.Current.data(), TargetGains, Counter, OutPos);
-
-    const al::span<float> nfcsamples{Device->NfcSampleData, DstBufferSize};
-    size_t chanoffset{outcount};
-    using FilterProc = void (NfcFilter::*)(float*,const float*,const size_t);
-    auto apply_nfc = [&Direct,&parms,samples,TargetGains,Counter,OutPos,&chanoffset,nfcsamples](
-        const FilterProc process, const size_t chancount) -> void
-    {
-        if(chancount < 1) return;
-        (parms.NFCtrlFilter.*process)(nfcsamples.data(), samples, nfcsamples.size());
-        MixSamples(nfcsamples, Direct.Buffer.subspan(chanoffset, chancount),
-            &parms.Gains.Current[chanoffset], &TargetGains[chanoffset], Counter, OutPos);
-        chanoffset += chancount;
-    };
-    apply_nfc(&NfcFilter::process1, Device->NumChannelsPerOrder[1]);
-    apply_nfc(&NfcFilter::process2, Device->NumChannelsPerOrder[2]);
-    apply_nfc(&NfcFilter::process3, Device->NumChannelsPerOrder[3]);
-}
-
-} // namespace
-
-void ALvoice::mix(const State vstate, ALCcontext *Context, const ALuint SamplesToDo)
-{
-    static constexpr std::array<float,MAX_OUTPUT_CHANNELS> SilentTarget{};
-
-    ASSUME(SamplesToDo > 0);
-
-    /* Get voice info */
-    const bool isstatic{(mFlags&VOICE_IS_STATIC) != 0};
-    ALuint DataPosInt{mPosition.load(std::memory_order_relaxed)};
-    ALuint DataPosFrac{mPositionFrac.load(std::memory_order_relaxed)};
-    ALbufferlistitem *BufferListItem{mCurrentBuffer.load(std::memory_order_relaxed)};
-    ALbufferlistitem *BufferLoopItem{mLoopBuffer.load(std::memory_order_relaxed)};
-    const ALuint NumChannels{mNumChannels};
-    const ALuint SampleSize{mSampleSize};
-    const ALuint increment{mStep};
-    if(increment < 1) return;
-
-    ASSUME(NumChannels > 0);
-    ASSUME(SampleSize > 0);
-    ASSUME(increment > 0);
-
-    ALCdevice *Device{Context->mDevice.get()};
-    const ALuint NumSends{Device->NumAuxSends};
-    const ALuint IrSize{Device->mHrtf ? Device->mHrtf->irSize : 0};
-
-    ResamplerFunc Resample{(increment == FRACTIONONE && DataPosFrac == 0) ?
-                           Resample_<CopyTag,CTag> : mResampler};
-
-    ALuint Counter{(mFlags&VOICE_IS_FADING) ? SamplesToDo : 0};
-    if(!Counter)
-    {
-        /* No fading, just overwrite the old/current params. */
-        for(ALuint chan{0};chan < NumChannels;chan++)
-        {
-            ChannelData &chandata = mChans[chan];
-            {
-                DirectParams &parms = chandata.mDryParams;
-                if(!(mFlags&VOICE_HAS_HRTF))
-                    parms.Gains.Current = parms.Gains.Target;
-                else
-                    parms.Hrtf.Old = parms.Hrtf.Target;
-            }
-            for(ALuint send{0};send < NumSends;++send)
-            {
-                if(mSend[send].Buffer.empty())
-                    continue;
-
-                SendParams &parms = chandata.mWetParams[send];
-                parms.Gains.Current = parms.Gains.Target;
-            }
-        }
-    }
-    else if((mFlags&VOICE_HAS_HRTF))
-    {
-        for(ALuint chan{0};chan < NumChannels;chan++)
-        {
-            DirectParams &parms = mChans[chan].mDryParams;
-            if(!(parms.Hrtf.Old.Gain > GAIN_SILENCE_THRESHOLD))
-            {
-                /* The old HRTF params are silent, so overwrite the old
-                 * coefficients with the new, and reset the old gain to 0. The
-                 * future mix will then fade from silence.
-                 */
-                parms.Hrtf.Old = parms.Hrtf.Target;
-                parms.Hrtf.Old.Gain = 0.0f;
-            }
-        }
-    }
-
-    ALuint buffers_done{0u};
-    ALuint OutPos{0u};
-    do {
-        /* Figure out how many buffer samples will be needed */
-        ALuint DstBufferSize{SamplesToDo - OutPos};
-
-        /* Calculate the last written dst sample pos. */
-        uint64_t DataSize64{DstBufferSize - 1};
-        /* Calculate the last read src sample pos. */
-        DataSize64 = (DataSize64*increment + DataPosFrac) >> FRACTIONBITS;
-        /* +1 to get the src sample count, include padding. */
-        DataSize64 += 1 + MAX_RESAMPLER_PADDING;
-
-        auto SrcBufferSize = static_cast<ALuint>(
-            minu64(DataSize64, BUFFERSIZE + MAX_RESAMPLER_PADDING + 1));
-        if(SrcBufferSize > BUFFERSIZE + MAX_RESAMPLER_PADDING)
-        {
-            SrcBufferSize = BUFFERSIZE + MAX_RESAMPLER_PADDING;
-            /* If the source buffer got saturated, we can't fill the desired
-             * dst size. Figure out how many samples we can actually mix from
-             * this.
-             */
-            DataSize64 = SrcBufferSize - MAX_RESAMPLER_PADDING;
-            DataSize64 = ((DataSize64<<FRACTIONBITS) - DataPosFrac + increment-1) / increment;
-            DstBufferSize = static_cast<ALuint>(minu64(DataSize64, DstBufferSize));
-
-            /* Some mixers like having a multiple of 4, so try to give that
-             * unless this is the last update.
-             */
-            if(DstBufferSize < SamplesToDo-OutPos)
-                DstBufferSize &= ~3u;
-        }
-
-        ASSUME(DstBufferSize > 0);
-        for(ALuint chan{0};chan < NumChannels;chan++)
-        {
-            ChannelData &chandata = mChans[chan];
-            const al::span<ALfloat> SrcData{Device->SourceData, SrcBufferSize};
-
-            /* Load the previous samples into the source data first, then load
-             * what we can from the buffer queue.
-             */
-            auto srciter = std::copy_n(chandata.mPrevSamples.begin(), MAX_RESAMPLER_PADDING>>1,
-                SrcData.begin());
-
-            if UNLIKELY(!BufferListItem)
-                srciter = std::copy(chandata.mPrevSamples.begin()+(MAX_RESAMPLER_PADDING>>1),
-                    chandata.mPrevSamples.end(), srciter);
-            else if(isstatic)
-                srciter = LoadBufferStatic(BufferListItem, BufferLoopItem, NumChannels,
-                    SampleSize, chan, DataPosInt, {srciter, SrcData.end()});
-            else
-                srciter = LoadBufferQueue(BufferListItem, BufferLoopItem, NumChannels,
-                    SampleSize, chan, DataPosInt, {srciter, SrcData.end()});
-
-            if UNLIKELY(srciter != SrcData.end())
-            {
-                /* If the source buffer wasn't filled, copy the last sample for
-                 * the remaining buffer. Ideally it should have ended with
-                 * silence, but if not the gain fading should help avoid clicks
-                 * from sudden amplitude changes.
-                 */
-                const ALfloat sample{*(srciter-1)};
-                std::fill(srciter, SrcData.end(), sample);
-            }
-
-            /* Store the last source samples used for next time. */
-            std::copy_n(&SrcData[(increment*DstBufferSize + DataPosFrac)>>FRACTIONBITS],
-                chandata.mPrevSamples.size(), chandata.mPrevSamples.begin());
-
-            /* Resample, then apply ambisonic upsampling as needed. */
-            const ALfloat *ResampledData{Resample(&mResampleState,
-                &SrcData[MAX_RESAMPLER_PADDING>>1], DataPosFrac, increment,
-                {Device->ResampledData, DstBufferSize})};
-            if((mFlags&VOICE_IS_AMBISONIC))
-            {
-                const ALfloat hfscale{chandata.mAmbiScale};
-                /* Beware the evil const_cast. It's safe since it's pointing to
-                 * either SourceData or ResampledData (both non-const), but the
-                 * resample method takes the source as const float* and may
-                 * return it without copying to output, making it currently
-                 * unavoidable.
-                 */
-                chandata.mAmbiSplitter.applyHfScale(const_cast<ALfloat*>(ResampledData), hfscale,
-                    DstBufferSize);
-            }
-
-            /* Now filter and mix to the appropriate outputs. */
-            ALfloat (&FilterBuf)[BUFFERSIZE] = Device->FilteredData;
-            {
-                DirectParams &parms = chandata.mDryParams;
-                const ALfloat *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
-                    ResampledData, DstBufferSize, mDirect.FilterType)};
-
-                if((mFlags&VOICE_HAS_HRTF))
-                {
-                    const ALfloat TargetGain{UNLIKELY(vstate == ALvoice::Stopping) ? 0.0f :
-                        parms.Hrtf.Target.Gain};
-                    DoHrtfMix(TargetGain, parms, samples, DstBufferSize, Counter, OutPos, IrSize,
-                        Device);
-                }
-                else if((mFlags&VOICE_HAS_NFC))
-                {
-                    const float *TargetGains{UNLIKELY(vstate == ALvoice::Stopping) ?
-                        SilentTarget.data() : parms.Gains.Target.data()};
-                    DoNfcMix(mDirect, TargetGains, parms, samples, DstBufferSize, Counter, OutPos,
-                        Device);
-                }
-                else
-                {
-                    const float *TargetGains{UNLIKELY(vstate == ALvoice::Stopping) ?
-                        SilentTarget.data() : parms.Gains.Target.data()};
-                    MixSamples({samples, DstBufferSize}, mDirect.Buffer,
-                        parms.Gains.Current.data(), TargetGains, Counter, OutPos);
-                }
-            }
-
-            for(ALuint send{0};send < NumSends;++send)
-            {
-                if(mSend[send].Buffer.empty())
-                    continue;
-
-                SendParams &parms = chandata.mWetParams[send];
-                const ALfloat *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
-                    ResampledData, DstBufferSize, mSend[send].FilterType)};
-
-                const float *TargetGains{UNLIKELY(vstate == ALvoice::Stopping) ?
-                    SilentTarget.data() : parms.Gains.Target.data()};
-                MixSamples({samples, DstBufferSize}, mSend[send].Buffer,
-                    parms.Gains.Current.data(), TargetGains, Counter, OutPos);
-            }
-        }
-        /* Update positions */
-        DataPosFrac += increment*DstBufferSize;
-        DataPosInt  += DataPosFrac>>FRACTIONBITS;
-        DataPosFrac &= FRACTIONMASK;
-
-        OutPos += DstBufferSize;
-        Counter = maxu(DstBufferSize, Counter) - DstBufferSize;
-
-        if UNLIKELY(!BufferListItem)
-        {
-            /* Do nothing extra when there's no buffers. */
-        }
-        else if(isstatic)
-        {
-            if(BufferLoopItem)
-            {
-                /* Handle looping static source */
-                const ALbuffer *Buffer{BufferListItem->mBuffer};
-                const ALuint LoopStart{Buffer->LoopStart};
-                const ALuint LoopEnd{Buffer->LoopEnd};
-                if(DataPosInt >= LoopEnd)
-                {
-                    assert(LoopEnd > LoopStart);
-                    DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
-                }
-            }
-            else
-            {
-                /* Handle non-looping static source */
-                if(DataPosInt >= BufferListItem->mSampleLen)
-                {
-                    BufferListItem = nullptr;
-                    break;
-                }
-            }
-        }
-        else
-        {
-            /* Handle streaming source */
-            do {
-                if(BufferListItem->mSampleLen > DataPosInt)
-                    break;
-
-                DataPosInt -= BufferListItem->mSampleLen;
-
-                ++buffers_done;
-                BufferListItem = BufferListItem->mNext.load(std::memory_order_relaxed);
-                if(!BufferListItem) BufferListItem = BufferLoopItem;
-            } while(BufferListItem);
-        }
-    } while(OutPos < SamplesToDo);
-
-    mFlags |= VOICE_IS_FADING;
-
-    /* Don't update positions and buffers if we were stopping. */
-    if UNLIKELY(vstate == ALvoice::Stopping)
-    {
-        mPlayState.store(ALvoice::Stopped, std::memory_order_release);
-        return;
-    }
-
-    /* Capture the source ID in case it's reset for stopping. */
-    const ALuint SourceID{mSourceID.load(std::memory_order_relaxed)};
-
-    /* Update voice info */
-    mPosition.store(DataPosInt, std::memory_order_relaxed);
-    mPositionFrac.store(DataPosFrac, std::memory_order_relaxed);
-    mCurrentBuffer.store(BufferListItem, std::memory_order_relaxed);
-    if(!BufferListItem)
-    {
-        mLoopBuffer.store(nullptr, std::memory_order_relaxed);
-        mSourceID.store(0u, std::memory_order_relaxed);
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-
-    /* Send any events now, after the position/buffer info was updated. */
-    const ALbitfieldSOFT enabledevt{Context->mEnabledEvts.load(std::memory_order_acquire)};
-    if(buffers_done > 0 && (enabledevt&EventType_BufferCompleted))
-    {
-        RingBuffer *ring{Context->mAsyncEvents.get()};
-        auto evt_vec = ring->getWriteVector();
-        if(evt_vec.first.len > 0)
-        {
-            AsyncEvent *evt{new (evt_vec.first.buf) AsyncEvent{EventType_BufferCompleted}};
-            evt->u.bufcomp.id = SourceID;
-            evt->u.bufcomp.count = buffers_done;
-            ring->writeAdvance(1);
-            Context->mEventSem.post();
-        }
-    }
-
-    if(!BufferListItem)
-    {
-        /* If the voice just ended, set it to Stopping so the next render
-         * ensures any residual noise fades to 0 amplitude.
-         */
-        mPlayState.store(ALvoice::Stopping, std::memory_order_release);
-        if((enabledevt&EventType_SourceStateChange))
-            SendSourceStoppedEvent(Context, SourceID);
-    }
-}
diff --git a/alc/voice.h b/alc/voice.h
deleted file mode 100644
index d6b624f9..00000000
--- a/alc/voice.h
+++ /dev/null
@@ -1,293 +0,0 @@
-#ifndef VOICE_H
-#define VOICE_H
-
-#include <array>
-
-#include "AL/al.h"
-#include "AL/alext.h"
-
-#include "al/buffer.h"
-#include "alspan.h"
-#include "alu.h"
-#include "filters/biquad.h"
-#include "filters/nfc.h"
-#include "filters/splitter.h"
-#include "hrtf.h"
-
-enum class DistanceModel;
-
-
-enum SpatializeMode {
-    SpatializeOff = AL_FALSE,
-    SpatializeOn = AL_TRUE,
-    SpatializeAuto = AL_AUTO_SOFT
-};
-
-enum class Resampler {
-    Point,
-    Linear,
-    Cubic,
-    FastBSinc12,
-    BSinc12,
-    FastBSinc24,
-    BSinc24,
-
-    Max = BSinc24
-};
-extern Resampler ResamplerDefault;
-
-/* The number of distinct scale and phase intervals within the bsinc filter
- * table.
- */
-#define BSINC_SCALE_BITS  4
-#define BSINC_SCALE_COUNT (1<<BSINC_SCALE_BITS)
-#define BSINC_PHASE_BITS  5
-#define BSINC_PHASE_COUNT (1<<BSINC_PHASE_BITS)
-
-/* Interpolator state.  Kind of a misnomer since the interpolator itself is
- * stateless.  This just keeps it from having to recompute scale-related
- * mappings for every sample.
- */
-struct BsincState {
-    float sf; /* Scale interpolation factor. */
-    ALuint m; /* Coefficient count. */
-    ALuint l; /* Left coefficient offset. */
-    /* Filter coefficients, followed by the phase, scale, and scale-phase
-     * delta coefficients. Starting at phase index 0, each subsequent phase
-     * index follows contiguously.
-     */
-    const float *filter;
-};
-
-union InterpState {
-    BsincState bsinc;
-};
-
-using ResamplerFunc = const float*(*)(const InterpState *state, const float *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst);
-
-ResamplerFunc PrepareResampler(Resampler resampler, ALuint increment, InterpState *state);
-
-
-enum {
-    AF_None = 0,
-    AF_LowPass = 1,
-    AF_HighPass = 2,
-    AF_BandPass = AF_LowPass | AF_HighPass
-};
-
-
-struct MixHrtfFilter {
-    const HrirArray *Coeffs;
-    ALsizei Delay[2];
-    float Gain;
-    float GainStep;
-};
-
-
-struct DirectParams {
-    BiquadFilter LowPass;
-    BiquadFilter HighPass;
-
-    NfcFilter NFCtrlFilter;
-
-    struct {
-        HrtfFilter Old;
-        HrtfFilter Target;
-        HrtfState State;
-    } Hrtf;
-
-    struct {
-        std::array<float,MAX_OUTPUT_CHANNELS> Current;
-        std::array<float,MAX_OUTPUT_CHANNELS> Target;
-    } Gains;
-};
-
-struct SendParams {
-    BiquadFilter LowPass;
-    BiquadFilter HighPass;
-
-    struct {
-        std::array<float,MAX_OUTPUT_CHANNELS> Current;
-        std::array<float,MAX_OUTPUT_CHANNELS> Target;
-    } Gains;
-};
-
-
-struct ALvoicePropsBase {
-    float Pitch;
-    float Gain;
-    float OuterGain;
-    float MinGain;
-    float MaxGain;
-    float InnerAngle;
-    float OuterAngle;
-    float RefDistance;
-    float MaxDistance;
-    float RolloffFactor;
-    std::array<float,3> Position;
-    std::array<float,3> Velocity;
-    std::array<float,3> Direction;
-    std::array<float,3> OrientAt;
-    std::array<float,3> OrientUp;
-    bool HeadRelative;
-    DistanceModel mDistanceModel;
-    Resampler mResampler;
-    bool DirectChannels;
-    SpatializeMode mSpatializeMode;
-
-    bool DryGainHFAuto;
-    bool WetGainAuto;
-    bool WetGainHFAuto;
-    float OuterGainHF;
-
-    float AirAbsorptionFactor;
-    float RoomRolloffFactor;
-    float DopplerFactor;
-
-    std::array<float,2> StereoPan;
-
-    float Radius;
-
-    /** 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;
-    } Send[MAX_SENDS];
-};
-
-struct ALvoiceProps : public ALvoicePropsBase {
-    std::atomic<ALvoiceProps*> next{nullptr};
-
-    DEF_NEWDEL(ALvoiceProps)
-};
-
-#define VOICE_IS_STATIC    (1u<<0)
-#define VOICE_IS_FADING    (1u<<1) /* Fading sources use gain stepping for smooth transitions. */
-#define VOICE_IS_AMBISONIC (1u<<2) /* Voice needs HF scaling for ambisonic upsampling. */
-#define VOICE_HAS_HRTF     (1u<<3)
-#define VOICE_HAS_NFC      (1u<<4)
-
-struct ALvoice {
-    enum State {
-        Stopped = 0,
-        Playing = 1,
-        Stopping = 2
-    };
-
-    std::atomic<ALvoiceProps*> mUpdate{nullptr};
-
-    std::atomic<ALuint> mSourceID{0u};
-    std::atomic<State> mPlayState{Stopped};
-
-    ALvoicePropsBase mProps;
-
-    /**
-     * Source offset in samples, relative to the currently playing buffer, NOT
-     * the whole queue.
-     */
-    std::atomic<ALuint> mPosition;
-    /** Fractional (fixed-point) offset to the next sample. */
-    std::atomic<ALuint> mPositionFrac;
-
-    /* Current buffer queue item being played. */
-    std::atomic<ALbufferlistitem*> mCurrentBuffer;
-
-    /* Buffer queue item to loop to at end of queue (will be NULL for non-
-     * looping voices).
-     */
-    std::atomic<ALbufferlistitem*> mLoopBuffer;
-
-    /* Properties for the attached buffer(s). */
-    FmtChannels mFmtChannels;
-    ALuint mFrequency;
-    ALuint mNumChannels;
-    ALuint mSampleSize;
-
-    /** Current target parameters used for mixing. */
-    ALuint mStep;
-
-    ResamplerFunc mResampler;
-
-    InterpState mResampleState;
-
-    ALuint mFlags;
-
-    struct TargetData {
-        int FilterType;
-        al::span<FloatBufferLine> Buffer;
-    };
-    TargetData mDirect;
-    std::array<TargetData,MAX_SENDS> mSend;
-
-    struct ChannelData {
-        alignas(16) std::array<float,MAX_RESAMPLER_PADDING> mPrevSamples;
-
-        float mAmbiScale;
-        BandSplitter mAmbiSplitter;
-
-        DirectParams mDryParams;
-        std::array<SendParams,MAX_SENDS> mWetParams;
-    };
-    std::array<ChannelData,MAX_INPUT_CHANNELS> mChans;
-
-    ALvoice() = default;
-    ALvoice(const ALvoice&) = delete;
-    ALvoice(ALvoice&& rhs) noexcept { *this = std::move(rhs); }
-    ~ALvoice() { delete mUpdate.exchange(nullptr, std::memory_order_acq_rel); }
-    ALvoice& operator=(const ALvoice&) = delete;
-    ALvoice& operator=(ALvoice&& rhs) noexcept
-    {
-        ALvoiceProps *old_update{mUpdate.load(std::memory_order_relaxed)};
-        mUpdate.store(rhs.mUpdate.exchange(old_update, std::memory_order_relaxed),
-            std::memory_order_relaxed);
-
-        mSourceID.store(rhs.mSourceID.load(std::memory_order_relaxed), std::memory_order_relaxed);
-        mPlayState.store(rhs.mPlayState.load(std::memory_order_relaxed),
-            std::memory_order_relaxed);
-
-        mProps = rhs.mProps;
-
-        mPosition.store(rhs.mPosition.load(std::memory_order_relaxed), std::memory_order_relaxed);
-        mPositionFrac.store(rhs.mPositionFrac.load(std::memory_order_relaxed),
-            std::memory_order_relaxed);
-
-        mCurrentBuffer.store(rhs.mCurrentBuffer.load(std::memory_order_relaxed),
-            std::memory_order_relaxed);
-        mLoopBuffer.store(rhs.mLoopBuffer.load(std::memory_order_relaxed),
-            std::memory_order_relaxed);
-
-        mFmtChannels = rhs.mFmtChannels;
-        mFrequency = rhs.mFrequency;
-        mNumChannels = rhs.mNumChannels;
-        mSampleSize = rhs.mSampleSize;
-
-        mStep = rhs.mStep;
-        mResampler = rhs.mResampler;
-
-        mResampleState = rhs.mResampleState;
-
-        mFlags = rhs.mFlags;
-
-        mDirect = rhs.mDirect;
-        mSend = rhs.mSend;
-        mChans = rhs.mChans;
-
-        return *this;
-    }
-
-    void mix(const State vstate, ALCcontext *Context, const ALuint SamplesToDo);
-};
-
-#endif /* VOICE_H */
diff --git a/alsoftrc.sample b/alsoftrc.sample
index de3ab6f3..2906cca4 100644
--- a/alsoftrc.sample
+++ b/alsoftrc.sample
@@ -14,10 +14,17 @@
 # block, while ALSA options would be in the [alsa/Name of Device] block.
 # Options marked as "(global)" are not influenced by the device.
 #
-# The system-wide settings can be put in /etc/openal/alsoft.conf and user-
-# specific override settings in $HOME/.alsoftrc.
+# The system-wide settings can be put in /etc/xdg/alsoft.conf (as determined by
+# the XDG_CONFIG_DIRS env var list, /etc/xdg being the default if unset) and
+# user-specific override settings in $HOME/.config/alsoft.conf (as determined
+# by the XDG_CONFIG_HOME env var).
+#
 # For Windows, these settings should go into $AppData\alsoft.ini
 #
+# An additional configuration file (alsoft.ini on Windows, alsoft.conf on other
+# OSs) can be placed alongside the process executable for app-specific config
+# settings.
+#
 # Option and block names are case-senstive. The supplied values are only hints
 # and may not be honored (though generally it'll try to get as close as
 # possible). Note: options that are left unset may default to app- or system-
@@ -46,17 +53,19 @@
 #drivers =
 
 ## channels:
-#  Sets the output channel configuration. If left unspecified, one will try to
-#  be detected from the system, and defaulting to stereo. The available values
-#  are: mono, stereo, quad, surround51, surround51rear, surround61, surround71,
-#  ambi1, ambi2, ambi3. Note that the ambi* configurations provide ambisonic
-#  channels of the given order (using ACN ordering and SN3D normalization by
-#  default), which need to be decoded to play correctly on speakers.
+#  Sets the default output channel configuration. If left unspecified, one will
+#  try to be detected from the system, with a fallback to stereo. The available
+#  values are: mono, stereo, quad, surround51, surround61, surround71,
+#  surround3d71, ambi1, ambi2, ambi3. Note that the ambi* configurations output
+#  ambisonic channels of the given order (using ACN ordering and SN3D
+#  normalization by default), which need to be decoded to play correctly on
+#  speakers.
 #channels =
 
 ## sample-type:
-#  Sets the output sample type. Currently, all mixing is done with 32-bit float
-#  and converted to the output sample type as needed. Available values are:
+#  Sets the default output sample type. Currently, all mixing is done with
+#  32-bit float and converted to the output sample type as needed. Available
+#  values are:
 #  int8    - signed 8-bit int
 #  uint8   - unsigned 8-bit int
 #  int16   - signed 16-bit int
@@ -67,8 +76,8 @@
 #sample-type = float32
 
 ## frequency:
-#  Sets the output frequency. If left unspecified it will try to detect a
-#  default from the system, otherwise it will default to 44100.
+#  Sets the default output frequency. If left unspecified it will try to detect
+#  a default from the system, otherwise it will fallback to 48000.
 #frequency =
 
 ## period_size:
@@ -92,27 +101,26 @@
 #stereo-mode = auto
 
 ## stereo-encoding:
-#  Specifies the encoding method for non-HRTF stereo output. 'panpot' (default)
-#  uses standard amplitude panning (aka pair-wise, stereo pair, etc) between
-#  -30 and +30 degrees, while 'uhj' creates stereo-compatible two-channel UHJ
-#  output, which encodes some surround sound information into stereo output
-#  that can be decoded with a surround sound receiver. If crossfeed filters are
-#  used, UHJ is disabled.
-#stereo-encoding = panpot
+#  Specifies the default encoding method for stereo output. Valid values are:
+#  basic - Standard amplitude panning (aka pair-wise, stereo pair, etc) between
+#          -30 and +30 degrees.
+#  uhj - Creates a stereo-compatible two-channel UHJ mix, which encodes some
+#        surround sound information into stereo output that can be decoded with
+#        a surround sound receiver.
+#  hrtf - Uses filters to provide better spatialization of sounds while using
+#         stereo headphones.
+#  If crossfeed filters are used, basic stereo mixing is used.
+#stereo-encoding = basic
 
 ## ambi-format:
 #  Specifies the channel order and normalization for the "ambi*" set of channel
-#  configurations. Valid settings are: fuma, ambix (or acn+sn3d), acn+n3d
+#  configurations. Valid settings are: fuma, acn+fuma, ambix (or acn+sn3d), or
+#  acn+n3d
 #ambi-format = ambix
 
 ## hrtf:
-#  Controls HRTF processing. These filters provide better spatialization of
-#  sounds while using headphones, but do require a bit more CPU power. The
-#  default filters will only work with 44100hz or 48000hz stereo output. While
-#  HRTF is used, the cf_level option is ignored. Setting this to auto (default)
-#  will allow HRTF to be used when headphones are detected or the app requests
-#  it, while setting true or false will forcefully enable or disable HRTF
-#  respectively.
+#  Deprecated. Consider using stereo-encoding instead. Valid values are auto,
+#  off, and on.
 #hrtf = auto
 
 ## hrtf-mode:
@@ -128,6 +136,13 @@
 #  usage (still less than "full", given some number of active sources).
 #hrtf-mode = full
 
+## hrtf-size:
+#  Specifies the impulse response size, in samples, for the HRTF filter. Larger
+#  values increase the filter quality, while smaller values reduce processing
+#  cost. A value of 0 (default) uses the full filter size in the dataset, and
+#  the default dataset has a filter size of 64 samples at 48khz.
+#hrtf-size = 0
+
 ## default-hrtf:
 #  Specifies the default HRTF to use. When multiple HRTFs are available, this
 #  determines the preferred one to use if none are specifically requested. Note
@@ -173,16 +188,21 @@
 #            between 24 and 48 points, with anti-aliasing)
 #  fast_bsinc24 - same as bsinc24, except without interpolation between down-
 #                 sampling scales
-#resampler = linear
+#resampler = cubic
 
 ## rt-prio: (global)
-#  Sets real-time priority for the mixing thread. Not all drivers may use this
-#  (eg. PortAudio) as they already control the priority of the mixing thread.
-#  0 and negative values will disable it. Note that this may constitute a
-#  security risk since a real-time priority thread can indefinitely block
-#  normal-priority threads if it fails to wait. As such, the default is
-#  disabled.
-#rt-prio = 0
+#  Sets the real-time priority value for the mixing thread. Not all drivers may
+#  use this (eg. PortAudio) as those APIs already control the priority of the
+#  mixing thread. 0 and negative values will disable real-time priority. Note
+#  that this may constitute a security risk since a real-time priority thread
+#  can indefinitely block normal-priority threads if it fails to wait. Disable
+#  this if it turns out to be a problem.
+#rt-prio = 1
+
+## rt-time-limit: (global)
+#  On non-Windows systems, allows reducing the process's RLIMIT_RTTIME resource
+#  as necessary for acquiring real-time priority from RTKit.
+#rt-time-limit = true
 
 ## sources:
 #  Sets the maximum number of allocatable sources. Lower values may help for
@@ -199,7 +219,7 @@
 ## sends:
 #  Limits the number of auxiliary sends allowed per source. Setting this higher
 #  than the default has no effect.
-#sends = 16
+#sends = 6
 
 ## front-stablizer:
 #  Applies filters to "stablize" front sound imaging. A psychoacoustic method
@@ -246,9 +266,9 @@
 ## default-reverb: (global)
 #  A reverb preset that applies by default to all sources on send 0
 #  (applications that set their own slots on send 0 will override this).
-#  Available presets are: None, Generic, PaddedCell, Room, Bathroom,
+#  Available presets include: None, Generic, PaddedCell, Room, Bathroom,
 #  Livingroom, Stoneroom, Auditorium, ConcertHall, Cave, Arena, Hangar,
-#  CarpetedHallway, Hallway, StoneCorridor, Alley, Forest, City, Moutains,
+#  CarpetedHallway, Hallway, StoneCorridor, Alley, Forest, City, Mountains,
 #  Quarry, Plain, ParkingLot, SewerPipe, Underwater, Drugged, Dizzy, Psychotic.
 #default-reverb =
 
@@ -272,10 +292,7 @@
 ## hq-mode:
 #  Enables a high-quality ambisonic decoder. This mode is capable of frequency-
 #  dependent processing, creating a better reproduction of 3D sound rendering
-#  over surround sound speakers. Enabling this also requires specifying decoder
-#  configuration files for the appropriate speaker configuration you intend to
-#  use (see the quad, surround51, etc options below). Currently, up to third-
-#  order decoding is supported.
+#  over surround sound speakers.
 #hq-mode = true
 
 ## distance-comp:
@@ -289,22 +306,22 @@
 ## nfc:
 #  Enables near-field control filters. This simulates and compensates for low-
 #  frequency effects caused by the curvature of nearby sound-waves, which
-#  creates a more realistic perception of sound distance. Note that the effect
-#  may be stronger or weaker than intended if the application doesn't use or
-#  specify an appropriate unit scale, or if incorrect speaker distances are set
-#  in the decoder configuration file.
+#  creates a more realistic perception of sound distance with surround sound
+#  output. Note that the effect may be stronger or weaker than intended if the
+#  application doesn't use or specify an appropriate unit scale, or if
+#  incorrect speaker distances are set. For HRTF output, hrtf-mode must be set
+#  to one of the ambi* values for this to function.
 #nfc = false
 
-## nfc-ref-delay
-#  Specifies the reference delay value for ambisonic output when NFC filters
-#  are enabled. If channels is set to one of the ambi* formats, this option
-#  enables NFC-HOA output with the specified Reference Delay parameter. The
-#  specified value can then be shared with an appropriate NFC-HOA decoder to
-#  reproduce correct near-field effects. Keep in mind that despite being
-#  designed for higher-order ambisonics, this also applies to first-order
-#  output. When left unset, normal output is created with no near-field
-#  simulation. Requires the nfc option to also be enabled.
-#nfc-ref-delay =
+## speaker-dist:
+#  Specifies the speaker distance in meters, used by the near-field control
+#  filters with surround sound output. For ambisonic output modes, this value
+#  is the basis for the NFC-HOA Reference Delay parameter (calculated as
+#  delay_seconds = speaker_dist/343.3). This value is not used when a decoder
+#  configuration is set for the output mode (since they specify the per-speaker
+#  distances, overriding this setting), or when the NFC filters are off. Valid
+#  values range from 0.1 to 10.
+#speaker-dist = 1
 
 ## quad:
 #  Decoder configuration file for Quadraphonic channel output. See
@@ -323,11 +340,36 @@
 
 ## surround71:
 #  Decoder configuration file for 7.1 Surround channel output. See
-#  docs/ambdec.txt for a description of the file format. Note: This can be used
-#  to enable 3D7.1 with the appropriate configuration and speaker placement,
-#  see docs/3D7.1.txt.
+#  docs/ambdec.txt for a description of the file format.
 #surround71 =
 
+## surround3d71:
+#  Decoder configuration file for 3D7.1 Surround channel output. See
+#  docs/ambdec.txt for a description of the file format. See also
+#  docs/3D7.1.txt for information about 3D7.1.
+#surround3d71 =
+
+##
+## UHJ and Super Stereo stuff
+##
+[uhj]
+
+## decode-filter: (global)
+#  Specifies the all-pass filter type for UHJ decoding and Super Stereo
+#  processing. Valid values are:
+#  iir - utilizes dual IIR filters, providing a wide pass-band with low CPU
+#        use, but causes additional phase shifts on the signal.
+#  fir256 - utilizes a 256-point FIR filter, providing more stable results but
+#           exhibiting attenuation in the lower and higher frequency bands.
+#  fir512 - utilizes a 512-point FIR filter, providing a wider pass-band than
+#           fir256, at the cost of more CPU use.
+#decode-filter = iir
+
+## encode-filter: (global)
+#  Specifies the all-pass filter type for UHJ output encoding. Valid values are
+#  the same as for decode-filter.
+#encode-filter = iir
+
 ##
 ## Reverb effect stuff (includes EAX reverb)
 ##
@@ -341,6 +383,27 @@
 #boost = 0
 
 ##
+## PipeWire backend stuff
+##
+[pipewire]
+
+## assume-audio: (global)
+#  Causes the backend to succeed initialization even if PipeWire reports no
+#  audio support. Currently, audio support is detected by the presence of audio
+#  source or sink nodes, although this can cause false negatives in cases where
+#  device availability during library initialization is spotty. Future versions
+#  of PipeWire are expected to have a more robust method to test audio support,
+#  but in the mean time this can be set to true to assume PipeWire has audio
+#  support even when no nodes may be reported at initialization time.
+#assume-audio = false
+
+## rt-mix:
+#  Renders samples directly in the real-time processing callback. This allows
+#  for lower latency and less overall CPU utilization, but can increase the
+#  risk of underruns when increasing the amount of work the mixer needs to do.
+#rt-mix = true
+
+##
 ## PulseAudio backend stuff
 ##
 [pulse]
@@ -349,7 +412,7 @@
 #  Attempts to autospawn a PulseAudio server whenever needed (initializing the
 #  backend, enumerating devices, etc). Setting autospawn to false in Pulse's
 #  client.conf will still prevent autospawning even if this is set to true.
-#spawn-server = true
+#spawn-server = false
 
 ## allow-moves: (global)
 #  Allows PulseAudio to move active streams to different devices. Note that the
@@ -395,6 +458,13 @@
 #  case-sensitive.
 #device-prefix- =
 
+## custom-devices: (global)
+#  Specifies a list of enumerated playback devices and the ALSA devices they
+#  refer to. The list pattern is "Display Name=ALSA device;...". The display
+#  names will be returned for device enumeration, and the ALSA device is the
+#  device name to open for each enumerated device.
+#custom-devices =
+
 ## capture: (global)
 #  Sets the device name for the default capture device.
 #capture = default
@@ -412,6 +482,13 @@
 #  capture-prefix-NVidia-0). The card id is case-sensitive.
 #capture-prefix- =
 
+## custom-captures: (global)
+#  Specifies a list of enumerated capture devices and the ALSA devices they
+#  refer to. The list pattern is "Display Name=ALSA device;...". The display
+#  names will be returned for device enumeration, and the ALSA device is the
+#  device name to open for each enumerated device.
+#custom-captures =
+
 ## mmap:
 #  Sets whether to try using mmap mode (helps reduce latencies and CPU
 #  consumption). If mmap isn't available, it will automatically fall back to
@@ -459,10 +536,29 @@
 [jack]
 
 ## spawn-server: (global)
-#  Attempts to autospawn a JACK server whenever needed (initializing the
-#  backend, opening devices, etc).
+#  Attempts to autospawn a JACK server when initializing.
 #spawn-server = false
 
+## custom-devices: (global)
+#  Specifies a list of enumerated devices and the ports they connect to. The
+#  list pattern is "Display Name=ports regex;Display Name=ports regex;...". The
+#  display names will be returned for device enumeration, and the ports regex
+#  is the regular expression to identify the target ports on the server (as
+#  given by the jack_get_ports function) for each enumerated device.
+#custom-devices =
+
+## rt-mix:
+#  Renders samples directly in the real-time processing callback. This allows
+#  for lower latency and less overall CPU utilization, but can increase the
+#  risk of underruns when increasing the amount of work the mixer needs to do.
+#rt-mix = true
+
+## connect-ports:
+#  Attempts to automatically connect the client ports to physical server ports.
+#  Client ports that fail to connect will leave the remaining channels
+#  unconnected and silent (the device format won't change to accommodate).
+#connect-ports = true
+
 ## buffer-size:
 #  Sets the update buffer size, in samples, that the backend will keep buffered
 #  to handle the server's real-time processing requests. This value must be a
@@ -470,6 +566,7 @@
 #  less than JACK's buffer update size, it will be clamped. This option may
 #  be useful in case the server's update size is too small and doesn't give the
 #  mixer time to keep enough audio available for the processing requests.
+#  Ignored when rt-mix is true.
 #buffer-size = 0
 
 ##
@@ -477,6 +574,14 @@
 ##
 [wasapi]
 
+## allow-resampler:
+#  Specifies whether to allow an extra resampler pass on the output. Enabling
+#  this will allow the playback device to be set to a different sample rate
+#  than the actual output can accept, causing the backend to apply its own
+#  resampling pass after OpenAL Soft mixes the sources and processes effects
+#  for output.
+#allow-resampler = true
+
 ##
 ## DirectSound backend stuff
 ##
@@ -517,3 +622,45 @@
 #  Creates AMB format files using first-order ambisonics instead of a standard
 #  single- or multi-channel .wav file.
 #bformat = false
+
+##
+## EAX extensions stuff
+##
+[eax]
+
+## enable: (global)
+#  Sets whether to enable EAX extensions or not.
+#enable = true
+
+##
+## Per-game compatibility options (these should only be set in per-game config
+## files, *NOT* system- or user-level!)
+##
+[game_compat]
+
+## nfc-scale: (global)
+#  A meters-per-unit distance scale applied to NFC filters. If a game doesn't
+#  use real-world meters for in-game units, the filters may create a too-near
+#  or too-distant effect. For instance, if the game uses 1 foot per unit, a
+#  value of 0.3048 will correctly adjust the filters. Or if the game uses 1
+#  kilometer per unit, a value of 1000 will correctly adjust the filters.
+#nfc-scale = 1
+
+## enable-sub-data-ext: (global)
+#  Enables the AL_SOFT_buffer_sub_data extension, disabling the
+#  AL_EXT_SOURCE_RADIUS extension. These extensions are incompatible, so only
+#  one can be available. The latter extension is more commonly used, but this
+#  option can be enabled for older apps that want the former extension.
+#enable-sub-data-ext = false
+
+## reverse-x: (global)
+#  Reverses the local X (left-right) position of 3D sound sources.
+#reverse-x = false
+
+## reverse-y: (global)
+#  Reverses the local Y (up-down) position of 3D sound sources.
+#reverse-y = false
+
+## reverse-z: (global)
+#  Reverses the local Z (front-back) position of 3D sound sources.
+#reverse-z = false
diff --git a/appveyor.yml b/appveyor.yml
index 81080828..aa155af4 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,27 +1,21 @@
-version: 1.20.0.{build}
+version: 1.23.1.{build}
 
 environment:
+    APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    GEN: "Visual Studio 15 2017"
     matrix:
-      - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-        GEN: "Visual Studio 14 2015"
-        ARCH: Win32
+      - ARCH: Win32
         CFG: Release
-      - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-        GEN: "Visual Studio 14 2015"
-        ARCH: x64
-        CFG: Release
-      - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-        GEN: "Visual Studio 15 2017"
-        ARCH: x64
+      - ARCH: x64
         CFG: Release
 
-install:
-    # Remove the VS Xamarin targets to reduce AppVeyor specific noise in build
-    # logs.  See also http://help.appveyor.com/discussions/problems/4569
-    - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
+after_build:
+- 7z a ..\soft_oal.zip "%APPVEYOR_BUILD_FOLDER%\build\%CFG%\soft_oal.dll" "%APPVEYOR_BUILD_FOLDER%\README.md" "%APPVEYOR_BUILD_FOLDER%\COPYING"
+
+artifacts:
+- path: soft_oal.zip
 
 build_script:
     - cd build
     - cmake -G "%GEN%" -A %ARCH% -DALSOFT_BUILD_ROUTER=ON -DALSOFT_REQUIRE_WINMM=ON -DALSOFT_REQUIRE_DSOUND=ON -DALSOFT_REQUIRE_WASAPI=ON -DALSOFT_EMBED_HRTF_DATA=YES ..
     - cmake --build . --config %CFG% --clean-first
-
diff --git a/cmake/FindDSound.cmake b/cmake/FindDSound.cmake
deleted file mode 100644
index 4078deb5..00000000
--- a/cmake/FindDSound.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# - Find DirectSound includes and libraries
-#
-#   DSOUND_FOUND        - True if DSOUND_INCLUDE_DIR & DSOUND_LIBRARY are found
-#   DSOUND_LIBRARIES    - Set when DSOUND_LIBRARY is found
-#   DSOUND_INCLUDE_DIRS - Set when DSOUND_INCLUDE_DIR is found
-#
-#   DSOUND_INCLUDE_DIR - where to find dsound.h, etc.
-#   DSOUND_LIBRARY     - the dsound library
-#
-
-if (WIN32)
-  include(FindWindowsSDK)
-  if (WINDOWSSDK_FOUND)
-    get_windowssdk_library_dirs(${WINDOWSSDK_PREFERRED_DIR} WINSDK_LIB_DIRS)
-    get_windowssdk_include_dirs(${WINDOWSSDK_PREFERRED_DIR} WINSDK_INCLUDE_DIRS)
-  endif()
-endif()
-
-# DSOUND_INCLUDE_DIR
-find_path(DSOUND_INCLUDE_DIR
-          NAMES "dsound.h" 
-          PATHS "${DXSDK_DIR}" ${WINSDK_INCLUDE_DIRS} 
-          PATH_SUFFIXES include
-          DOC "The DirectSound include directory")
-
-# DSOUND_LIBRARY
-find_library(DSOUND_LIBRARY
-             NAMES dsound
-             PATHS "${DXSDK_DIR}" ${WINSDK_LIB_DIRS}
-             PATH_SUFFIXES lib lib/x86 lib/x64
-             DOC "The DirectSound library")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(DSound REQUIRED_VARS DSOUND_LIBRARY DSOUND_INCLUDE_DIR)
-
-if(DSOUND_FOUND)
-    set(DSOUND_LIBRARIES ${DSOUND_LIBRARY})
-    set(DSOUND_INCLUDE_DIRS ${DSOUND_INCLUDE_DIR})
-endif()
-
-mark_as_advanced(DSOUND_INCLUDE_DIR DSOUND_LIBRARY)
diff --git a/cmake/FindFFmpeg.cmake b/cmake/FindFFmpeg.cmake
index c489c2c3..26ed4d2f 100644
--- a/cmake/FindFFmpeg.cmake
+++ b/cmake/FindFFmpeg.cmake
@@ -80,30 +80,8 @@ macro(find_component _component _pkgconfig _library _header)
             ${PC_LIB${_component}_LIBRARY_DIRS}
     )
 
-    STRING(REGEX REPLACE "/.*" "/version.h" _ver_header ${_header})
-    if(EXISTS "${${_component}_INCLUDE_DIRS}/${_ver_header}")
-        file(STRINGS "${${_component}_INCLUDE_DIRS}/${_ver_header}" version_str REGEX "^#define[\t ]+LIB${_component}_VERSION_M.*")
-
-        foreach(_str "${version_str}")
-            if(NOT version_maj)
-                string(REGEX REPLACE "^.*LIB${_component}_VERSION_MAJOR[\t ]+([0-9]*).*$" "\\1" version_maj "${_str}")
-            endif()
-            if(NOT version_min)
-                string(REGEX REPLACE "^.*LIB${_component}_VERSION_MINOR[\t ]+([0-9]*).*$" "\\1" version_min "${_str}")
-            endif()
-            if(NOT version_mic)
-                string(REGEX REPLACE "^.*LIB${_component}_VERSION_MICRO[\t ]+([0-9]*).*$" "\\1" version_mic "${_str}")
-            endif()
-        endforeach()
-        unset(version_str)
-
-        set(${_component}_VERSION "${version_maj}.${version_min}.${version_mic}" CACHE STRING "The ${_component} version number.")
-        unset(version_maj)
-        unset(version_min)
-        unset(version_mic)
-    endif(EXISTS "${${_component}_INCLUDE_DIRS}/${_ver_header}")
-    set(${_component}_VERSION     ${PC_${_component}_VERSION}      CACHE STRING "The ${_component} version number.")
-    set(${_component}_DEFINITIONS ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS.")
+    set(${_component}_VERSION     ${PC_${_component}_VERSION}      CACHE STRING "The ${_component} version number." FORCE)
+    set(${_component}_DEFINITIONS ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS." FORCE)
 
     set_component_found(${_component})
 
diff --git a/cmake/FindMySOFA.cmake b/cmake/FindMySOFA.cmake
index a1d57446..7d485c35 100644
--- a/cmake/FindMySOFA.cmake
+++ b/cmake/FindMySOFA.cmake
@@ -56,7 +56,7 @@ find_library(MYSOFA_M_LIBRARY NAMES m
 # handle the QUIETLY and REQUIRED arguments and set MYSOFA_FOUND to TRUE if
 # all listed variables are TRUE
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(MYSOFA REQUIRED_VARS MYSOFA_LIBRARY MYSOFA_INCLUDE_DIR ZLIB_FOUND)
+find_package_handle_standard_args(MySOFA REQUIRED_VARS MYSOFA_LIBRARY MYSOFA_INCLUDE_DIR ZLIB_FOUND)
 
 if(MYSOFA_FOUND)
     set(MYSOFA_INCLUDE_DIRS ${MYSOFA_INCLUDE_DIR})
diff --git a/cmake/FindOboe.cmake b/cmake/FindOboe.cmake
new file mode 100644
index 00000000..bf12c12c
--- /dev/null
+++ b/cmake/FindOboe.cmake
@@ -0,0 +1,31 @@
+# - Find Oboe
+# Find the Oboe library
+#
+# This module defines the following variable:
+#   OBOE_FOUND - True if Oboe was found
+#
+# This module defines the following target:
+#   oboe::oboe - Import target for linking Oboe to a project
+#
+
+find_path(OBOE_INCLUDE_DIR NAMES oboe/Oboe.h
+    DOC "The Oboe include directory"
+)
+
+find_library(OBOE_LIBRARY NAMES oboe
+    DOC "The Oboe library"
+)
+
+# handle the QUIETLY and REQUIRED arguments and set OBOE_FOUND to TRUE if
+# all listed variables are TRUE
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Oboe REQUIRED_VARS OBOE_LIBRARY OBOE_INCLUDE_DIR)
+
+if(OBOE_FOUND)
+    add_library(oboe::oboe UNKNOWN IMPORTED)
+    set_target_properties(oboe::oboe PROPERTIES
+        IMPORTED_LOCATION ${OBOE_LIBRARY}
+        INTERFACE_INCLUDE_DIRECTORIES ${OBOE_INCLUDE_DIR})
+endif()
+
+mark_as_advanced(OBOE_INCLUDE_DIR OBOE_LIBRARY)
diff --git a/cmake/FindOpenSL.cmake b/cmake/FindOpenSL.cmake
index 41c68fde..00428749 100644
--- a/cmake/FindOpenSL.cmake
+++ b/cmake/FindOpenSL.cmake
@@ -1,10 +1,9 @@
 # - Find OpenSL
 # Find the OpenSL libraries
 #
-#  This module defines the following variables:
-#     OPENSL_FOUND        - True if OPENSL_INCLUDE_DIR & OPENSL_LIBRARY are set
-#     OPENSL_INCLUDE_DIRS - where to find SLES/OpenSLES.h, etc.
-#     OPENSL_LIBRARIES    - the OpenSL library
+#  This module defines the following variables and targets:
+#     OPENSL_FOUND     - True if OPENSL was found
+#     OpenSL::OpenSLES - The OpenSLES target
 #
 
 #=============================================================================
@@ -40,25 +39,25 @@
 #=============================================================================
 
 find_path(OPENSL_INCLUDE_DIR NAMES SLES/OpenSLES.h
-          DOC "The OpenSL include directory"
-)
+    DOC "The OpenSL include directory")
 find_path(OPENSL_ANDROID_INCLUDE_DIR NAMES SLES/OpenSLES_Android.h
-          DOC "The OpenSL Android include directory"
-)
+    DOC "The OpenSL Android include directory")
 
 find_library(OPENSL_LIBRARY NAMES OpenSLES
-             DOC "The OpenSL library"
-)
+    DOC "The OpenSL library")
 
 # handle the QUIETLY and REQUIRED arguments and set OPENSL_FOUND to TRUE if
 # all listed variables are TRUE
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(OPENSL REQUIRED_VARS OPENSL_LIBRARY OPENSL_INCLUDE_DIR
+find_package_handle_standard_args(OpenSL REQUIRED_VARS OPENSL_LIBRARY OPENSL_INCLUDE_DIR
     OPENSL_ANDROID_INCLUDE_DIR)
 
 if(OPENSL_FOUND)
-    set(OPENSL_LIBRARIES ${OPENSL_LIBRARY})
-    set(OPENSL_INCLUDE_DIRS ${OPENSL_INCLUDE_DIR} ${OPENSL_ANDROID_INCLUDE_DIR})
+    add_library(OpenSL::OpenSLES UNKNOWN IMPORTED)
+    set_target_properties(OpenSL::OpenSLES PROPERTIES
+        IMPORTED_LOCATION ${OPENSL_LIBRARY}
+        INTERFACE_INCLUDE_DIRECTORIES ${OPENSL_INCLUDE_DIR}
+        INTERFACE_INCLUDE_DIRECTORIES ${OPENSL_ANDROID_INCLUDE_DIR})
 endif()
 
 mark_as_advanced(OPENSL_INCLUDE_DIR OPENSL_ANDROID_INCLUDE_DIR OPENSL_LIBRARY)
diff --git a/cmake/FindPulseAudio.cmake b/cmake/FindPulseAudio.cmake
index 1f6f843a..fdcbc20f 100644
--- a/cmake/FindPulseAudio.cmake
+++ b/cmake/FindPulseAudio.cmake
@@ -2,8 +2,6 @@
 #
 #   PULSEAUDIO_FOUND        - True if PULSEAUDIO_INCLUDE_DIR &
 #                             PULSEAUDIO_LIBRARY are found
-#   PULSEAUDIO_LIBRARIES    - Set when PULSEAUDIO_LIBRARY is found
-#   PULSEAUDIO_INCLUDE_DIRS - Set when PULSEAUDIO_INCLUDE_DIR is found
 #
 #   PULSEAUDIO_INCLUDE_DIR - where to find pulse/pulseaudio.h, etc.
 #   PULSEAUDIO_LIBRARY     - the pulse library
@@ -34,10 +32,3 @@ find_package_handle_standard_args(PulseAudio
     REQUIRED_VARS PULSEAUDIO_LIBRARY PULSEAUDIO_INCLUDE_DIR
     VERSION_VAR PULSEAUDIO_VERSION_STRING
 )
-
-if(PULSEAUDIO_FOUND)
-    set(PULSEAUDIO_LIBRARIES ${PULSEAUDIO_LIBRARY})
-    set(PULSEAUDIO_INCLUDE_DIRS ${PULSEAUDIO_INCLUDE_DIR})
-endif()
-
-mark_as_advanced(PULSEAUDIO_INCLUDE_DIR PULSEAUDIO_LIBRARY)
diff --git a/cmake/FindQSA.cmake b/cmake/FindQSA.cmake
deleted file mode 100644
index 0ad1fd43..00000000
--- a/cmake/FindQSA.cmake
+++ /dev/null
@@ -1,34 +0,0 @@
-# - Find QSA includes and libraries
-#
-#   QSA_FOUND        - True if QSA_INCLUDE_DIR & QSA_LIBRARY are found
-#   QSA_LIBRARIES    - Set when QSA_LIBRARY is found
-#   QSA_INCLUDE_DIRS - Set when QSA_INCLUDE_DIR is found
-#
-#   QSA_INCLUDE_DIR - where to find sys/asoundlib.h, etc.
-#   QSA_LIBRARY     - the asound library
-#
-
-# Only check for QSA on QNX, because it conflicts with ALSA.
-if("${CMAKE_C_PLATFORM_ID}" STREQUAL "QNX")
-    find_path(QSA_INCLUDE_DIR
-              NAMES sys/asoundlib.h
-              DOC "The QSA include directory"
-    )
-
-    find_library(QSA_LIBRARY
-                 NAMES asound
-                 DOC "The QSA library"
-    )
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(QSA
-    REQUIRED_VARS QSA_LIBRARY QSA_INCLUDE_DIR
-)
-
-if(QSA_FOUND)
-    set(QSA_LIBRARIES ${QSA_LIBRARY})
-    set(QSA_INCLUDE_DIRS ${QSA_INCLUDE_DIR})
-endif()
-
-mark_as_advanced(QSA_INCLUDE_DIR QSA_LIBRARY)
diff --git a/cmake/FindSDL2.cmake b/cmake/FindSDL2.cmake
deleted file mode 100644
index e808d006..00000000
--- a/cmake/FindSDL2.cmake
+++ /dev/null
@@ -1,191 +0,0 @@
-# Locate SDL2 library
-# This module defines
-# SDL2_LIBRARY, the name of the library to link against
-# SDL2_FOUND, if false, do not try to link to SDL2
-# SDL2_INCLUDE_DIR, where to find SDL.h
-#
-# This module responds to the the flag:
-# SDL2_BUILDING_LIBRARY
-# If this is defined, then no SDL2_main will be linked in because
-# only applications need main().
-# Otherwise, it is assumed you are building an application and this
-# module will attempt to locate and set the the proper link flags
-# as part of the returned SDL2_LIBRARY variable.
-#
-# Don't forget to include SDL2main.h and SDL2main.m your project for the
-# OS X framework based version. (Other versions link to -lSDL2main which
-# this module will try to find on your behalf.) Also for OS X, this
-# module will automatically add the -framework Cocoa on your behalf.
-#
-#
-# Additional Note: If you see an empty SDL2_CORE_LIBRARY in your configuration
-# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
-# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
-# Set SDL2_CORE_LIBRARY to point to your SDL2 library, and configure again.
-# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
-# as appropriate. These values are used to generate the final SDL2_LIBRARY
-# variable, but when these values are unset, SDL2_LIBRARY does not get created.
-#
-#
-# $SDL2DIR is an environment variable that would
-# correspond to the ./configure --prefix=$SDL2DIR
-# used in building SDL2.
-# l.e.galup  9-20-02
-#
-# Modified by Eric Wing.
-# Added code to assist with automated building by using environmental variables
-# and providing a more controlled/consistent search behavior.
-# Added new modifications to recognize OS X frameworks and
-# additional Unix paths (FreeBSD, etc).
-# Also corrected the header search path to follow "proper" SDL2 guidelines.
-# Added a search for SDL2main which is needed by some platforms.
-# Added a search for threads which is needed by some platforms.
-# Added needed compile switches for MinGW.
-#
-# On OSX, this will prefer the Framework version (if found) over others.
-# People will have to manually change the cache values of
-# SDL2_LIBRARY to override this selection or set the CMake environment
-# CMAKE_INCLUDE_PATH to modify the search paths.
-#
-# Note that the header path has changed from SDL2/SDL.h to just SDL.h
-# This needed to change because "proper" SDL2 convention
-# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
-# reasons because not all systems place things in SDL2/ (see FreeBSD).
-#
-# Ported by Johnny Patterson. This is a literal port for SDL2 of the FindSDL.cmake
-# module with the minor edit of changing "SDL" to "SDL2" where necessary. This
-# was not created for redistribution, and exists temporarily pending official
-# SDL2 CMake modules.
-
-#=============================================================================
-# Copyright 2003-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-
-FIND_PATH(SDL2_INCLUDE_DIR SDL.h
-  HINTS
-  $ENV{SDL2DIR}
-  PATH_SUFFIXES include/SDL2 include
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local/include/SDL2
-  /usr/include/SDL2
-  /sw # Fink
-  /opt/local # DarwinPorts
-  /opt/csw # Blastwave
-  /opt
-)
-#MESSAGE("SDL2_INCLUDE_DIR is ${SDL2_INCLUDE_DIR}")
-
-FIND_LIBRARY(SDL2_CORE_LIBRARY
-  NAMES SDL2
-  HINTS
-  $ENV{SDL2DIR}
-  PATH_SUFFIXES lib64 lib
-  PATHS
-  /sw
-  /opt/local
-  /opt/csw
-  /opt
-)
-#MESSAGE("SDL2_CORE_LIBRARY is ${SDL2_CORE_LIBRARY}")
-
-IF(NOT SDL2_BUILDING_LIBRARY)
-  IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-    # Non-OS X framework versions expect you to also dynamically link to
-    # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
-    # seem to provide SDL2main for compatibility even though they don't
-    # necessarily need it.
-    FIND_LIBRARY(SDL2MAIN_LIBRARY
-      NAMES SDL2main
-      HINTS
-      $ENV{SDL2DIR}
-      PATH_SUFFIXES lib64 lib
-      PATHS
-      /sw
-      /opt/local
-      /opt/csw
-      /opt
-    )
-  ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-# SDL2 may require threads on your system.
-# The Apple build may not need an explicit flag because one of the
-# frameworks may already provide it.
-# But for non-OSX systems, I will use the CMake Threads package.
-IF(NOT APPLE)
-  FIND_PACKAGE(Threads)
-ENDIF(NOT APPLE)
-
-# MinGW needs an additional library, mwindows
-# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
-# (Actually on second look, I think it only needs one of the m* libraries.)
-IF(MINGW)
-  SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
-ENDIF(MINGW)
-
-SET(SDL2_FOUND "NO")
-IF(SDL2_CORE_LIBRARY)
-  SET(SDL2_LIBRARY_TEMP ${SDL2_CORE_LIBRARY})
-
-  # For SDL2main
-  IF(NOT SDL2_BUILDING_LIBRARY)
-    IF(SDL2MAIN_LIBRARY)
-      SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
-    ENDIF(SDL2MAIN_LIBRARY)
-  ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-  # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
-  # CMake doesn't display the -framework Cocoa string in the UI even
-  # though it actually is there if I modify a pre-used variable.
-  # I think it has something to do with the CACHE STRING.
-  # So I use a temporary variable until the end so I can set the
-  # "real" variable in one-shot.
-  IF(APPLE)
-    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
-  ENDIF(APPLE)
-
-  # For threads, as mentioned Apple doesn't need this.
-  # In fact, there seems to be a problem if I used the Threads package
-  # and try using this line, so I'm just skipping it entirely for OS X.
-  IF(NOT APPLE)
-    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
-  ENDIF(NOT APPLE)
-
-  # For MinGW library
-  IF(MINGW)
-    SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
-  ENDIF(MINGW)
-  
-  IF(WIN32)
-    SET(SDL2_LIBRARY_TEMP winmm imm32 version msimg32 ${SDL2_LIBRARY_TEMP})
-  ENDIF(WIN32)
-
-  # Set the final string here so the GUI reflects the final state.
-  SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP})
-
-  SET(SDL2_FOUND "YES")
-ENDIF(SDL2_CORE_LIBRARY)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
-                                  REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)
-
-IF(SDL2_STATIC)
-  if (UNIX AND NOT APPLE)
-    EXECUTE_PROCESS(COMMAND sdl2-config --static-libs OUTPUT_VARIABLE SDL2_LINK_FLAGS)
-    STRING(REGEX REPLACE "(\r?\n)+$" "" SDL2_LINK_FLAGS "${SDL2_LINK_FLAGS}")
-    SET(SDL2_LIBRARY ${SDL2_LINK_FLAGS})
-  ENDIF()
-ENDIF(SDL2_STATIC)
diff --git a/cmake/FindSDL_sound.cmake b/cmake/FindSDL_sound.cmake
deleted file mode 100644
index 5557b55b..00000000
--- a/cmake/FindSDL_sound.cmake
+++ /dev/null
@@ -1,429 +0,0 @@
-# - Locates the SDL_sound library
-#
-# This module depends on SDL being found and
-# must be called AFTER FindSDL.cmake or FindSDL2.cmake is called.
-#
-# This module defines
-#  SDL_SOUND_INCLUDE_DIR, where to find SDL_sound.h
-#  SDL_SOUND_FOUND, if false, do not try to link to SDL_sound
-#  SDL_SOUND_LIBRARIES, this contains the list of libraries that you need
-#    to link against. This is a read-only variable and is marked INTERNAL.
-#  SDL_SOUND_EXTRAS, this is an optional variable for you to add your own
-#    flags to SDL_SOUND_LIBRARIES. This is prepended to SDL_SOUND_LIBRARIES.
-#    This is available mostly for cases this module failed to anticipate for
-#    and you must add additional flags. This is marked as ADVANCED.
-#  SDL_SOUND_VERSION_STRING, human-readable string containing the version of SDL_sound
-#
-# This module also defines (but you shouldn't need to use directly)
-#   SDL_SOUND_LIBRARY, the name of just the SDL_sound library you would link
-#   against. Use SDL_SOUND_LIBRARIES for you link instructions and not this one.
-# And might define the following as needed
-#   MIKMOD_LIBRARY
-#   MODPLUG_LIBRARY
-#   OGG_LIBRARY
-#   VORBIS_LIBRARY
-#   SMPEG_LIBRARY
-#   FLAC_LIBRARY
-#   SPEEX_LIBRARY
-#
-# Typically, you should not use these variables directly, and you should use
-# SDL_SOUND_LIBRARIES which contains SDL_SOUND_LIBRARY and the other audio libraries
-# (if needed) to successfully compile on your system.
-#
-# Created by Eric Wing.
-# This module is a bit more complicated than the other FindSDL* family modules.
-# The reason is that SDL_sound can be compiled in a large variety of different ways
-# which are independent of platform. SDL_sound may dynamically link against other 3rd
-# party libraries to get additional codec support, such as Ogg Vorbis, SMPEG, ModPlug,
-# MikMod, FLAC, Speex, and potentially others.
-# Under some circumstances which I don't fully understand,
-# there seems to be a requirement
-# that dependent libraries of libraries you use must also be explicitly
-# linked against in order to successfully compile. SDL_sound does not currently
-# have any system in place to know how it was compiled.
-# So this CMake module does the hard work in trying to discover which 3rd party
-# libraries are required for building (if any).
-# This module uses a brute force approach to create a test program that uses SDL_sound,
-# and then tries to build it. If the build fails, it parses the error output for
-# known symbol names to figure out which libraries are needed.
-#
-# Responds to the $SDLDIR and $SDLSOUNDDIR environmental variable that would
-# correspond to the ./configure --prefix=$SDLDIR used in building SDL.
-#
-# On OSX, this will prefer the Framework version (if found) over others.
-# People will have to manually change the cache values of
-# SDL_LIBRARY or SDL2_LIBRARY to override this selection or set the CMake
-# environment CMAKE_INCLUDE_PATH to modify the search paths.
-
-#=============================================================================
-# Copyright 2005-2009 Kitware, Inc.
-# Copyright 2012 Benjamin Eikel
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-set(SDL_SOUND_EXTRAS "" CACHE STRING "SDL_sound extra flags")
-mark_as_advanced(SDL_SOUND_EXTRAS)
-
-# Find SDL_sound.h
-find_path(SDL_SOUND_INCLUDE_DIR SDL_sound.h
-    HINTS
-        ENV SDLSOUNDDIR
-        ENV SDLDIR
-    PATH_SUFFIXES SDL SDL12 SDL11
-)
-
-find_library(SDL_SOUND_LIBRARY
-    NAMES SDL_sound
-    HINTS
-        ENV SDLSOUNDDIR
-        ENV SDLDIR
-)
-
-if(SDL2_FOUND OR SDL_FOUND)
-    if(SDL_SOUND_INCLUDE_DIR AND SDL_SOUND_LIBRARY)
-        # CMake is giving me problems using TRY_COMPILE with the CMAKE_FLAGS
-        # for the :STRING syntax if I have multiple values contained in a
-        # single variable. This is a problem for the SDL2_LIBRARY variable
-        # because it does just that. When I feed this variable to the command,
-        # only the first value gets the appropriate modifier (e.g. -I) and
-        # the rest get dropped.
-        # To get multiple single variables to work, I must separate them with a "\;"
-        # I could go back and modify the FindSDL2.cmake module, but that's kind of painful.
-        # The solution would be to try something like:
-        # set(SDL2_TRY_COMPILE_LIBRARY_LIST "${SDL2_TRY_COMPILE_LIBRARY_LIST}\;${CMAKE_THREAD_LIBS_INIT}")
-        # Instead, it was suggested on the mailing list to write a temporary CMakeLists.txt
-        # with a temporary test project and invoke that with TRY_COMPILE.
-        # See message thread "Figuring out dependencies for a library in order to build"
-        # 2005-07-16
-        #     try_compile(
-        #             MY_RESULT
-        #             ${CMAKE_BINARY_DIR}
-        #             ${PROJECT_SOURCE_DIR}/DetermineSoundLibs.c
-        #             CMAKE_FLAGS
-        #                     -DINCLUDE_DIRECTORIES:STRING=${SDL2_INCLUDE_DIR}\;${SDL_SOUND_INCLUDE_DIR}
-        #                     -DLINK_LIBRARIES:STRING=${SDL_SOUND_LIBRARY}\;${SDL2_LIBRARY}
-        #             OUTPUT_VARIABLE MY_OUTPUT
-        #     )
-
-        # To minimize external dependencies, create a sdlsound test program
-        # which will be used to figure out if additional link dependencies are
-        # required for the link phase.
-        file(WRITE ${PROJECT_BINARY_DIR}/CMakeTmp/DetermineSoundLibs.c
-            "#include \"SDL_sound.h\"
-            #include \"SDL.h\"
-            int main(int argc, char* argv[])
-            {
-                Sound_AudioInfo desired;
-                Sound_Sample* sample;
-
-                SDL_Init(0);
-                Sound_Init();
-
-                /* This doesn't actually have to work, but Init() is a no-op
-                 * for some of the decoders, so this should force more symbols
-                 * to be pulled in.
-                 */
-                sample = Sound_NewSampleFromFile(argv[1], &desired, 4096);
-
-                Sound_Quit();
-                SDL_Quit();
-                return 0;
-            }"
-        )
-
-        # Calling
-        # target_link_libraries(DetermineSoundLibs "${SDL_SOUND_LIBRARY} ${SDL2_LIBRARY})
-        # causes problems when SDL2_LIBRARY looks like
-        # /Library/Frameworks/SDL2.framework;-framework Cocoa
-        # The ;-framework Cocoa seems to be confusing CMake once the OS X
-        # framework support was added. I was told that breaking up the list
-        # would fix the problem.
-        set(TMP_LIBS "")
-        if(SDL2_FOUND)
-            set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARY} ${SDL2_LIBRARY})
-            foreach(lib ${SDL_SOUND_LIBRARY} ${SDL2_LIBRARY})
-                set(TMP_LIBS "${TMP_LIBS} \"${lib}\"")
-            endforeach()
-            set(TMP_INCLUDE_DIRS ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-        else()
-            set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARY} ${SDL_LIBRARY})
-            foreach(lib ${SDL_SOUND_LIBRARY} ${SDL_LIBRARY})
-                set(TMP_LIBS "${TMP_LIBS} \"${lib}\"")
-            endforeach()
-            set(TMP_INCLUDE_DIRS ${SDL_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR})
-        endif()
-
-        # Keep trying to build a temp project until we find all missing libs.
-        set(TRY_AGAIN TRUE)
-        WHILE(TRY_AGAIN)
-            set(TRY_AGAIN FALSE)
-            # message("TMP_TRY_LIBS ${TMP_TRY_LIBS}")
-
-            # Write the CMakeLists.txt and test project
-            # Weird, this is still sketchy. If I don't quote the variables
-            # in the TARGET_LINK_LIBRARIES, I seem to loose everything
-            # in the SDL2_LIBRARY string after the "-framework".
-            # But if I quote the stuff in INCLUDE_DIRECTORIES, it doesn't work.
-            file(WRITE ${PROJECT_BINARY_DIR}/CMakeTmp/CMakeLists.txt
-                "cmake_minimum_required(VERSION 2.8)
-                project(DetermineSoundLibs C)
-                include_directories(${TMP_INCLUDE_DIRS})
-                add_executable(DetermineSoundLibs DetermineSoundLibs.c)
-                target_link_libraries(DetermineSoundLibs ${TMP_LIBS})"
-            )
-
-            try_compile(
-                MY_RESULT
-                ${PROJECT_BINARY_DIR}/CMakeTmp
-                ${PROJECT_BINARY_DIR}/CMakeTmp
-                DetermineSoundLibs
-                OUTPUT_VARIABLE MY_OUTPUT
-            )
-            # message("${MY_RESULT}")
-            # message(${MY_OUTPUT})
-
-            if(NOT MY_RESULT)
-                # I expect that MPGLIB, VOC, WAV, AIFF, and SHN are compiled in statically.
-                # I think Timidity is also compiled in statically.
-                # I've never had to explcitly link against Quicktime, so I'll skip that for now.
-
-                # Find libmath
-                if("${MY_OUTPUT}" MATCHES "cos@@GLIBC")
-                    find_library(MATH_LIBRARY NAMES m)
-                    if(MATH_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${MATH_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${MATH_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif(MATH_LIBRARY)
-                endif("${MY_OUTPUT}" MATCHES "cos@@GLIBC")
-
-                # Find MikMod
-                if("${MY_OUTPUT}" MATCHES "MikMod_")
-                    find_library(MIKMOD_LIBRARY
-                        NAMES libmikmod-coreaudio mikmod
-                        PATHS
-                            ENV MIKMODDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(MIKMOD_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${MIKMOD_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${MIKMOD_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif(MIKMOD_LIBRARY)
-                endif("${MY_OUTPUT}" MATCHES "MikMod_")
-
-                # Find ModPlug
-                if("${MY_OUTPUT}" MATCHES "MODPLUG_")
-                    find_library(MODPLUG_LIBRARY
-                        NAMES modplug
-                        PATHS
-                            ENV MODPLUGDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(MODPLUG_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${MODPLUG_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${MODPLUG_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-                endif()
-
-                # Find Ogg and Vorbis
-                if("${MY_OUTPUT}" MATCHES "ov_")
-                    find_library(VORBISFILE_LIBRARY
-                        NAMES vorbisfile VorbisFile VORBISFILE
-                        PATHS
-                            ENV VORBISDIR
-                            ENV OGGDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(VORBISFILE_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${VORBISFILE_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${VORBISFILE_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-
-                    find_library(VORBIS_LIBRARY
-                        NAMES vorbis Vorbis VORBIS
-                        PATHS
-                            ENV OGGDIR
-                            ENV VORBISDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(VORBIS_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${VORBIS_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${VORBIS_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-
-                    find_library(OGG_LIBRARY
-                        NAMES ogg Ogg OGG
-                        PATHS
-                            ENV OGGDIR
-                            ENV VORBISDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(OGG_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${OGG_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${OGG_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-                endif()
-
-                # Find SMPEG
-                if("${MY_OUTPUT}" MATCHES "SMPEG_")
-                    find_library(SMPEG_LIBRARY
-                        NAMES smpeg SMPEG Smpeg SMpeg
-                        PATHS
-                            ENV SMPEGDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(SMPEG_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${SMPEG_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${SMPEG_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-                endif()
-
-
-                # Find FLAC
-                if("${MY_OUTPUT}" MATCHES "FLAC_")
-                    find_library(FLAC_LIBRARY
-                        NAMES flac FLAC
-                        PATHS
-                            ENV FLACDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(FLAC_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${FLAC_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${FLAC_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-                endif()
-
-
-                # Hmmm...Speex seems to depend on Ogg. This might be a problem if
-                # the TRY_COMPILE attempt gets blocked at SPEEX before it can pull
-                # in the Ogg symbols. I'm not sure if I should duplicate the ogg stuff
-                # above for here or if two ogg entries will screw up things.
-                if("${MY_OUTPUT}" MATCHES "speex_")
-                    find_library(SPEEX_LIBRARY
-                        NAMES speex SPEEX
-                        PATHS
-                            ENV SPEEXDIR
-                            ENV SDLSOUNDDIR
-                            ENV SDLDIR
-                            /sw
-                            /opt/local
-                            /opt/csw
-                            /opt
-                        PATH_SUFFIXES lib
-                    )
-                    if(SPEEX_LIBRARY)
-                        set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${SPEEX_LIBRARY})
-                        set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${SPEEX_LIBRARY}\"")
-                        set(TRY_AGAIN TRUE)
-                    endif()
-
-                    # Find OGG (needed for Speex)
-                    # We might have already found Ogg for Vorbis, so skip it if so.
-                    if(NOT OGG_LIBRARY)
-                        find_library(OGG_LIBRARY
-                            NAMES ogg Ogg OGG
-                            PATHS
-                                ENV OGGDIR
-                                ENV VORBISDIR
-                                ENV SPEEXDIR
-                                ENV SDLSOUNDDIR
-                                ENV SDLDIR
-                                /sw
-                                /opt/local
-                                /opt/csw
-                                /opt
-                            PATH_SUFFIXES lib
-                        )
-                        if(OGG_LIBRARY)
-                            set(SDL_SOUND_LIBRARIES_TMP ${SDL_SOUND_LIBRARIES_TMP} ${OGG_LIBRARY})
-                            set(TMP_LIBS "${SDL_SOUND_LIBRARIES_TMP} \"${OGG_LIBRARY}\"")
-                            set(TRY_AGAIN TRUE)
-                        endif()
-                    endif()
-                endif()
-            endif()
-        ENDWHILE()
-        unset(TMP_INCLUDE_DIRS)
-        unset(TMP_LIBS)
-
-        set(SDL_SOUND_LIBRARIES ${SDL_SOUND_EXTRAS} ${SDL_SOUND_LIBRARIES_TMP} CACHE INTERNAL "SDL_sound and dependent libraries")
-    endif()
-endif()
-
-if(SDL_SOUND_INCLUDE_DIR AND EXISTS "${SDL_SOUND_INCLUDE_DIR}/SDL_sound.h")
-  file(STRINGS "${SDL_SOUND_INCLUDE_DIR}/SDL_sound.h" SDL_SOUND_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SOUND_VER_MAJOR[ \t]+[0-9]+$")
-  file(STRINGS "${SDL_SOUND_INCLUDE_DIR}/SDL_sound.h" SDL_SOUND_VERSION_MINOR_LINE REGEX "^#define[ \t]+SOUND_VER_MINOR[ \t]+[0-9]+$")
-  file(STRINGS "${SDL_SOUND_INCLUDE_DIR}/SDL_sound.h" SDL_SOUND_VERSION_PATCH_LINE REGEX "^#define[ \t]+SOUND_VER_PATCH[ \t]+[0-9]+$")
-  string(REGEX REPLACE "^#define[ \t]+SOUND_VER_MAJOR[ \t]+([0-9]+)$" "\\1" SDL_SOUND_VERSION_MAJOR "${SDL_SOUND_VERSION_MAJOR_LINE}")
-  string(REGEX REPLACE "^#define[ \t]+SOUND_VER_MINOR[ \t]+([0-9]+)$" "\\1" SDL_SOUND_VERSION_MINOR "${SDL_SOUND_VERSION_MINOR_LINE}")
-  string(REGEX REPLACE "^#define[ \t]+SOUND_VER_PATCH[ \t]+([0-9]+)$" "\\1" SDL_SOUND_VERSION_PATCH "${SDL_SOUND_VERSION_PATCH_LINE}")
-  set(SDL_SOUND_VERSION_STRING ${SDL_SOUND_VERSION_MAJOR}.${SDL_SOUND_VERSION_MINOR}.${SDL_SOUND_VERSION_PATCH})
-  unset(SDL_SOUND_VERSION_MAJOR_LINE)
-  unset(SDL_SOUND_VERSION_MINOR_LINE)
-  unset(SDL_SOUND_VERSION_PATCH_LINE)
-  unset(SDL_SOUND_VERSION_MAJOR)
-  unset(SDL_SOUND_VERSION_MINOR)
-  unset(SDL_SOUND_VERSION_PATCH)
-endif()
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL_sound
-                                  REQUIRED_VARS SDL_SOUND_LIBRARIES SDL_SOUND_INCLUDE_DIR
-                                  VERSION_VAR SDL_SOUND_VERSION_STRING)
diff --git a/cmake/FindSndFile.cmake b/cmake/FindSndFile.cmake
new file mode 100644
index 00000000..b931d3c0
--- /dev/null
+++ b/cmake/FindSndFile.cmake
@@ -0,0 +1,25 @@
+# - Try to find SndFile
+# Once done this will define
+#
+#  SNDFILE_FOUND - system has SndFile
+#  SndFile::SndFile - the SndFile target
+#
+
+find_path(SNDFILE_INCLUDE_DIR NAMES sndfile.h)
+
+find_library(SNDFILE_LIBRARY NAMES sndfile sndfile-1)
+
+# handle the QUIETLY and REQUIRED arguments and set SNDFILE_FOUND to TRUE if
+# all listed variables are TRUE
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(SndFile DEFAULT_MSG SNDFILE_LIBRARY SNDFILE_INCLUDE_DIR)
+
+if(SNDFILE_FOUND)
+    add_library(SndFile::SndFile UNKNOWN IMPORTED)
+    set_target_properties(SndFile::SndFile PROPERTIES
+        IMPORTED_LOCATION ${SNDFILE_LIBRARY}
+        INTERFACE_INCLUDE_DIRECTORIES ${SNDFILE_INCLUDE_DIR})
+endif()
+
+# show the SNDFILE_INCLUDE_DIR and SNDFILE_LIBRARY variables only in the advanced view
+mark_as_advanced(SNDFILE_INCLUDE_DIR SNDFILE_LIBRARY)
diff --git a/cmake/FindWindowsSDK.cmake b/cmake/FindWindowsSDK.cmake
deleted file mode 100644
index 3fcc3bf4..00000000
--- a/cmake/FindWindowsSDK.cmake
+++ /dev/null
@@ -1,631 +0,0 @@
-# - Find the Windows SDK aka Platform SDK
-#
-# Relevant Wikipedia article: http://en.wikipedia.org/wiki/Microsoft_Windows_SDK
-#
-# Pass "COMPONENTS tools" to ignore Visual Studio version checks: in case
-# you just want the tool binaries to run, rather than the libraries and headers
-# for compiling.
-#
-# Variables:
-#  WINDOWSSDK_FOUND - if any version of the windows or platform SDK was found that is usable with the current version of visual studio
-#  WINDOWSSDK_LATEST_DIR
-#  WINDOWSSDK_LATEST_NAME
-#  WINDOWSSDK_FOUND_PREFERENCE - if we found an entry indicating a "preferred" SDK listed for this visual studio version
-#  WINDOWSSDK_PREFERRED_DIR
-#  WINDOWSSDK_PREFERRED_NAME
-#
-#  WINDOWSSDK_DIRS - contains no duplicates, ordered most recent first.
-#  WINDOWSSDK_PREFERRED_FIRST_DIRS - contains no duplicates, ordered with preferred first, followed by the rest in descending recency
-#
-# Functions:
-#  windowssdk_name_lookup(<directory> <output variable>) - Find the name corresponding with the SDK directory you pass in, or
-#     NOTFOUND if not recognized. Your directory must be one of WINDOWSSDK_DIRS for this to work.
-#
-#  windowssdk_build_lookup(<directory> <output variable>) - Find the build version number corresponding with the SDK directory you pass in, or
-#     NOTFOUND if not recognized. Your directory must be one of WINDOWSSDK_DIRS for this to work.
-#
-#  get_windowssdk_from_component(<file or dir> <output variable>) - Given a library or include dir,
-#     find the Windows SDK root dir corresponding to it, or NOTFOUND if unrecognized.
-#
-#  get_windowssdk_library_dirs(<directory> <output variable>) - Find the architecture-appropriate
-#     library directories corresponding to the SDK directory you pass in (or NOTFOUND if none)
-#
-#  get_windowssdk_library_dirs_multiple(<output variable> <directory> ...) - Find the architecture-appropriate
-#     library directories corresponding to the SDK directories you pass in, in order, skipping those not found. NOTFOUND if none at all.
-#     Good for passing WINDOWSSDK_DIRS or WINDOWSSDK_DIRS to if you really just want a file and don't care where from.
-#
-#  get_windowssdk_include_dirs(<directory> <output variable>) - Find the
-#     include directories corresponding to the SDK directory you pass in (or NOTFOUND if none)
-#
-#  get_windowssdk_include_dirs_multiple(<output variable> <directory> ...) - Find the
-#     include directories corresponding to the SDK directories you pass in, in order, skipping those not found. NOTFOUND if none at all.
-#     Good for passing WINDOWSSDK_DIRS or WINDOWSSDK_DIRS to if you really just want a file and don't care where from.
-#
-# Requires these CMake modules:
-#  FindPackageHandleStandardArgs (known included with CMake >=2.6.2)
-#
-# Original Author:
-# 2012 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2012.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-set(_preferred_sdk_dirs) # pre-output
-set(_win_sdk_dirs) # pre-output
-set(_win_sdk_versanddirs) # pre-output
-set(_win_sdk_buildsanddirs) # pre-output
-set(_winsdk_vistaonly) # search parameters
-set(_winsdk_kits) # search parameters
-
-
-set(_WINDOWSSDK_ANNOUNCE OFF)
-if(NOT WINDOWSSDK_FOUND AND (NOT WindowsSDK_FIND_QUIETLY))
-	set(_WINDOWSSDK_ANNOUNCE ON)
-endif()
-macro(_winsdk_announce)
-	if(_WINSDK_ANNOUNCE)
-		message(STATUS ${ARGN})
-	endif()
-endmacro()
-
-set(_winsdk_win10vers
-	10.0.18362.0 # Windows 10 Version 1903
-	10.0.17763.0 # Windows 10 Version 1809
-	10.0.17134.0 # Windows 10 Version 1803 (April 2018 Update)
-	10.0.16299.0 # Windows 10 Version 1709 (Fall Creators Update)
-	10.0.15063.0 # Windows 10 Version 1703 (Creators Update)
-	10.0.14393.0 # Redstone aka Win10 1607 "Anniversary Update"
-	10.0.10586.0 # TH2 aka Win10 1511
-	10.0.10240.0 # Win10 RTM
-	10.0.10150.0 # just ucrt
-	10.0.10056.0
-)
-
-if(WindowsSDK_FIND_COMPONENTS MATCHES "tools")
-	set(_WINDOWSSDK_IGNOREMSVC ON)
-	_winsdk_announce("Checking for tools from Windows/Platform SDKs...")
-else()
-	set(_WINDOWSSDK_IGNOREMSVC OFF)
-	_winsdk_announce("Checking for Windows/Platform SDKs...")
-endif()
-
-# Appends to the three main pre-output lists used only if the path exists
-# and is not already in the list.
-function(_winsdk_conditional_append _vername _build _path)
-	if(("${_path}" MATCHES "registry") OR (NOT EXISTS "${_path}"))
-		# Path invalid - do not add
-		return()
-	endif()
-	list(FIND _win_sdk_dirs "${_path}" _win_sdk_idx)
-	if(_win_sdk_idx GREATER -1)
-		# Path already in list - do not add
-		return()
-	endif()
-	_winsdk_announce( " - ${_vername}, Build ${_build} @ ${_path}")
-	# Not yet in the list, so we'll add it
-	list(APPEND _win_sdk_dirs "${_path}")
-	set(_win_sdk_dirs "${_win_sdk_dirs}" CACHE INTERNAL "" FORCE)
-	list(APPEND
-		_win_sdk_versanddirs
-		"${_vername}"
-		"${_path}")
-	set(_win_sdk_versanddirs "${_win_sdk_versanddirs}" CACHE INTERNAL "" FORCE)
-	list(APPEND
-		_win_sdk_buildsanddirs
-		"${_build}"
-		"${_path}")
-	set(_win_sdk_buildsanddirs "${_win_sdk_buildsanddirs}" CACHE INTERNAL "" FORCE)
-endfunction()
-
-# Appends to the "preferred SDK" lists only if the path exists
-function(_winsdk_conditional_append_preferred _info _path)
-	if(("${_path}" MATCHES "registry") OR (NOT EXISTS "${_path}"))
-		# Path invalid - do not add
-		return()
-	endif()
-
-	get_filename_component(_path "${_path}" ABSOLUTE)
-
-	list(FIND _win_sdk_preferred_sdk_dirs "${_path}" _win_sdk_idx)
-	if(_win_sdk_idx GREATER -1)
-		# Path already in list - do not add
-		return()
-	endif()
-	_winsdk_announce( " - Found \"preferred\" SDK ${_info} @ ${_path}")
-	# Not yet in the list, so we'll add it
-	list(APPEND _win_sdk_preferred_sdk_dirs "${_path}")
-	set(_win_sdk_preferred_sdk_dirs "${_win_sdk_dirs}" CACHE INTERNAL "" FORCE)
-
-	# Just in case we somehow missed it:
-	_winsdk_conditional_append("${_info}" "" "${_path}")
-endfunction()
-
-# Given a version like v7.0A, looks for an SDK in the registry under "Microsoft SDKs".
-# If the given version might be in both HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows
-# and HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots aka "Windows Kits",
-# use this macro first, since these registry keys usually have more information.
-#
-# Pass a "default" build number as an extra argument in case we can't find it.
-function(_winsdk_check_microsoft_sdks_registry _winsdkver)
-	set(SDKKEY "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\${_winsdkver}")
-	get_filename_component(_sdkdir
-		"[${SDKKEY};InstallationFolder]"
-		ABSOLUTE)
-
-	set(_sdkname "Windows SDK ${_winsdkver}")
-
-	# Default build number passed as extra argument
-	set(_build ${ARGN})
-	# See if the registry holds a Microsoft-mutilated, err, designated, product name
-	# (just using get_filename_component to execute the registry lookup)
-	get_filename_component(_sdkproductname
-		"[${SDKKEY};ProductName]"
-		NAME)
-	if(NOT "${_sdkproductname}" MATCHES "registry")
-		# Got a product name
-		set(_sdkname "${_sdkname} (${_sdkproductname})")
-	endif()
-
-	# try for a version to augment our name
-	# (just using get_filename_component to execute the registry lookup)
-	get_filename_component(_sdkver
-		"[${SDKKEY};ProductVersion]"
-		NAME)
-	if(NOT "${_sdkver}" MATCHES "registry" AND NOT MATCHES)
-		# Got a version
-		if(NOT "${_sdkver}" MATCHES "\\.\\.")
-			# and it's not an invalid one with two dots in it:
-			# use to override the default build
-			set(_build ${_sdkver})
-			if(NOT "${_sdkname}" MATCHES "${_sdkver}")
-				# Got a version that's not already in the name, let's use it to improve our name.
-				set(_sdkname "${_sdkname} (${_sdkver})")
-			endif()
-		endif()
-	endif()
-	_winsdk_conditional_append("${_sdkname}" "${_build}" "${_sdkdir}")
-endfunction()
-
-# Given a name for identification purposes, the build number, and a key (technically a "value name")
-# corresponding to a Windows SDK packaged as a "Windows Kit", look for it
-# in HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots
-# Note that the key or "value name" tends to be something weird like KitsRoot81 -
-# no easy way to predict, just have to observe them in the wild.
-# Doesn't hurt to also try _winsdk_check_microsoft_sdks_registry for these:
-# sometimes you get keys in both parts of the registry (in the wow64 portion especially),
-# and the non-"Windows Kits" location is often more descriptive.
-function(_winsdk_check_windows_kits_registry _winkit_name _winkit_build _winkit_key)
-	get_filename_component(_sdkdir
-		"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots;${_winkit_key}]"
-		ABSOLUTE)
-	_winsdk_conditional_append("${_winkit_name}" "${_winkit_build}" "${_sdkdir}")
-endfunction()
-
-# Given a name for identification purposes and the build number
-# corresponding to a Windows 10 SDK packaged as a "Windows Kit", look for it
-# in HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots
-# Doesn't hurt to also try _winsdk_check_microsoft_sdks_registry for these:
-# sometimes you get keys in both parts of the registry (in the wow64 portion especially),
-# and the non-"Windows Kits" location is often more descriptive.
-function(_winsdk_check_win10_kits _winkit_build)
-	get_filename_component(_sdkdir
-		"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots;KitsRoot10]"
-		ABSOLUTE)
-	if(("${_sdkdir}" MATCHES "registry") OR (NOT EXISTS "${_sdkdir}"))
-		return() # not found
-	endif()
-	if(EXISTS "${_sdkdir}/Include/${_winkit_build}/um")
-		_winsdk_conditional_append("Windows Kits 10 (Build ${_winkit_build})" "${_winkit_build}" "${_sdkdir}")
-	endif()
-endfunction()
-
-# Given a name for indentification purposes, the build number, and the associated package GUID,
-# look in the registry under both HKLM and HKCU in \\SOFTWARE\\Microsoft\\MicrosoftSDK\\InstalledSDKs\\
-# for that guid and the SDK it points to.
-function(_winsdk_check_platformsdk_registry _platformsdkname _build _platformsdkguid)
-	foreach(_winsdk_hive HKEY_LOCAL_MACHINE HKEY_CURRENT_USER)
-		get_filename_component(_sdkdir
-			"[${_winsdk_hive}\\SOFTWARE\\Microsoft\\MicrosoftSDK\\InstalledSDKs\\${_platformsdkguid};Install Dir]"
-			ABSOLUTE)
-		_winsdk_conditional_append("${_platformsdkname} (${_build})" "${_build}" "${_sdkdir}")
-	endforeach()
-endfunction()
-
-###
-# Detect toolchain information: to know whether it's OK to use Vista+ only SDKs
-###
-set(_winsdk_vistaonly_ok OFF)
-if(MSVC AND NOT _WINDOWSSDK_IGNOREMSVC)
-	# VC 10 and older has broad target support
-	if(MSVC_VERSION LESS 1700)
-		# VC 11 by default targets Vista and later only, so we can add a few more SDKs that (might?) only work on vista+
-	elseif("${CMAKE_VS_PLATFORM_TOOLSET}" MATCHES "_xp")
-		# This is the XP-compatible v110+ toolset
-	elseif("${CMAKE_VS_PLATFORM_TOOLSET}" STREQUAL "v100" OR "${CMAKE_VS_PLATFORM_TOOLSET}" STREQUAL "v90")
-		# This is the VS2010/VS2008 toolset
-	else()
-		# OK, we're VC11 or newer and not using a backlevel or XP-compatible toolset.
-		# These versions have no XP (and possibly Vista pre-SP1) support
-		set(_winsdk_vistaonly_ok ON)
-		if(_WINDOWSSDK_ANNOUNCE AND NOT _WINDOWSSDK_VISTAONLY_PESTERED)
-			set(_WINDOWSSDK_VISTAONLY_PESTERED ON CACHE INTERNAL "" FORCE)
-			message(STATUS "FindWindowsSDK: Detected Visual Studio 2012 or newer, not using the _xp toolset variant: including SDK versions that drop XP support in search!")
-		endif()
-	endif()
-endif()
-if(_WINDOWSSDK_IGNOREMSVC)
-	set(_winsdk_vistaonly_ok ON)
-endif()
-
-###
-# MSVC version checks - keeps messy conditionals in one place
-# (messy because of _WINDOWSSDK_IGNOREMSVC)
-###
-set(_winsdk_msvc_greater_1200 OFF)
-if(_WINDOWSSDK_IGNOREMSVC OR (MSVC AND (MSVC_VERSION GREATER 1200)))
-	set(_winsdk_msvc_greater_1200 ON)
-endif()
-# Newer than VS .NET/VS Toolkit 2003
-set(_winsdk_msvc_greater_1310 OFF)
-if(_WINDOWSSDK_IGNOREMSVC OR (MSVC AND (MSVC_VERSION GREATER 1310)))
-	set(_winsdk_msvc_greater_1310 ON)
-endif()
-
-# VS2005/2008
-set(_winsdk_msvc_less_1600 OFF)
-if(_WINDOWSSDK_IGNOREMSVC OR (MSVC AND (MSVC_VERSION LESS 1600)))
-	set(_winsdk_msvc_less_1600 ON)
-endif()
-
-# VS2013+
-set(_winsdk_msvc_not_less_1800 OFF)
-if(_WINDOWSSDK_IGNOREMSVC OR (MSVC AND (NOT MSVC_VERSION LESS 1800)))
-	set(_winsdk_msvc_not_less_1800 ON)
-endif()
-
-###
-# START body of find module
-###
-if(_winsdk_msvc_greater_1310) # Newer than VS .NET/VS Toolkit 2003
-	###
-	# Look for "preferred" SDKs
-	###
-
-	# Environment variable for SDK dir
-	if(EXISTS "$ENV{WindowsSDKDir}" AND (NOT "$ENV{WindowsSDKDir}" STREQUAL ""))
-		_winsdk_conditional_append_preferred("WindowsSDKDir environment variable" "$ENV{WindowsSDKDir}")
-	endif()
-
-	if(_winsdk_msvc_less_1600)
-		# Per-user current Windows SDK for VS2005/2008
-		get_filename_component(_sdkdir
-			"[HKEY_CURRENT_USER\\Software\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]"
-			ABSOLUTE)
-		_winsdk_conditional_append_preferred("Per-user current Windows SDK" "${_sdkdir}")
-
-		# System-wide current Windows SDK for VS2005/2008
-		get_filename_component(_sdkdir
-			"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]"
-			ABSOLUTE)
-		_winsdk_conditional_append_preferred("System-wide current Windows SDK" "${_sdkdir}")
-	endif()
-
-	###
-	# Begin the massive list of SDK searching!
-	###
-	if(_winsdk_vistaonly_ok AND _winsdk_msvc_not_less_1800)
-		# These require at least Visual Studio 2013 (VC12)
-
-		_winsdk_check_microsoft_sdks_registry(v10.0A)
-
-		# Windows Software Development Kit (SDK) for Windows 10
-		# Several different versions living in the same directory - if nothing else we can assume RTM (10240)
-		_winsdk_check_microsoft_sdks_registry(v10.0 10.0.10240.0)
-		foreach(_win10build ${_winsdk_win10vers})
-			_winsdk_check_win10_kits(${_win10build})
-		endforeach()
-	endif() # vista-only and 2013+
-
-	# Included in Visual Studio 2013
-	# Includes the v120_xp toolset
-	_winsdk_check_microsoft_sdks_registry(v8.1A 8.1.51636)
-
-	if(_winsdk_vistaonly_ok AND _winsdk_msvc_not_less_1800)
-		# Windows Software Development Kit (SDK) for Windows 8.1
-		# http://msdn.microsoft.com/en-gb/windows/desktop/bg162891
-		_winsdk_check_microsoft_sdks_registry(v8.1 8.1.25984.0)
-		_winsdk_check_windows_kits_registry("Windows Kits 8.1" 8.1.25984.0 KitsRoot81)
-	endif() # vista-only and 2013+
-
-	if(_winsdk_vistaonly_ok)
-		# Included in Visual Studio 2012
-		_winsdk_check_microsoft_sdks_registry(v8.0A 8.0.50727)
-
-		# Microsoft Windows SDK for Windows 8 and .NET Framework 4.5
-		# This is the first version to also include the DirectX SDK
-		# http://msdn.microsoft.com/en-US/windows/desktop/hh852363.aspx
-		_winsdk_check_microsoft_sdks_registry(v8.0 6.2.9200.16384)
-		_winsdk_check_windows_kits_registry("Windows Kits 8.0" 6.2.9200.16384 KitsRoot)
-	endif() # vista-only
-
-	# Included with VS 2012 Update 1 or later
-	# Introduces v110_xp toolset
-	_winsdk_check_microsoft_sdks_registry(v7.1A 7.1.51106)
-	if(_winsdk_vistaonly_ok)
-		# Microsoft Windows SDK for Windows 7 and .NET Framework 4
-		# http://www.microsoft.com/downloads/en/details.aspx?FamilyID=6b6c21d2-2006-4afa-9702-529fa782d63b
-		_winsdk_check_microsoft_sdks_registry(v7.1 7.1.7600.0.30514)
-	endif() # vista-only
-
-	# Included with VS 2010
-	_winsdk_check_microsoft_sdks_registry(v7.0A 6.1.7600.16385)
-
-	# Windows SDK for Windows 7 and .NET Framework 3.5 SP1
-	# Works with VC9
-	# http://www.microsoft.com/en-us/download/details.aspx?id=18950
-	_winsdk_check_microsoft_sdks_registry(v7.0 6.1.7600.16385)
-
-	# Two versions call themselves "v6.1":
-	# Older:
-	# Windows Vista Update & .NET 3.0 SDK
-	# http://www.microsoft.com/en-us/download/details.aspx?id=14477
-
-	# Newer:
-	# Windows Server 2008 & .NET 3.5 SDK
-	# may have broken VS9SP1? they recommend v7.0 instead, or a KB...
-	# http://www.microsoft.com/en-us/download/details.aspx?id=24826
-	_winsdk_check_microsoft_sdks_registry(v6.1 6.1.6000.16384.10)
-
-	# Included in VS 2008
-	_winsdk_check_microsoft_sdks_registry(v6.0A 6.1.6723.1)
-
-	# Microsoft Windows Software Development Kit for Windows Vista and .NET Framework 3.0 Runtime Components
-	# http://blogs.msdn.com/b/stanley/archive/2006/11/08/microsoft-windows-software-development-kit-for-windows-vista-and-net-framework-3-0-runtime-components.aspx
-	_winsdk_check_microsoft_sdks_registry(v6.0 6.0.6000.16384)
-endif()
-
-# Let's not forget the Platform SDKs, which sometimes are useful!
-if(_winsdk_msvc_greater_1200)
-	_winsdk_check_platformsdk_registry("Microsoft Platform SDK for Windows Server 2003 R2" "5.2.3790.2075.51" "D2FF9F89-8AA2-4373-8A31-C838BF4DBBE1")
-	_winsdk_check_platformsdk_registry("Microsoft Platform SDK for Windows Server 2003 SP1" "5.2.3790.1830.15" "8F9E5EF3-A9A5-491B-A889-C58EFFECE8B3")
-endif()
-###
-# Finally, look for "preferred" SDKs
-###
-if(_winsdk_msvc_greater_1310) # Newer than VS .NET/VS Toolkit 2003
-
-
-	# Environment variable for SDK dir
-	if(EXISTS "$ENV{WindowsSDKDir}" AND (NOT "$ENV{WindowsSDKDir}" STREQUAL ""))
-		_winsdk_conditional_append_preferred("WindowsSDKDir environment variable" "$ENV{WindowsSDKDir}")
-	endif()
-
-	if(_winsdk_msvc_less_1600)
-		# Per-user current Windows SDK for VS2005/2008
-		get_filename_component(_sdkdir
-			"[HKEY_CURRENT_USER\\Software\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]"
-			ABSOLUTE)
-		_winsdk_conditional_append_preferred("Per-user current Windows SDK" "${_sdkdir}")
-
-		# System-wide current Windows SDK for VS2005/2008
-		get_filename_component(_sdkdir
-			"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]"
-			ABSOLUTE)
-		_winsdk_conditional_append_preferred("System-wide current Windows SDK" "${_sdkdir}")
-	endif()
-endif()
-
-
-function(windowssdk_name_lookup _dir _outvar)
-	list(FIND _win_sdk_versanddirs "${_dir}" _diridx)
-	math(EXPR _idx "${_diridx} - 1")
-	if(${_idx} GREATER -1)
-		list(GET _win_sdk_versanddirs ${_idx} _ret)
-	else()
-		set(_ret "NOTFOUND")
-	endif()
-	set(${_outvar} "${_ret}" PARENT_SCOPE)
-endfunction()
-
-function(windowssdk_build_lookup _dir _outvar)
-	list(FIND _win_sdk_buildsanddirs "${_dir}" _diridx)
-	math(EXPR _idx "${_diridx} - 1")
-	if(${_idx} GREATER -1)
-		list(GET _win_sdk_buildsanddirs ${_idx} _ret)
-	else()
-		set(_ret "NOTFOUND")
-	endif()
-	set(${_outvar} "${_ret}" PARENT_SCOPE)
-endfunction()
-
-# If we found something...
-if(_win_sdk_dirs)
-	list(GET _win_sdk_dirs 0 WINDOWSSDK_LATEST_DIR)
-	windowssdk_name_lookup("${WINDOWSSDK_LATEST_DIR}"
-		WINDOWSSDK_LATEST_NAME)
-	set(WINDOWSSDK_DIRS ${_win_sdk_dirs})
-
-	# Fallback, in case no preference found.
-	set(WINDOWSSDK_PREFERRED_DIR "${WINDOWSSDK_LATEST_DIR}")
-	set(WINDOWSSDK_PREFERRED_NAME "${WINDOWSSDK_LATEST_NAME}")
-	set(WINDOWSSDK_PREFERRED_FIRST_DIRS ${WINDOWSSDK_DIRS})
-	set(WINDOWSSDK_FOUND_PREFERENCE OFF)
-endif()
-
-# If we found indications of a user preference...
-if(_win_sdk_preferred_sdk_dirs)
-	list(GET _win_sdk_preferred_sdk_dirs 0 WINDOWSSDK_PREFERRED_DIR)
-	windowssdk_name_lookup("${WINDOWSSDK_PREFERRED_DIR}"
-		WINDOWSSDK_PREFERRED_NAME)
-	set(WINDOWSSDK_PREFERRED_FIRST_DIRS
-		${_win_sdk_preferred_sdk_dirs}
-		${_win_sdk_dirs})
-	list(REMOVE_DUPLICATES WINDOWSSDK_PREFERRED_FIRST_DIRS)
-	set(WINDOWSSDK_FOUND_PREFERENCE ON)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(WindowsSDK
-	"No compatible version of the Windows SDK or Platform SDK found."
-	WINDOWSSDK_DIRS)
-
-if(WINDOWSSDK_FOUND)
-	# Internal: Architecture-appropriate library directory names.
-	if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "ARM")
-		if(CMAKE_SIZEOF_VOID_P MATCHES "8")
-			# Only supported in Win10 SDK and up.
-			set(_winsdk_arch8 arm64) # what the WDK for Win8+ calls this architecture
-		else()
-			set(_winsdk_archbare /arm) # what the architecture used to be called in oldest SDKs
-			set(_winsdk_arch arm) # what the architecture used to be called
-			set(_winsdk_arch8 arm) # what the WDK for Win8+ calls this architecture
-		endif()
-	else()
-		if(CMAKE_SIZEOF_VOID_P MATCHES "8")
-			set(_winsdk_archbare /x64) # what the architecture used to be called in oldest SDKs
-			set(_winsdk_arch amd64) # what the architecture used to be called
-			set(_winsdk_arch8 x64) # what the WDK for Win8+ calls this architecture
-		else()
-			set(_winsdk_archbare ) # what the architecture used to be called in oldest SDKs
-			set(_winsdk_arch i386) # what the architecture used to be called
-			set(_winsdk_arch8 x86) # what the WDK for Win8+ calls this architecture
-		endif()
-	endif()
-
-	function(get_windowssdk_from_component _component _var)
-		get_filename_component(_component "${_component}" ABSOLUTE)
-		file(TO_CMAKE_PATH "${_component}" _component)
-		foreach(_sdkdir ${WINDOWSSDK_DIRS})
-			get_filename_component(_sdkdir "${_sdkdir}" ABSOLUTE)
-			string(LENGTH "${_sdkdir}" _sdklen)
-			file(RELATIVE_PATH _rel "${_sdkdir}" "${_component}")
-			# If we don't have any "parent directory" items...
-			if(NOT "${_rel}" MATCHES "[.][.]")
-				set(${_var} "${_sdkdir}" PARENT_SCOPE)
-				return()
-			endif()
-		endforeach()
-		# Fail.
-		set(${_var} "NOTFOUND" PARENT_SCOPE)
-	endfunction()
-	function(get_windowssdk_library_dirs _winsdk_dir _var)
-		set(_dirs)
-		set(_suffixes
-			"lib${_winsdk_archbare}" # SDKs like 7.1A
-			"lib/${_winsdk_arch}" # just because some SDKs have x86 dir and root dir
-			"lib/w2k/${_winsdk_arch}" # Win2k min requirement
-			"lib/wxp/${_winsdk_arch}" # WinXP min requirement
-			"lib/wnet/${_winsdk_arch}" # Win Server 2003 min requirement
-			"lib/wlh/${_winsdk_arch}"
-			"lib/wlh/um/${_winsdk_arch8}" # Win Vista ("Long Horn") min requirement
-			"lib/win7/${_winsdk_arch}"
-			"lib/win7/um/${_winsdk_arch8}" # Win 7 min requirement
-		)
-		foreach(_ver
-			wlh # Win Vista ("Long Horn") min requirement
-			win7 # Win 7 min requirement
-			win8 # Win 8 min requirement
-			winv6.3 # Win 8.1 min requirement
-		)
-
-		list(APPEND _suffixes
-			"lib/${_ver}/${_winsdk_arch}"
-			"lib/${_ver}/um/${_winsdk_arch8}"
-			"lib/${_ver}/km/${_winsdk_arch8}"
-		)
-		endforeach()
-
-		# Look for WDF libraries in Win10+ SDK
-		foreach(_mode umdf kmdf)
-			file(GLOB _wdfdirs RELATIVE "${_winsdk_dir}" "${_winsdk_dir}/lib/wdf/${_mode}/${_winsdk_arch8}/*")
-			if(_wdfdirs)
-				list(APPEND _suffixes ${_wdfdirs})
-			endif()
-		endforeach()
-
-		# Look in each Win10+ SDK version for the components
-		foreach(_win10ver ${_winsdk_win10vers})
-			foreach(_component um km ucrt mmos)
-				list(APPEND _suffixes "lib/${_win10ver}/${_component}/${_winsdk_arch8}")
-			endforeach()
-		endforeach()
-
-		foreach(_suffix ${_suffixes})
-			# Check to see if a library actually exists here.
-			file(GLOB _libs "${_winsdk_dir}/${_suffix}/*.lib")
-			if(_libs)
-				list(APPEND _dirs "${_winsdk_dir}/${_suffix}")
-			endif()
-		endforeach()
-		if("${_dirs}" STREQUAL "")
-			set(_dirs NOTFOUND)
-		else()
-			list(REMOVE_DUPLICATES _dirs)
-		endif()
-		set(${_var} ${_dirs} PARENT_SCOPE)
-	endfunction()
-	function(get_windowssdk_include_dirs _winsdk_dir _var)
-		set(_dirs)
-
-		set(_subdirs shared um winrt km wdf mmos ucrt)
-		set(_suffixes Include)
-
-		foreach(_dir ${_subdirs})
-			list(APPEND _suffixes "Include/${_dir}")
-		endforeach()
-
-		foreach(_ver ${_winsdk_win10vers})
-			foreach(_dir ${_subdirs})
-				list(APPEND _suffixes "Include/${_ver}/${_dir}")
-			endforeach()
-		endforeach()
-
-		foreach(_suffix ${_suffixes})
-			# Check to see if a header file actually exists here.
-			file(GLOB _headers "${_winsdk_dir}/${_suffix}/*.h")
-			if(_headers)
-				list(APPEND _dirs "${_winsdk_dir}/${_suffix}")
-			endif()
-		endforeach()
-		if("${_dirs}" STREQUAL "")
-			set(_dirs NOTFOUND)
-		else()
-			list(REMOVE_DUPLICATES _dirs)
-		endif()
-		set(${_var} ${_dirs} PARENT_SCOPE)
-	endfunction()
-	function(get_windowssdk_library_dirs_multiple _var)
-		set(_dirs)
-		foreach(_sdkdir ${ARGN})
-			get_windowssdk_library_dirs("${_sdkdir}" _current_sdk_libdirs)
-			if(_current_sdk_libdirs)
-				list(APPEND _dirs ${_current_sdk_libdirs})
-			endif()
-		endforeach()
-		if("${_dirs}" STREQUAL "")
-			set(_dirs NOTFOUND)
-		else()
-			list(REMOVE_DUPLICATES _dirs)
-		endif()
-		set(${_var} ${_dirs} PARENT_SCOPE)
-	endfunction()
-	function(get_windowssdk_include_dirs_multiple _var)
-		set(_dirs)
-		foreach(_sdkdir ${ARGN})
-			get_windowssdk_include_dirs("${_sdkdir}" _current_sdk_incdirs)
-			if(_current_sdk_libdirs)
-				list(APPEND _dirs ${_current_sdk_incdirs})
-			endif()
-		endforeach()
-		if("${_dirs}" STREQUAL "")
-			set(_dirs NOTFOUND)
-		else()
-			list(REMOVE_DUPLICATES _dirs)
-		endif()
-		set(${_var} ${_dirs} PARENT_SCOPE)
-	endfunction()
-endif()
diff --git a/cmake/bin2h.script.cmake b/cmake/bin2h.script.cmake
new file mode 100644
index 00000000..7e74a7a1
--- /dev/null
+++ b/cmake/bin2h.script.cmake
@@ -0,0 +1,12 @@
+# Read the input file into 'indata', converting each byte to a pair of hex
+# characters
+file(READ "${INPUT_FILE}" indata HEX)
+
+# For each pair of characters, indent them and prepend the 0x prefix, and
+# append a comma separateor.
+# TODO: Prettify this. Should group a number of bytes per line instead of one
+# per line.
+string(REGEX REPLACE "(..)" "    0x\\1,\n" output "${indata}")
+
+# Write the list of hex chars to the output file
+file(WRITE "${OUTPUT_FILE}" "${output}")
diff --git a/common/albit.h b/common/albit.h
new file mode 100644
index 00000000..ad596208
--- /dev/null
+++ b/common/albit.h
@@ -0,0 +1,155 @@
+#ifndef AL_BIT_H
+#define AL_BIT_H
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+#if !defined(__GNUC__) && (defined(_WIN32) || defined(_WIN64))
+#include <intrin.h>
+#endif
+
+namespace al {
+
+#ifdef __BYTE_ORDER__
+enum class endian {
+    little = __ORDER_LITTLE_ENDIAN__,
+    big = __ORDER_BIG_ENDIAN__,
+    native = __BYTE_ORDER__
+};
+
+#else
+
+/* This doesn't support mixed-endian. */
+namespace detail_ {
+constexpr bool IsLittleEndian() noexcept
+{
+    static_assert(sizeof(char) < sizeof(int), "char is too big");
+
+    constexpr int test_val{1};
+    return static_cast<const char&>(test_val) ? true : false;
+}
+} // namespace detail_
+
+enum class endian {
+    big = 0,
+    little = 1,
+    native = detail_::IsLittleEndian() ? little : big
+};
+#endif
+
+
+/* Define popcount (population count/count 1 bits) and countr_zero (count
+ * trailing zero bits, starting from the lsb) methods, for various integer
+ * types.
+ */
+#ifdef __GNUC__
+
+namespace detail_ {
+    inline int popcount(unsigned long long val) noexcept { return __builtin_popcountll(val); }
+    inline int popcount(unsigned long val) noexcept { return __builtin_popcountl(val); }
+    inline int popcount(unsigned int val) noexcept { return __builtin_popcount(val); }
+
+    inline int countr_zero(unsigned long long val) noexcept { return __builtin_ctzll(val); }
+    inline int countr_zero(unsigned long val) noexcept { return __builtin_ctzl(val); }
+    inline int countr_zero(unsigned int val) noexcept { return __builtin_ctz(val); }
+} // namespace detail_
+
+template<typename T>
+inline std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
+int> popcount(T v) noexcept { return detail_::popcount(v); }
+
+template<typename T>
+inline std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
+int> countr_zero(T val) noexcept
+{ return val ? detail_::countr_zero(val) : std::numeric_limits<T>::digits; }
+
+#else
+
+/* There be black magics here. The popcount method is derived from
+ * https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+ * while the ctz-utilizing-popcount algorithm is shown here
+ * http://www.hackersdelight.org/hdcodetxt/ntz.c.txt
+ * as the ntz2 variant. These likely aren't the most efficient methods, but
+ * they're good enough if the GCC built-ins aren't available.
+ */
+namespace detail_ {
+    template<typename T, size_t = std::numeric_limits<T>::digits>
+    struct fast_utype { };
+    template<typename T>
+    struct fast_utype<T,8> { using type = std::uint_fast8_t; };
+    template<typename T>
+    struct fast_utype<T,16> { using type = std::uint_fast16_t; };
+    template<typename T>
+    struct fast_utype<T,32> { using type = std::uint_fast32_t; };
+    template<typename T>
+    struct fast_utype<T,64> { using type = std::uint_fast64_t; };
+
+    template<typename T>
+    constexpr T repbits(unsigned char bits) noexcept
+    {
+        T ret{bits};
+        for(size_t i{1};i < sizeof(T);++i)
+            ret = (ret<<8) | bits;
+        return ret;
+    }
+} // namespace detail_
+
+template<typename T>
+constexpr std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
+int> popcount(T val) noexcept
+{
+    using fast_type = typename detail_::fast_utype<T>::type;
+    constexpr fast_type b01010101{detail_::repbits<fast_type>(0x55)};
+    constexpr fast_type b00110011{detail_::repbits<fast_type>(0x33)};
+    constexpr fast_type b00001111{detail_::repbits<fast_type>(0x0f)};
+    constexpr fast_type b00000001{detail_::repbits<fast_type>(0x01)};
+
+    fast_type v{fast_type{val} - ((fast_type{val} >> 1) & b01010101)};
+    v = (v & b00110011) + ((v >> 2) & b00110011);
+    v = (v + (v >> 4)) & b00001111;
+    return static_cast<int>(((v * b00000001) >> ((sizeof(T)-1)*8)) & 0xff);
+}
+
+#ifdef _WIN32
+
+template<typename T>
+inline std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value
+    && std::numeric_limits<T>::digits <= 32,
+int> countr_zero(T v)
+{
+    unsigned long idx{std::numeric_limits<T>::digits};
+    _BitScanForward(&idx, static_cast<uint32_t>(v));
+    return static_cast<int>(idx);
+}
+
+template<typename T>
+inline std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value
+    && 32 < std::numeric_limits<T>::digits && std::numeric_limits<T>::digits <= 64,
+int> countr_zero(T v)
+{
+    unsigned long idx{std::numeric_limits<T>::digits};
+#ifdef _WIN64
+    _BitScanForward64(&idx, v);
+#else
+    if(!_BitScanForward(&idx, static_cast<uint32_t>(v)))
+    {
+        if(_BitScanForward(&idx, static_cast<uint32_t>(v>>32)))
+            idx += 32;
+    }
+#endif /* _WIN64 */
+    return static_cast<int>(idx);
+}
+
+#else
+
+template<typename T>
+constexpr std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
+int> countr_zero(T value)
+{ return popcount(static_cast<T>(~value & (value - 1))); }
+
+#endif
+#endif
+
+} // namespace al
+
+#endif /* AL_BIT_H */
diff --git a/common/albyte.h b/common/albyte.h
index 23864636..be586869 100644
--- a/common/albyte.h
+++ b/common/albyte.h
@@ -2,97 +2,15 @@
 #define AL_BYTE_H
 
 #include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <type_traits>
 
-namespace al {
-
-/* The "canonical" way to store raw byte data. Like C++17's std::byte, it's not
- * treated as a character type and does not work with arithmatic ops. Only
- * bitwise ops are allowed.
- */
-enum class byte : unsigned char { };
-
-#define REQUIRES(...) typename std::enable_if<(__VA_ARGS__),bool>::type = true
-
-template<typename T, REQUIRES(std::is_integral<T>::value)>
-inline constexpr T to_integer(al::byte b) noexcept { return T(b); }
-
-
-template<typename T, REQUIRES(std::is_integral<T>::value)>
-inline constexpr al::byte operator<<(al::byte lhs, T rhs) noexcept
-{ return al::byte(to_integer<unsigned int>(lhs) << rhs); }
-
-template<typename T, REQUIRES(std::is_integral<T>::value)>
-inline constexpr al::byte operator>>(al::byte lhs, T rhs) noexcept
-{ return al::byte(to_integer<unsigned int>(lhs) >> rhs); }
-
-template<typename T, REQUIRES(std::is_integral<T>::value)>
-inline al::byte& operator<<=(al::byte &lhs, T rhs) noexcept
-{ lhs = lhs << rhs; return lhs; }
-
-template<typename T, REQUIRES(std::is_integral<T>::value)>
-inline al::byte& operator>>=(al::byte &lhs, T rhs) noexcept
-{ lhs = lhs >> rhs; return lhs; }
+using uint = unsigned int;
 
-#define AL_DECL_OP(op)                                                        \
-template<typename T, REQUIRES(std::is_integral<T>::value)>                    \
-inline constexpr al::byte operator op (al::byte lhs, T rhs) noexcept          \
-{ return al::byte(to_integer<unsigned int>(lhs) op static_cast<unsigned int>(rhs)); } \
-template<typename T, REQUIRES(std::is_integral<T>::value)>                    \
-inline al::byte& operator op##= (al::byte &lhs, T rhs) noexcept               \
-{ lhs = lhs op rhs; return lhs; }                                             \
-inline constexpr al::byte operator op (al::byte lhs, al::byte rhs) noexcept   \
-{ return al::byte(lhs op to_integer<unsigned int>(rhs)); }                    \
-inline al::byte& operator op##= (al::byte &lhs, al::byte rhs) noexcept        \
-{ lhs = lhs op rhs; return lhs; }
-
-AL_DECL_OP(|)
-AL_DECL_OP(&)
-AL_DECL_OP(^)
-
-#undef AL_DECL_OP
-
-inline constexpr al::byte operator~(al::byte b) noexcept
-{ return al::byte(~to_integer<unsigned int>(b)); }
-
-
-template<size_t N>
-class bitfield {
-    static constexpr size_t bits_per_byte{std::numeric_limits<unsigned char>::digits};
-    static constexpr size_t NumElems{(N+bits_per_byte-1) / bits_per_byte};
-
-    byte vals[NumElems]{};
-
-public:
-    template<size_t b>
-    inline void set() noexcept
-    {
-        static_assert(b < N, "Bit index out of range");
-        vals[b/bits_per_byte] |= 1 << (b%bits_per_byte);
-    }
-    template<size_t b>
-    inline void unset() noexcept
-    {
-        static_assert(b < N, "Bit index out of range");
-        vals[b/bits_per_byte] &= ~(1 << (b%bits_per_byte));
-    }
-    template<size_t b>
-    inline bool get() const noexcept
-    {
-        static_assert(b < N, "Bit index out of range");
-        return (vals[b/bits_per_byte] & (1 << (b%bits_per_byte))) != byte{};
-    }
-
-    template<size_t b, size_t ...args, REQUIRES(sizeof...(args) > 0)>
-    void set() noexcept
-    {
-        set<b>();
-        set<args...>();
-    }
-};
+namespace al {
 
-#undef REQUIRES
+using byte = unsigned char;
 
 } // namespace al
 
diff --git a/common/alcomplex.cpp b/common/alcomplex.cpp
index e5cbe8a0..4420a1bb 100644
--- a/common/alcomplex.cpp
+++ b/common/alcomplex.cpp
@@ -4,58 +4,153 @@
 #include "alcomplex.h"
 
 #include <algorithm>
+#include <cassert>
 #include <cmath>
 #include <cstddef>
+#include <functional>
 #include <utility>
 
-#include "math_defs.h"
+#include "albit.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "opthelpers.h"
 
 
-void complex_fft(const al::span<std::complex<double>> buffer, const double sign)
+namespace {
+
+using ushort = unsigned short;
+using ushort2 = std::pair<ushort,ushort>;
+
+constexpr size_t BitReverseCounter(size_t log2_size) noexcept
 {
-    const size_t fftsize{buffer.size()};
-    /* Bit-reversal permutation applied to a sequence of FFTSize items */
-    for(size_t i{1u};i < fftsize-1;i++)
+    /* Some magic math that calculates the number of swaps needed for a
+     * sequence of bit-reversed indices when index < reversed_index.
+     */
+    return (1u<<(log2_size-1)) - (1u<<((log2_size-1u)/2u));
+}
+
+
+template<size_t N>
+struct BitReverser {
+    static_assert(N <= sizeof(ushort)*8, "Too many bits for the bit-reversal table.");
+
+    ushort2 mData[BitReverseCounter(N)]{};
+
+    constexpr BitReverser()
     {
-        size_t j{0u};
-        for(size_t mask{1u};mask < fftsize;mask <<= 1)
+        const size_t fftsize{1u << N};
+        size_t ret_i{0};
+
+        /* Bit-reversal permutation applied to a sequence of fftsize items. */
+        for(size_t idx{1u};idx < fftsize-1;++idx)
         {
-            if((i&mask) != 0)
-                j++;
-            j <<= 1;
+            size_t revidx{0u}, imask{idx};
+            for(size_t i{0};i < N;++i)
+            {
+                revidx = (revidx<<1) | (imask&1);
+                imask >>= 1;
+            }
+
+            if(idx < revidx)
+            {
+                mData[ret_i].first  = static_cast<ushort>(idx);
+                mData[ret_i].second = static_cast<ushort>(revidx);
+                ++ret_i;
+            }
         }
-        j >>= 1;
+        assert(ret_i == al::size(mData));
+    }
+};
 
-        if(i < j)
-            std::swap(buffer[i], buffer[j]);
+/* These bit-reversal swap tables support up to 10-bit indices (1024 elements),
+ * which is the largest used by OpenAL Soft's filters and effects. Larger FFT
+ * requests, used by some utilities where performance is less important, will
+ * use a slower table-less path.
+ */
+constexpr BitReverser<2> BitReverser2{};
+constexpr BitReverser<3> BitReverser3{};
+constexpr BitReverser<4> BitReverser4{};
+constexpr BitReverser<5> BitReverser5{};
+constexpr BitReverser<6> BitReverser6{};
+constexpr BitReverser<7> BitReverser7{};
+constexpr BitReverser<8> BitReverser8{};
+constexpr BitReverser<9> BitReverser9{};
+constexpr BitReverser<10> BitReverser10{};
+constexpr std::array<al::span<const ushort2>,11> gBitReverses{{
+    {}, {},
+    BitReverser2.mData,
+    BitReverser3.mData,
+    BitReverser4.mData,
+    BitReverser5.mData,
+    BitReverser6.mData,
+    BitReverser7.mData,
+    BitReverser8.mData,
+    BitReverser9.mData,
+    BitReverser10.mData
+}};
+
+} // namespace
+
+template<typename Real>
+std::enable_if_t<std::is_floating_point<Real>::value>
+complex_fft(const al::span<std::complex<Real>> buffer, const al::type_identity_t<Real> sign)
+{
+    const size_t fftsize{buffer.size()};
+    /* Get the number of bits used for indexing. Simplifies bit-reversal and
+     * the main loop count.
+     */
+    const size_t log2_size{static_cast<size_t>(al::countr_zero(fftsize))};
+
+    if(log2_size >= gBitReverses.size()) UNLIKELY
+    {
+        for(size_t idx{1u};idx < fftsize-1;++idx)
+        {
+            size_t revidx{0u}, imask{idx};
+            for(size_t i{0};i < log2_size;++i)
+            {
+                revidx = (revidx<<1) | (imask&1);
+                imask >>= 1;
+            }
+
+            if(idx < revidx)
+                std::swap(buffer[idx], buffer[revidx]);
+        }
     }
+    else for(auto &rev : gBitReverses[log2_size])
+        std::swap(buffer[rev.first], buffer[rev.second]);
 
-    /* Iterative form of Danielson–Lanczos lemma */
-    size_t step{2u};
-    for(size_t i{1u};i < fftsize;i<<=1, step<<=1)
+    /* Iterative form of Danielson-Lanczos lemma */
+    const Real pi{al::numbers::pi_v<Real> * sign};
+    size_t step2{1u};
+    for(size_t i{0};i < log2_size;++i)
     {
-        const size_t step2{step >> 1};
-        double arg{al::MathDefs<double>::Pi() / static_cast<double>(step2)};
+        const Real arg{pi / static_cast<Real>(step2)};
 
-        std::complex<double> w{std::cos(arg), std::sin(arg)*sign};
-        std::complex<double> u{1.0, 0.0};
+        /* TODO: Would std::polar(1.0, arg) be any better? */
+        const std::complex<Real> w{std::cos(arg), std::sin(arg)};
+        std::complex<Real> u{1.0, 0.0};
+        const size_t step{step2 << 1};
         for(size_t j{0};j < step2;j++)
         {
             for(size_t k{j};k < fftsize;k+=step)
             {
-                std::complex<double> temp{buffer[k+step2] * u};
+                std::complex<Real> temp{buffer[k+step2] * u};
                 buffer[k+step2] = buffer[k] - temp;
                 buffer[k] += temp;
             }
 
             u *= w;
         }
+
+        step2 <<= 1;
     }
 }
 
 void complex_hilbert(const al::span<std::complex<double>> buffer)
 {
-    complex_fft(buffer, 1.0);
+    using namespace std::placeholders;
+
+    inverse_fft(buffer);
 
     const double inverse_size = 1.0/static_cast<double>(buffer.size());
     auto bufiter = buffer.begin();
@@ -63,11 +158,14 @@ void complex_hilbert(const al::span<std::complex<double>> buffer)
 
     *bufiter *= inverse_size; ++bufiter;
     bufiter = std::transform(bufiter, halfiter, bufiter,
-        [inverse_size](const std::complex<double> &c) -> std::complex<double>
-        { return c * (2.0*inverse_size); });
+        [scale=inverse_size*2.0](std::complex<double> d){ return d * scale; });
     *bufiter *= inverse_size; ++bufiter;
 
     std::fill(bufiter, buffer.end(), std::complex<double>{});
 
-    complex_fft(buffer, -1.0);
+    forward_fft(buffer);
 }
+
+
+template void complex_fft<>(const al::span<std::complex<float>> buffer, const float sign);
+template void complex_fft<>(const al::span<std::complex<double>> buffer, const double sign);
diff --git a/common/alcomplex.h b/common/alcomplex.h
index 12b86436..794c3526 100644
--- a/common/alcomplex.h
+++ b/common/alcomplex.h
@@ -2,16 +2,36 @@
 #define ALCOMPLEX_H
 
 #include <complex>
+#include <type_traits>
 
 #include "alspan.h"
 
 /**
  * Iterative implementation of 2-radix FFT (In-place algorithm). Sign = -1 is
- * FFT and 1 is iFFT (inverse). Fills the buffer with the Discrete Fourier
- * Transform (DFT) of the time domain data stored in the buffer. The buffer is
- * an array of complex numbers, and MUST BE power of two.
+ * FFT and 1 is inverse FFT. Applies the Discrete Fourier Transform (DFT) to
+ * the data supplied in the buffer, which MUST BE power of two.
  */
-void complex_fft(const al::span<std::complex<double>> buffer, const double sign);
+template<typename Real>
+std::enable_if_t<std::is_floating_point<Real>::value>
+complex_fft(const al::span<std::complex<Real>> buffer, const al::type_identity_t<Real> sign);
+
+/**
+ * Calculate the frequency-domain response of the time-domain signal in the
+ * provided buffer, which MUST BE power of two.
+ */
+template<typename Real, size_t N>
+std::enable_if_t<std::is_floating_point<Real>::value>
+forward_fft(const al::span<std::complex<Real>,N> buffer)
+{ complex_fft(buffer.subspan(0), -1); }
+
+/**
+ * Calculate the time-domain signal of the frequency-domain response in the
+ * provided buffer, which MUST BE power of two.
+ */
+template<typename Real, size_t N>
+std::enable_if_t<std::is_floating_point<Real>::value>
+inverse_fft(const al::span<std::complex<Real>,N> buffer)
+{ complex_fft(buffer.subspan(0), 1); }
 
 /**
  * Calculate the complex helical sequence (discrete-time analytical signal) of
diff --git a/common/aldeque.h b/common/aldeque.h
new file mode 100644
index 00000000..3f99bf00
--- /dev/null
+++ b/common/aldeque.h
@@ -0,0 +1,16 @@
+#ifndef ALDEQUE_H
+#define ALDEQUE_H
+
+#include <deque>
+
+#include "almalloc.h"
+
+
+namespace al {
+
+template<typename T>
+using deque = std::deque<T, al::allocator<T>>;
+
+} // namespace al
+
+#endif /* ALDEQUE_H */
diff --git a/common/alexcpt.h b/common/alexcpt.h
deleted file mode 100644
index ff09bab2..00000000
--- a/common/alexcpt.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef ALEXCPT_H
-#define ALEXCPT_H
-
-#include <exception>
-#include <string>
-
-#include "AL/alc.h"
-
-
-#ifdef __GNUC__
-#define ALEXCPT_FORMAT(x, y, z) __attribute__((format(x, (y), (z))))
-#else
-#define ALEXCPT_FORMAT(x, y, z)
-#endif
-
-
-namespace al {
-
-class backend_exception final : public std::exception {
-    std::string mMessage;
-    ALCenum mErrorCode;
-
-public:
-    backend_exception(ALCenum code, const char *msg, ...) ALEXCPT_FORMAT(printf, 3,4);
-
-    const char *what() const noexcept override { return mMessage.c_str(); }
-    ALCenum errorCode() const noexcept { return mErrorCode; }
-};
-
-} // namespace al
-
-#define START_API_FUNC try
-
-#define END_API_FUNC catch(...) { std::terminate(); }
-
-#endif /* ALEXCPT_H */
diff --git a/common/alfstream.cpp b/common/alfstream.cpp
index 7378c678..8991ce03 100644
--- a/common/alfstream.cpp
+++ b/common/alfstream.cpp
@@ -9,138 +9,17 @@
 
 namespace al {
 
-auto filebuf::underflow() -> int_type
-{
-    if(mFile != INVALID_HANDLE_VALUE && gptr() == egptr())
-    {
-        // Read in the next chunk of data, and set the pointers on success
-        DWORD got{};
-        if(ReadFile(mFile, mBuffer.data(), static_cast<DWORD>(mBuffer.size()), &got, nullptr))
-            setg(mBuffer.data(), mBuffer.data(), mBuffer.data()+got);
-    }
-    if(gptr() == egptr())
-        return traits_type::eof();
-    return traits_type::to_int_type(*gptr());
-}
-
-auto filebuf::seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) -> pos_type
-{
-    if(mFile == INVALID_HANDLE_VALUE || (mode&std::ios_base::out) || !(mode&std::ios_base::in))
-        return traits_type::eof();
-
-    LARGE_INTEGER fpos{};
-    switch(whence)
-    {
-        case std::ios_base::beg:
-            fpos.QuadPart = offset;
-            if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_BEGIN))
-                return traits_type::eof();
-            break;
-
-        case std::ios_base::cur:
-            // If the offset remains in the current buffer range, just
-            // update the pointer.
-            if((offset >= 0 && offset < off_type(egptr()-gptr())) ||
-                (offset < 0 && -offset <= off_type(gptr()-eback())))
-            {
-                // Get the current file offset to report the correct read
-                // offset.
-                fpos.QuadPart = 0;
-                if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_CURRENT))
-                    return traits_type::eof();
-                setg(eback(), gptr()+offset, egptr());
-                return fpos.QuadPart - off_type(egptr()-gptr());
-            }
-            // Need to offset for the file offset being at egptr() while
-            // the requested offset is relative to gptr().
-            offset -= off_type(egptr()-gptr());
-            fpos.QuadPart = offset;
-            if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_CURRENT))
-                return traits_type::eof();
-            break;
-
-        case std::ios_base::end:
-            fpos.QuadPart = offset;
-            if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_END))
-                return traits_type::eof();
-            break;
-
-        default:
-            return traits_type::eof();
-    }
-    setg(nullptr, nullptr, nullptr);
-    return fpos.QuadPart;
-}
-
-auto filebuf::seekpos(pos_type pos, std::ios_base::openmode mode) -> pos_type
-{
-    // Simplified version of seekoff
-    if(mFile == INVALID_HANDLE_VALUE || (mode&std::ios_base::out) || !(mode&std::ios_base::in))
-        return traits_type::eof();
-
-    LARGE_INTEGER fpos{};
-    fpos.QuadPart = pos;
-    if(!SetFilePointerEx(mFile, fpos, &fpos, FILE_BEGIN))
-        return traits_type::eof();
-
-    setg(nullptr, nullptr, nullptr);
-    return fpos.QuadPart;
-}
-
-filebuf::~filebuf()
-{
-    if(mFile != INVALID_HANDLE_VALUE)
-        CloseHandle(mFile);
-    mFile = INVALID_HANDLE_VALUE;
-}
-
-bool filebuf::open(const wchar_t *filename, std::ios_base::openmode mode)
-{
-    if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
-        return false;
-    HANDLE f{CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
-        FILE_ATTRIBUTE_NORMAL, nullptr)};
-    if(f == INVALID_HANDLE_VALUE) return false;
-
-    if(mFile != INVALID_HANDLE_VALUE)
-        CloseHandle(mFile);
-    mFile = f;
-
-    setg(nullptr, nullptr, nullptr);
-    return true;
-}
-bool filebuf::open(const char *filename, std::ios_base::openmode mode)
-{
-    std::wstring wname{utf8_to_wstr(filename)};
-    return open(wname.c_str(), mode);
-}
-
-
-ifstream::ifstream(const wchar_t *filename, std::ios_base::openmode mode)
-  : std::istream{nullptr}
-{
-    init(&mStreamBuf);
-
-    // Set the failbit if the file failed to open.
-    if((mode&std::ios_base::out) || !mStreamBuf.open(filename, mode|std::ios_base::in))
-        clear(failbit);
-}
-
 ifstream::ifstream(const char *filename, std::ios_base::openmode mode)
-  : std::istream{nullptr}
-{
-    init(&mStreamBuf);
+  : std::ifstream{utf8_to_wstr(filename).c_str(), mode}
+{ }
 
-    // Set the failbit if the file failed to open.
-    if((mode&std::ios_base::out) || !mStreamBuf.open(filename, mode|std::ios_base::in))
-        clear(failbit);
+void ifstream::open(const char *filename, std::ios_base::openmode mode)
+{
+    std::wstring wstr{utf8_to_wstr(filename)};
+    std::ifstream::open(wstr.c_str(), mode);
 }
 
-/* This is only here to ensure the compiler doesn't define an implicit
- * destructor, which it tries to automatically inline and subsequently complain
- * it can't inline without excessive code growth.
- */
-ifstream::~ifstream() { }
+ifstream::~ifstream() = default;
 
 } // namespace al
 
diff --git a/common/alfstream.h b/common/alfstream.h
index 046a6e2a..62b2e12c 100644
--- a/common/alfstream.h
+++ b/common/alfstream.h
@@ -3,53 +3,29 @@
 
 #ifdef _WIN32
 
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-#include <array>
 #include <string>
 #include <fstream>
 
 
 namespace al {
 
-// Windows' std::ifstream fails with non-ANSI paths since the standard only
-// specifies names using const char* (or std::string). MSVC has a non-standard
-// extension using const wchar_t* (or std::wstring?) to handle Unicode paths,
-// but not all Windows compilers support it. So we have to make our own istream
-// that accepts UTF-8 paths and forwards to Unicode-aware I/O functions.
-class filebuf final : public std::streambuf {
-    std::array<char_type,4096> mBuffer;
-    HANDLE mFile{INVALID_HANDLE_VALUE};
-
-    int_type underflow() override;
-    pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) override;
-    pos_type seekpos(pos_type pos, std::ios_base::openmode mode) override;
-
+// Inherit from std::ifstream to accept UTF-8 filenames
+class ifstream final : public std::ifstream {
 public:
-    filebuf() = default;
-    ~filebuf() override;
+    explicit ifstream(const char *filename, std::ios_base::openmode mode=std::ios_base::in);
+    explicit ifstream(const std::string &filename, std::ios_base::openmode mode=std::ios_base::in)
+        : ifstream{filename.c_str(), mode} { }
 
-    bool open(const wchar_t *filename, std::ios_base::openmode mode);
-    bool open(const char *filename, std::ios_base::openmode mode);
+    explicit ifstream(const wchar_t *filename, std::ios_base::openmode mode=std::ios_base::in)
+        : std::ifstream{filename, mode} { }
+    explicit ifstream(const std::wstring &filename, std::ios_base::openmode mode=std::ios_base::in)
+        : ifstream{filename.c_str(), mode} { }
 
-    bool is_open() const noexcept { return mFile != INVALID_HANDLE_VALUE; }
-};
+    void open(const char *filename, std::ios_base::openmode mode=std::ios_base::in);
+    void open(const std::string &filename, std::ios_base::openmode mode=std::ios_base::in)
+    { open(filename.c_str(), mode); }
 
-// Inherit from std::istream to use our custom streambuf
-class ifstream final : public std::istream {
-    filebuf mStreamBuf;
-
-public:
-    ifstream(const wchar_t *filename, std::ios_base::openmode mode = std::ios_base::in);
-    ifstream(const std::wstring &filename, std::ios_base::openmode mode = std::ios_base::in)
-      : ifstream(filename.c_str(), mode) { }
-    ifstream(const char *filename, std::ios_base::openmode mode = std::ios_base::in);
-    ifstream(const std::string &filename, std::ios_base::openmode mode = std::ios_base::in)
-      : ifstream(filename.c_str(), mode) { }
     ~ifstream() override;
-
-    bool is_open() const noexcept { return mStreamBuf.is_open(); }
 };
 
 } // namespace al
@@ -60,7 +36,6 @@ public:
 
 namespace al {
 
-using filebuf = std::filebuf;
 using ifstream = std::ifstream;
 
 } // namespace al
diff --git a/common/almalloc.cpp b/common/almalloc.cpp
index 842fb400..ad1dc6be 100644
--- a/common/almalloc.cpp
+++ b/common/almalloc.cpp
@@ -7,61 +7,55 @@
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
+#include <memory>
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
 
 
-#define ALIGNED_ALLOC_AVAILABLE (__STDC_VERSION__ >= 201112L || __cplusplus >= 201703L)
-
 void *al_malloc(size_t alignment, size_t size)
 {
     assert((alignment & (alignment-1)) == 0);
     alignment = std::max(alignment, alignof(std::max_align_t));
 
-#if ALIGNED_ALLOC_AVAILABLE
-    size = (size+(alignment-1))&~(alignment-1);
-    return aligned_alloc(alignment, size);
-#elif defined(HAVE_POSIX_MEMALIGN)
-    void *ret;
+#if defined(HAVE_POSIX_MEMALIGN)
+    void *ret{};
     if(posix_memalign(&ret, alignment, size) == 0)
         return ret;
     return nullptr;
 #elif defined(HAVE__ALIGNED_MALLOC)
     return _aligned_malloc(size, alignment);
 #else
-    auto *ret = static_cast<char*>(malloc(size+alignment));
-    if(ret != nullptr)
+    size_t total_size{size + alignment-1 + sizeof(void*)};
+    void *base{std::malloc(total_size)};
+    if(base != nullptr)
     {
-        *(ret++) = 0x00;
-        while((reinterpret_cast<uintptr_t>(ret)&(alignment-1)) != 0)
-            *(ret++) = 0x55;
+        void *aligned_ptr{static_cast<char*>(base) + sizeof(void*)};
+        total_size -= sizeof(void*);
+
+        std::align(alignment, size, aligned_ptr, total_size);
+        *(static_cast<void**>(aligned_ptr)-1) = base;
+        base = aligned_ptr;
     }
-    return ret;
+    return base;
 #endif
 }
 
 void *al_calloc(size_t alignment, size_t size)
 {
-    void *ret = al_malloc(alignment, size);
-    if(ret) memset(ret, 0, size);
+    void *ret{al_malloc(alignment, size)};
+    if(ret) std::memset(ret, 0, size);
     return ret;
 }
 
 void al_free(void *ptr) noexcept
 {
-#if ALIGNED_ALLOC_AVAILABLE || defined(HAVE_POSIX_MEMALIGN)
-    free(ptr);
+#if defined(HAVE_POSIX_MEMALIGN)
+    std::free(ptr);
 #elif defined(HAVE__ALIGNED_MALLOC)
     _aligned_free(ptr);
 #else
     if(ptr != nullptr)
-    {
-        auto *finder = static_cast<char*>(ptr);
-        do {
-            --finder;
-        } while(*finder == 0x55);
-        free(finder);
-    }
+        std::free(*(static_cast<void**>(ptr) - 1));
 #endif
 }
diff --git a/common/almalloc.h b/common/almalloc.h
index 15ec600d..a795fc3b 100644
--- a/common/almalloc.h
+++ b/common/almalloc.h
@@ -13,47 +13,69 @@
 #include "pragmadefs.h"
 
 
+void al_free(void *ptr) noexcept;
+[[gnu::alloc_align(1), gnu::alloc_size(2), gnu::malloc]]
 void *al_malloc(size_t alignment, size_t size);
+[[gnu::alloc_align(1), gnu::alloc_size(2), gnu::malloc]]
 void *al_calloc(size_t alignment, size_t size);
-void al_free(void *ptr) noexcept;
 
 
+#define DISABLE_ALLOC()                                                       \
+    void *operator new(size_t) = delete;                                      \
+    void *operator new[](size_t) = delete;                                    \
+    void operator delete(void*) noexcept = delete;                            \
+    void operator delete[](void*) noexcept = delete;
+
 #define DEF_NEWDEL(T)                                                         \
     void *operator new(size_t size)                                           \
     {                                                                         \
-        void *ret = al_malloc(alignof(T), size);                              \
-        if(!ret) throw std::bad_alloc();                                      \
-        return ret;                                                           \
+        static_assert(&operator new == &T::operator new,                      \
+            "Incorrect container type specified");                            \
+        if(void *ret{al_malloc(alignof(T), size)})                            \
+            return ret;                                                       \
+        throw std::bad_alloc();                                               \
     }                                                                         \
-    void operator delete(void *block) noexcept { al_free(block); }
+    void *operator new[](size_t size) { return operator new(size); }          \
+    void operator delete(void *block) noexcept { al_free(block); }            \
+    void operator delete[](void *block) noexcept { operator delete(block); }
 
 #define DEF_PLACE_NEWDEL()                                                    \
     void *operator new(size_t /*size*/, void *ptr) noexcept { return ptr; }   \
+    void *operator new[](size_t /*size*/, void *ptr) noexcept { return ptr; } \
     void operator delete(void *block, void*) noexcept { al_free(block); }     \
-    void operator delete(void *block) noexcept { al_free(block); }
+    void operator delete(void *block) noexcept { al_free(block); }            \
+    void operator delete[](void *block, void*) noexcept { al_free(block); }   \
+    void operator delete[](void *block) noexcept { al_free(block); }
 
-struct FamCount { size_t mCount; };
+enum FamCount : size_t { };
 
 #define DEF_FAM_NEWDEL(T, FamMem)                                             \
     static constexpr size_t Sizeof(size_t count) noexcept                     \
-    { return decltype(FamMem)::Sizeof(count, offsetof(T, FamMem)); }          \
+    {                                                                         \
+        static_assert(&Sizeof == &T::Sizeof,                                  \
+            "Incorrect container type specified");                            \
+        return std::max(decltype(FamMem)::Sizeof(count, offsetof(T, FamMem)), \
+            sizeof(T));                                                       \
+    }                                                                         \
                                                                               \
-    void *operator new(size_t /*size*/, FamCount fam)                         \
+    void *operator new(size_t /*size*/, FamCount count)                       \
     {                                                                         \
-        if(void *ret{al_malloc(alignof(T), T::Sizeof(fam.mCount))})           \
+        if(void *ret{al_malloc(alignof(T), T::Sizeof(count))})                \
             return ret;                                                       \
         throw std::bad_alloc();                                               \
     }                                                                         \
+    void *operator new[](size_t /*size*/) = delete;                           \
     void operator delete(void *block, FamCount) { al_free(block); }           \
-    void operator delete(void *block) noexcept { al_free(block); }
+    void operator delete(void *block) noexcept { al_free(block); }            \
+    void operator delete[](void* /*block*/) = delete;
 
 
 namespace al {
 
-#define REQUIRES(...) typename std::enable_if<(__VA_ARGS__),int>::type = 0
-
-template<typename T, std::size_t alignment=alignof(T)>
+template<typename T, std::size_t Align=alignof(T)>
 struct allocator {
+    static constexpr std::size_t alignment{std::max(Align, alignof(T))};
+
     using value_type = T;
     using reference = T&;
     using const_reference = const T&;
@@ -65,52 +87,64 @@ struct allocator {
 
     template<typename U>
     struct rebind {
-        using other = allocator<U, (alignment<alignof(U))?alignof(U):alignment>;
+        using other = allocator<U, Align>;
     };
 
-    allocator() = default;
+    constexpr explicit allocator() noexcept = default;
     template<typename U, std::size_t N>
-    constexpr allocator(const allocator<U,N>&) noexcept { }
+    constexpr explicit allocator(const allocator<U,N>&) noexcept { }
 
     T *allocate(std::size_t n)
     {
         if(n > std::numeric_limits<std::size_t>::max()/sizeof(T)) throw std::bad_alloc();
-        if(auto p = static_cast<T*>(al_malloc(alignment, n*sizeof(T)))) return p;
+        if(auto p = al_malloc(alignment, n*sizeof(T))) return static_cast<T*>(p);
         throw std::bad_alloc();
     }
     void deallocate(T *p, std::size_t) noexcept { al_free(p); }
 };
 template<typename T, std::size_t N, typename U, std::size_t M>
-bool operator==(const allocator<T,N>&, const allocator<U,M>&) noexcept { return true; }
+constexpr bool operator==(const allocator<T,N>&, const allocator<U,M>&) noexcept { return true; }
 template<typename T, std::size_t N, typename U, std::size_t M>
-bool operator!=(const allocator<T,N>&, const allocator<U,M>&) noexcept { return false; }
+constexpr bool operator!=(const allocator<T,N>&, const allocator<U,M>&) noexcept { return false; }
 
-template<size_t alignment, typename T>
-inline T* assume_aligned(T *ptr) noexcept
+
+template<typename T>
+constexpr T *to_address(T *p) noexcept
 {
-    static_assert((alignment & (alignment-1)) == 0, "alignment must be a power of 2");
-#ifdef __GNUC__
-    return static_cast<T*>(__builtin_assume_aligned(ptr, alignment));
-#elif defined(_MSC_VER)
-    auto ptrval = reinterpret_cast<uintptr_t>(ptr);
-    if((ptrval&(alignment-1)) != 0) __assume(0);
-    return reinterpret_cast<T*>(ptrval);
-#else
-    return ptr;
-#endif
+    static_assert(!std::is_function<T>::value, "Can't be a function type");
+    return p;
 }
 
+template<typename T>
+constexpr auto to_address(const T &p) noexcept
+{ return to_address(p.operator->()); }
+
+
+template<typename T, typename ...Args>
+constexpr T* construct_at(T *ptr, Args&& ...args)
+    noexcept(std::is_nothrow_constructible<T, Args...>::value)
+{ return ::new(static_cast<void*>(ptr)) T{std::forward<Args>(args)...}; }
+
 /* At least VS 2015 complains that 'ptr' is unused when the given type's
  * destructor is trivial (a no-op). So disable that warning for this call.
  */
 DIAGNOSTIC_PUSH
 msc_pragma(warning(disable : 4100))
 template<typename T>
-inline void destroy_at(T *ptr) { ptr->~T(); }
+constexpr std::enable_if_t<!std::is_array<T>::value>
+destroy_at(T *ptr) noexcept(std::is_nothrow_destructible<T>::value)
+{ ptr->~T(); }
 DIAGNOSTIC_POP
+template<typename T>
+constexpr std::enable_if_t<std::is_array<T>::value>
+destroy_at(T *ptr) noexcept(std::is_nothrow_destructible<std::remove_all_extents_t<T>>::value)
+{
+    for(auto &elem : *ptr)
+        al::destroy_at(std::addressof(elem));
+}
 
 template<typename T>
-inline void destroy(T first, const T end)
+constexpr void destroy(T first, T end) noexcept(noexcept(al::destroy_at(std::addressof(*first))))
 {
     while(first != end)
     {
@@ -119,8 +153,9 @@ inline void destroy(T first, const T end)
     }
 }
 
-template<typename T, typename N, REQUIRES(std::is_integral<N>::value)>
-inline T destroy_n(T first, N count)
+template<typename T, typename N>
+constexpr std::enable_if_t<std::is_integral<N>::value,T>
+destroy_n(T first, N count) noexcept(noexcept(al::destroy_at(std::addressof(*first))))
 {
     if(count != 0)
     {
@@ -133,26 +168,9 @@ inline T destroy_n(T first, N count)
 }
 
 
-template<typename T>
-inline void uninitialized_default_construct(T first, const T last)
-{
-    using ValueT = typename std::iterator_traits<T>::value_type;
-    T current{first};
-    try {
-        while(current != last)
-        {
-            ::new (static_cast<void*>(std::addressof(*current))) ValueT;
-            ++current;
-        }
-    }
-    catch(...) {
-        destroy(first, current);
-        throw;
-    }
-}
-
-template<typename T, typename N, REQUIRES(std::is_integral<N>::value)>
-inline T uninitialized_default_construct_n(T first, N count)
+template<typename T, typename N>
+inline std::enable_if_t<std::is_integral<N>::value,
+T> uninitialized_default_construct_n(T first, N count)
 {
     using ValueT = typename std::iterator_traits<T>::value_type;
     T current{first};
@@ -160,12 +178,12 @@ inline T uninitialized_default_construct_n(T first, N count)
     {
         try {
             do {
-                ::new (static_cast<void*>(std::addressof(*current))) ValueT;
+                ::new(static_cast<void*>(std::addressof(*current))) ValueT;
                 ++current;
             } while(--count);
         }
         catch(...) {
-            destroy(first, current);
+            al::destroy(first, current);
             throw;
         }
     }
@@ -173,56 +191,52 @@ inline T uninitialized_default_construct_n(T first, N count)
 }
 
 
-template<typename T0, typename T1>
-inline T1 uninitialized_move(T0 first, const T0 last, const T1 output)
-{
-    using ValueT = typename std::iterator_traits<T1>::value_type;
-    T1 current{output};
-    try {
-        while(first != last)
-        {
-            ::new (static_cast<void*>(std::addressof(*current))) ValueT{std::move(*first)};
-            ++current;
-            ++first;
-        }
-    }
-    catch(...) {
-        destroy(output, current);
-        throw;
-    }
-    return current;
-}
+/* Storage for flexible array data. This is trivially destructible if type T is
+ * trivially destructible.
+ */
+template<typename T, size_t alignment, bool = std::is_trivially_destructible<T>::value>
+struct FlexArrayStorage {
+    const size_t mSize;
+    union {
+        char mDummy;
+        alignas(alignment) T mArray[1];
+    };
 
-template<typename T0, typename N, typename T1, REQUIRES(std::is_integral<N>::value)>
-inline T1 uninitialized_move_n(T0 first, N count, const T1 output)
-{
-    using ValueT = typename std::iterator_traits<T1>::value_type;
-    T1 current{output};
-    if(count != 0)
+    static constexpr size_t Sizeof(size_t count, size_t base=0u) noexcept
     {
-        try {
-            do {
-                ::new (static_cast<void*>(std::addressof(*current))) ValueT{std::move(*first)};
-                ++current;
-                ++first;
-            } while(--count);
-        }
-        catch(...) {
-            destroy(output, current);
-            throw;
-        }
+        const size_t len{sizeof(T)*count};
+        return std::max(offsetof(FlexArrayStorage,mArray)+len, sizeof(FlexArrayStorage)) + base;
     }
-    return current;
-}
 
+    FlexArrayStorage(size_t size) : mSize{size}
+    { al::uninitialized_default_construct_n(mArray, mSize); }
+    ~FlexArrayStorage() = default;
 
-/* std::make_unique was added with C++14, so until we rely on that, make our
- * own version.
- */
-template<typename T, typename ...ArgsT>
-std::unique_ptr<T> make_unique(ArgsT&&...args)
-{ return std::unique_ptr<T>{new T{std::forward<ArgsT>(args)...}}; }
+    FlexArrayStorage(const FlexArrayStorage&) = delete;
+    FlexArrayStorage& operator=(const FlexArrayStorage&) = delete;
+};
+
+template<typename T, size_t alignment>
+struct FlexArrayStorage<T,alignment,false> {
+    const size_t mSize;
+    union {
+        char mDummy;
+        alignas(alignment) T mArray[1];
+    };
+
+    static constexpr size_t Sizeof(size_t count, size_t base) noexcept
+    {
+        const size_t len{sizeof(T)*count};
+        return std::max(offsetof(FlexArrayStorage,mArray)+len, sizeof(FlexArrayStorage)) + base;
+    }
 
+    FlexArrayStorage(size_t size) : mSize{size}
+    { al::uninitialized_default_construct_n(mArray, mSize); }
+    ~FlexArrayStorage() { al::destroy_n(mArray, mSize); }
+
+    FlexArrayStorage(const FlexArrayStorage&) = delete;
+    FlexArrayStorage& operator=(const FlexArrayStorage&) = delete;
+};
 
 /* A flexible array type. Used either standalone or at the end of a parent
  * struct, with placement new, to have a run-time-sized array that's embedded
@@ -231,7 +245,7 @@ std::unique_ptr<T> make_unique(ArgsT&&...args)
 template<typename T, size_t alignment=alignof(T)>
 struct FlexArray {
     using element_type = T;
-    using value_type = typename std::remove_cv<T>::type;
+    using value_type = std::remove_cv_t<T>;
     using index_type = size_t;
     using difference_type = ptrdiff_t;
 
@@ -245,53 +259,42 @@ struct FlexArray {
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
+    using Storage_t_ = FlexArrayStorage<element_type,alignment>;
 
-    const index_type mSize;
-DIAGNOSTIC_PUSH
-std_pragma("GCC diagnostic ignored \"-Wpedantic\"")
-msc_pragma(warning(disable : 4200))
-    alignas(alignment) element_type mArray[0];
-DIAGNOSTIC_POP
+    Storage_t_ mStore;
 
+    static constexpr index_type Sizeof(index_type count, index_type base=0u) noexcept
+    { return Storage_t_::Sizeof(count, base); }
     static std::unique_ptr<FlexArray> Create(index_type count)
     {
         void *ptr{al_calloc(alignof(FlexArray), Sizeof(count))};
-        return std::unique_ptr<FlexArray>{new (ptr) FlexArray{count}};
-    }
-    static constexpr index_type Sizeof(index_type count, index_type base=0u) noexcept
-    {
-        return base +
-            std::max<index_type>(offsetof(FlexArray, mArray) + sizeof(T)*count, sizeof(FlexArray));
+        return std::unique_ptr<FlexArray>{al::construct_at(static_cast<FlexArray*>(ptr), count)};
     }
 
-    FlexArray(index_type size) : mSize{size}
-    { uninitialized_default_construct_n(mArray, mSize); }
-    ~FlexArray() { destroy_n(mArray, mSize); }
+    FlexArray(index_type size) : mStore{size} { }
+    ~FlexArray() = default;
 
-    FlexArray(const FlexArray&) = delete;
-    FlexArray& operator=(const FlexArray&) = delete;
+    index_type size() const noexcept { return mStore.mSize; }
+    bool empty() const noexcept { return mStore.mSize == 0; }
 
-    index_type size() const noexcept { return mSize; }
-    bool empty() const noexcept { return mSize == 0; }
+    pointer data() noexcept { return mStore.mArray; }
+    const_pointer data() const noexcept { return mStore.mArray; }
 
-    pointer data() noexcept { return mArray; }
-    const_pointer data() const noexcept { return mArray; }
+    reference operator[](index_type i) noexcept { return mStore.mArray[i]; }
+    const_reference operator[](index_type i) const noexcept { return mStore.mArray[i]; }
 
-    reference operator[](index_type i) noexcept { return mArray[i]; }
-    const_reference operator[](index_type i) const noexcept { return mArray[i]; }
+    reference front() noexcept { return mStore.mArray[0]; }
+    const_reference front() const noexcept { return mStore.mArray[0]; }
 
-    reference front() noexcept { return mArray[0]; }
-    const_reference front() const noexcept { return mArray[0]; }
+    reference back() noexcept { return mStore.mArray[mStore.mSize-1]; }
+    const_reference back() const noexcept { return mStore.mArray[mStore.mSize-1]; }
 
-    reference back() noexcept { return mArray[mSize-1]; }
-    const_reference back() const noexcept { return mArray[mSize-1]; }
-
-    iterator begin() noexcept { return mArray; }
-    const_iterator begin() const noexcept { return mArray; }
-    const_iterator cbegin() const noexcept { return mArray; }
-    iterator end() noexcept { return mArray + mSize; }
-    const_iterator end() const noexcept { return mArray + mSize; }
-    const_iterator cend() const noexcept { return mArray + mSize; }
+    iterator begin() noexcept { return mStore.mArray; }
+    const_iterator begin() const noexcept { return mStore.mArray; }
+    const_iterator cbegin() const noexcept { return mStore.mArray; }
+    iterator end() noexcept { return mStore.mArray + mStore.mSize; }
+    const_iterator end() const noexcept { return mStore.mArray + mStore.mSize; }
+    const_iterator cend() const noexcept { return mStore.mArray + mStore.mSize; }
 
     reverse_iterator rbegin() noexcept { return end(); }
     const_reverse_iterator rbegin() const noexcept { return end(); }
@@ -303,8 +306,6 @@ DIAGNOSTIC_POP
     DEF_PLACE_NEWDEL()
 };
 
-#undef REQUIRES
-
 } // namespace al
 
 #endif /* AL_MALLOC_H */
diff --git a/common/alnumbers.h b/common/alnumbers.h
new file mode 100644
index 00000000..37a55410
--- /dev/null
+++ b/common/alnumbers.h
@@ -0,0 +1,36 @@
+#ifndef COMMON_ALNUMBERS_H
+#define COMMON_ALNUMBERS_H
+
+#include <utility>
+
+namespace al {
+
+namespace numbers {
+
+namespace detail_ {
+    template<typename T>
+    using as_fp = std::enable_if_t<std::is_floating_point<T>::value, T>;
+} // detail_
+
+template<typename T>
+static constexpr auto pi_v = detail_::as_fp<T>(3.141592653589793238462643383279502884L);
+
+template<typename T>
+static constexpr auto inv_pi_v = detail_::as_fp<T>(0.318309886183790671537767526745028724L);
+
+template<typename T>
+static constexpr auto sqrt2_v = detail_::as_fp<T>(1.414213562373095048801688724209698079L);
+
+template<typename T>
+static constexpr auto sqrt3_v = detail_::as_fp<T>(1.732050807568877293527446341505872367L);
+
+static constexpr auto pi = pi_v<double>;
+static constexpr auto inv_pi = inv_pi_v<double>;
+static constexpr auto sqrt2 = sqrt2_v<double>;
+static constexpr auto sqrt3 = sqrt3_v<double>;
+
+} // namespace numbers
+
+} // namespace al
+
+#endif /* COMMON_ALNUMBERS_H */
diff --git a/common/alnumeric.h b/common/alnumeric.h
index 9158b764..d6919e40 100644
--- a/common/alnumeric.h
+++ b/common/alnumeric.h
@@ -1,6 +1,8 @@
 #ifndef AL_NUMERIC_H
 #define AL_NUMERIC_H
 
+#include <algorithm>
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #ifdef HAVE_INTRIN_H
@@ -10,6 +12,7 @@
 #include <xmmintrin.h>
 #endif
 
+#include "altraits.h"
 #include "opthelpers.h"
 
 
@@ -67,6 +70,19 @@ constexpr inline size_t clampz(size_t val, size_t min, size_t max) noexcept
 { return minz(max, maxz(min, val)); }
 
 
+constexpr inline float lerpf(float val1, float val2, float mu) noexcept
+{ return val1 + (val2-val1)*mu; }
+constexpr inline float cubic(float val1, float val2, float val3, float val4, float mu) noexcept
+{
+    const float mu2{mu*mu}, mu3{mu2*mu};
+    const float a0{-0.5f*mu3 +       mu2 + -0.5f*mu};
+    const float a1{ 1.5f*mu3 + -2.5f*mu2            + 1.0f};
+    const float a2{-1.5f*mu3 +  2.0f*mu2 +  0.5f*mu};
+    const float a3{ 0.5f*mu3 + -0.5f*mu2};
+    return val1*a0 + val2*a1 + val3*a2 + val4*a3;
+}
+
+
 /** Find the next power-of-2 for non-power-of-2 numbers. */
 inline uint32_t NextPowerOf2(uint32_t value) noexcept
 {
@@ -82,105 +98,20 @@ inline uint32_t NextPowerOf2(uint32_t value) noexcept
     return value+1;
 }
 
-/** Round up a value to the next multiple. */
-inline size_t RoundUp(size_t value, size_t r) noexcept
-{
-    value += r-1;
-    return value - (value%r);
-}
-
-
-/* Define CTZ macros (count trailing zeros), and POPCNT macros (population
- * count/count 1 bits), for 32- and 64-bit integers. The CTZ macros' results
- * are *UNDEFINED* if the value is 0.
+/**
+ * If the value is not already a multiple of r, round down to the next
+ * multiple.
  */
-#ifdef __GNUC__
-
-#define POPCNT32 __builtin_popcount
-#define CTZ32 __builtin_ctz
-#if SIZEOF_LONG == 8
-#define POPCNT64 __builtin_popcountl
-#define CTZ64 __builtin_ctzl
-#else
-#define POPCNT64 __builtin_popcountll
-#define CTZ64 __builtin_ctzll
-#endif
-
-#else
+template<typename T>
+constexpr T RoundDown(T value, al::type_identity_t<T> r) noexcept
+{ return value - (value%r); }
 
-/* There be black magics here. The popcnt method is derived from
- * https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
- * while the ctz-utilizing-popcnt algorithm is shown here
- * http://www.hackersdelight.org/hdcodetxt/ntz.c.txt
- * as the ntz2 variant. These likely aren't the most efficient methods, but
- * they're good enough if the GCC built-ins aren't available.
+/**
+ * If the value is not already a multiple of r, round up to the next multiple.
  */
-inline int fallback_popcnt32(uint32_t v)
-{
-    v = v - ((v >> 1) & 0x55555555u);
-    v = (v & 0x33333333u) + ((v >> 2) & 0x33333333u);
-    v = (v + (v >> 4)) & 0x0f0f0f0fu;
-    return (int)((v * 0x01010101u) >> 24);
-}
-#define POPCNT32 fallback_popcnt32
-inline int fallback_popcnt64(uint64_t v)
-{
-    v = v - ((v >> 1) & 0x5555555555555555_u64);
-    v = (v & 0x3333333333333333_u64) + ((v >> 2) & 0x3333333333333333_u64);
-    v = (v + (v >> 4)) & 0x0f0f0f0f0f0f0f0f_u64;
-    return (int)((v * 0x0101010101010101_u64) >> 56);
-}
-#define POPCNT64 fallback_popcnt64
-
-#if defined(HAVE_BITSCANFORWARD64_INTRINSIC)
-
-inline int msvc64_ctz32(uint32_t v)
-{
-    unsigned long idx = 32;
-    _BitScanForward(&idx, v);
-    return (int)idx;
-}
-#define CTZ32 msvc64_ctz32
-inline int msvc64_ctz64(uint64_t v)
-{
-    unsigned long idx = 64;
-    _BitScanForward64(&idx, v);
-    return (int)idx;
-}
-#define CTZ64 msvc64_ctz64
-
-#elif defined(HAVE_BITSCANFORWARD_INTRINSIC)
-
-inline int msvc_ctz32(uint32_t v)
-{
-    unsigned long idx = 32;
-    _BitScanForward(&idx, v);
-    return (int)idx;
-}
-#define CTZ32 msvc_ctz32
-inline int msvc_ctz64(uint64_t v)
-{
-    unsigned long idx = 64;
-    if(!_BitScanForward(&idx, (uint32_t)(v&0xffffffff)))
-    {
-        if(_BitScanForward(&idx, (uint32_t)(v>>32)))
-            idx += 32;
-    }
-    return (int)idx;
-}
-#define CTZ64 msvc_ctz64
-
-#else
-
-inline int fallback_ctz32(uint32_t value)
-{ return POPCNT32(~value & (value - 1)); }
-#define CTZ32 fallback_ctz32
-inline int fallback_ctz64(uint64_t value)
-{ return POPCNT64(~value & (value - 1)); }
-#define CTZ64 fallback_ctz64
-
-#endif
-#endif
+template<typename T>
+constexpr T RoundUp(T value, al::type_identity_t<T> r) noexcept
+{ return RoundDown(value + r-1, r); }
 
 
 /**
@@ -225,8 +156,9 @@ inline int float2int(float f) noexcept
 #if defined(HAVE_SSE_INTRINSICS)
     return _mm_cvtt_ss2si(_mm_set_ss(f));
 
-#elif ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) && \
-       !defined(__SSE_MATH__)) || (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP == 0)
+#elif (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP == 0) \
+    || ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) \
+        && !defined(__SSE_MATH__))
     int sign, shift, mant;
     union {
         float f;
@@ -238,11 +170,11 @@ inline int float2int(float f) noexcept
     shift = ((conv.i>>23)&0xff) - (127+23);
 
     /* Over/underflow */
-    if UNLIKELY(shift >= 31 || shift < -23)
+    if(shift >= 31 || shift < -23) UNLIKELY
         return 0;
 
     mant = (conv.i&0x7fffff) | 0x800000;
-    if LIKELY(shift < 0)
+    if(shift < 0) LIKELY
         return (mant >> -shift) * sign;
     return (mant << shift) * sign;
 
@@ -260,9 +192,9 @@ inline int double2int(double d) noexcept
 #if defined(HAVE_SSE_INTRINSICS)
     return _mm_cvttsd_si32(_mm_set_sd(d));
 
-#elif ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) && \
-       !defined(__SSE2_MATH__)) || (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP < 2)
-
+#elif (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP < 2) \
+    || ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) \
+        && !defined(__SSE2_MATH__))
     int sign, shift;
     int64_t mant;
     union {
@@ -275,11 +207,11 @@ inline int double2int(double d) noexcept
     shift = ((conv.i64 >> 52) & 0x7ff) - (1023 + 52);
 
     /* Over/underflow */
-    if UNLIKELY(shift >= 63 || shift < -52)
+    if(shift >= 63 || shift < -52) UNLIKELY
         return 0;
 
     mant = (conv.i64 & 0xfffffffffffff_i64) | 0x10000000000000_i64;
-    if LIKELY(shift < 0)
+    if(shift < 0) LIKELY
         return (int)(mant >> -shift) * sign;
     return (int)(mant << shift) * sign;
 
@@ -296,13 +228,19 @@ inline int double2int(double d) noexcept
  */
 inline float fast_roundf(float f) noexcept
 {
-#if (defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) && \
-    !defined(__SSE_MATH__)
+#if (defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__)) \
+    && !defined(__SSE_MATH__)
 
     float out;
     __asm__ __volatile__("frndint" : "=t"(out) : "0"(f));
     return out;
 
+#elif (defined(__GNUC__) || defined(__clang__)) && defined(__aarch64__)
+
+    float out;
+    __asm__ volatile("frintx %s0, %s1" : "=w"(out) : "w"(f));
+    return out;
+
 #else
 
     /* Integral limit, where sub-integral precision is not available for
@@ -322,7 +260,7 @@ inline float fast_roundf(float f) noexcept
     sign = (conv.i>>31)&0x01;
     expo = (conv.i>>23)&0xff;
 
-    if UNLIKELY(expo >= 150/*+23*/)
+    if(expo >= 150/*+23*/) UNLIKELY
     {
         /* An exponent (base-2) of 23 or higher is incapable of sub-integral
          * precision, so it's already an integral value. We don't need to worry
@@ -344,4 +282,27 @@ inline float fast_roundf(float f) noexcept
 #endif
 }
 
+
+template<typename T>
+constexpr const T& clamp(const T& value, const T& min_value, const T& max_value) noexcept
+{
+    return std::min(std::max(value, min_value), max_value);
+}
+
+// Converts level (mB) to gain.
+inline float level_mb_to_gain(float x)
+{
+    if(x <= -10'000.0f)
+        return 0.0f;
+    return std::pow(10.0f, x / 2'000.0f);
+}
+
+// Converts gain to level (mB).
+inline float gain_to_level_mb(float x)
+{
+    if (x <= 0.0f)
+        return -10'000.0f;
+    return maxf(std::log10(x) * 2'000.0f, -10'000.0f);
+}
+
 #endif /* AL_NUMERIC_H */
diff --git a/common/aloptional.h b/common/aloptional.h
index 269cba0e..6de16799 100644
--- a/common/aloptional.h
+++ b/common/aloptional.h
@@ -9,141 +9,345 @@
 
 namespace al {
 
-#define REQUIRES(...) bool rt_=true, typename std::enable_if<rt_ && (__VA_ARGS__),bool>::type = true
-
 struct nullopt_t { };
 struct in_place_t { };
 
 constexpr nullopt_t nullopt{};
 constexpr in_place_t in_place{};
 
+#define NOEXCEPT_AS(...)  noexcept(noexcept(__VA_ARGS__))
+
+namespace detail_ {
+/* Base storage struct for an optional. Defines a trivial destructor, for types
+ * that can be trivially destructed.
+ */
+template<typename T, bool = std::is_trivially_destructible<T>::value>
+struct optstore_base {
+    bool mHasValue{false};
+    union {
+        char mDummy{};
+        T mValue;
+    };
+
+    constexpr optstore_base() noexcept { }
+    template<typename ...Args>
+    constexpr explicit optstore_base(in_place_t, Args&& ...args)
+        noexcept(std::is_nothrow_constructible<T, Args...>::value)
+        : mHasValue{true}, mValue{std::forward<Args>(args)...}
+    { }
+    ~optstore_base() = default;
+};
+
+/* Specialization needing a non-trivial destructor. */
 template<typename T>
-class optional {
+struct optstore_base<T, false> {
     bool mHasValue{false};
     union {
-        char mDummy[sizeof(T)]{};
+        char mDummy{};
         T mValue;
     };
 
+    constexpr optstore_base() noexcept { }
+    template<typename ...Args>
+    constexpr explicit optstore_base(in_place_t, Args&& ...args)
+        noexcept(std::is_nothrow_constructible<T, Args...>::value)
+        : mHasValue{true}, mValue{std::forward<Args>(args)...}
+    { }
+    ~optstore_base() { if(mHasValue) al::destroy_at(std::addressof(mValue)); }
+};
+
+/* Next level of storage, which defines helpers to construct and destruct the
+ * stored object.
+ */
+template<typename T>
+struct optstore_helper : public optstore_base<T> {
+    using optstore_base<T>::optstore_base;
+
     template<typename... Args>
-    void DoConstruct(Args&& ...args)
+    constexpr void construct(Args&& ...args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
     {
-        ::new (std::addressof(mValue)) T{std::forward<Args>(args)...};
-        mHasValue = true;
+        al::construct_at(std::addressof(this->mValue), std::forward<Args>(args)...);
+        this->mHasValue = true;
     }
 
-public:
-    using value_type = T;
-
-    optional() noexcept = default;
-    optional(nullopt_t) noexcept { }
-    template<REQUIRES(std::is_copy_constructible<T>::value)>
-    optional(const optional &rhs) { if(rhs) DoConstruct(*rhs); }
-    template<REQUIRES(std::is_move_constructible<T>::value)>
-    optional(optional&& rhs) { if(rhs) DoConstruct(std::move(*rhs)); }
-    template<typename... Args, REQUIRES(std::is_constructible<T, Args...>::value)>
-    explicit optional(in_place_t, Args&& ...args) : mHasValue{true}
-      , mValue{std::forward<Args>(args)...}
-    { }
-    template<typename U, typename... Args, REQUIRES(std::is_constructible<T, std::initializer_list<U>&, Args...>::value)>
-    explicit optional(in_place_t, std::initializer_list<U> il, Args&& ...args)
-      : mHasValue{true}, mValue{il, std::forward<Args>(args)...}
-    { }
-    template<typename U=value_type, REQUIRES(std::is_constructible<T, U&&>::value &&
-        !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
-        !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
-        std::is_constructible<U&&, T>::value)>
-    constexpr explicit optional(U&& value) : mHasValue{true}, mValue{std::forward<U>(value)}
-    { }
-    template<typename U=value_type, REQUIRES(std::is_constructible<T, U&&>::value &&
-        !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
-        !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
-        !std::is_constructible<U&&, T>::value)>
-    constexpr optional(U&& value) : mHasValue{true}, mValue{std::forward<U>(value)}
-    { }
-    ~optional() { if(mHasValue) al::destroy_at(std::addressof(mValue)); }
+    constexpr void reset() noexcept
+    {
+        if(this->mHasValue)
+            al::destroy_at(std::addressof(this->mValue));
+        this->mHasValue = false;
+    }
 
-    optional& operator=(nullopt_t) noexcept { reset(); return *this; }
-    template<REQUIRES(std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value)>
-    optional& operator=(const optional &rhs)
+    constexpr void assign(const optstore_helper &rhs)
+        noexcept(std::is_nothrow_copy_constructible<T>::value
+            && std::is_nothrow_copy_assignable<T>::value)
     {
-        if(!rhs)
-            reset();
-        else if(*this)
-            mValue = *rhs;
+        if(!rhs.mHasValue)
+            this->reset();
+        else if(this->mHasValue)
+            this->mValue = rhs.mValue;
         else
-            DoConstruct(*rhs);
-        return *this;
+            this->construct(rhs.mValue);
     }
-    template<REQUIRES(std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
-    optional& operator=(optional&& rhs)
+
+    constexpr void assign(optstore_helper&& rhs)
+        noexcept(std::is_nothrow_move_constructible<T>::value
+            && std::is_nothrow_move_assignable<T>::value)
     {
-        if(!rhs)
-            reset();
-        else if(*this)
-            mValue = std::move(*rhs);
+        if(!rhs.mHasValue)
+            this->reset();
+        else if(this->mHasValue)
+            this->mValue = std::move(rhs.mValue);
         else
-            DoConstruct(std::move(*rhs));
-        return *this;
+            this->construct(std::move(rhs.mValue));
     }
-    template<typename U=T, REQUIRES(std::is_constructible<T, U>::value &&
-        std::is_assignable<T&, U>::value &&
-        !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
-        (!std::is_same<typename std::decay<U>::type, T>::value ||
-        !std::is_scalar<U>::value))>
-    optional& operator=(U&& rhs)
+};
+
+/* Define copy and move constructors and assignment operators, which may or may
+ * not be trivial.
+ */
+template<typename T, bool trivial_copy = std::is_trivially_copy_constructible<T>::value,
+    bool trivial_move = std::is_trivially_move_constructible<T>::value,
+    /* Trivial assignment is dependent on trivial construction+destruction. */
+    bool = trivial_copy && std::is_trivially_copy_assignable<T>::value
+        && std::is_trivially_destructible<T>::value,
+    bool = trivial_move && std::is_trivially_move_assignable<T>::value
+        && std::is_trivially_destructible<T>::value>
+struct optional_storage;
+
+/* Some versions of GCC have issues with 'this' in the following noexcept(...)
+ * statements, so this macro is a workaround.
+ */
+#define _this std::declval<optional_storage*>()
+
+/* Completely trivial. */
+template<typename T>
+struct optional_storage<T, true, true, true, true> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage&) = default;
+    constexpr optional_storage& operator=(optional_storage&&) = default;
+};
+
+/* Non-trivial move assignment. */
+template<typename T>
+struct optional_storage<T, true, true, true, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage&) = default;
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+/* Non-trivial move construction. */
+template<typename T>
+struct optional_storage<T, true, false, true, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&& rhs) NOEXCEPT_AS(_this->construct(std::move(rhs.mValue)))
+    { if(rhs.mHasValue) this->construct(std::move(rhs.mValue)); }
+    constexpr optional_storage& operator=(const optional_storage&) = default;
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+/* Non-trivial copy assignment. */
+template<typename T>
+struct optional_storage<T, true, true, false, true> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&&) = default;
+};
+
+/* Non-trivial copy construction. */
+template<typename T>
+struct optional_storage<T, false, true, false, true> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage &rhs) NOEXCEPT_AS(_this->construct(rhs.mValue))
+    { if(rhs.mHasValue) this->construct(rhs.mValue); }
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&&) = default;
+};
+
+/* Non-trivial assignment. */
+template<typename T>
+struct optional_storage<T, true, true, false, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+/* Non-trivial assignment, non-trivial move construction. */
+template<typename T>
+struct optional_storage<T, true, false, false, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage&) = default;
+    constexpr optional_storage(optional_storage&& rhs) NOEXCEPT_AS(_this->construct(std::move(rhs.mValue)))
+    { if(rhs.mHasValue) this->construct(std::move(rhs.mValue)); }
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+/* Non-trivial assignment, non-trivial copy construction. */
+template<typename T>
+struct optional_storage<T, false, true, false, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage &rhs) NOEXCEPT_AS(_this->construct(rhs.mValue))
+    { if(rhs.mHasValue) this->construct(rhs.mValue); }
+    constexpr optional_storage(optional_storage&&) = default;
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+/* Completely non-trivial. */
+template<typename T>
+struct optional_storage<T, false, false, false, false> : public optstore_helper<T> {
+    using optstore_helper<T>::optstore_helper;
+    constexpr optional_storage() noexcept = default;
+    constexpr optional_storage(const optional_storage &rhs) NOEXCEPT_AS(_this->construct(rhs.mValue))
+    { if(rhs.mHasValue) this->construct(rhs.mValue); }
+    constexpr optional_storage(optional_storage&& rhs) NOEXCEPT_AS(_this->construct(std::move(rhs.mValue)))
+    { if(rhs.mHasValue) this->construct(std::move(rhs.mValue)); }
+    constexpr optional_storage& operator=(const optional_storage &rhs) NOEXCEPT_AS(_this->assign(rhs))
+    { this->assign(rhs); return *this; }
+    constexpr optional_storage& operator=(optional_storage&& rhs) NOEXCEPT_AS(_this->assign(std::move(rhs)))
+    { this->assign(std::move(rhs)); return *this; }
+};
+
+#undef _this
+
+} // namespace detail_
+
+#define REQUIRES(...) std::enable_if_t<(__VA_ARGS__),bool> = true
+
+template<typename T>
+class optional {
+    using storage_t = detail_::optional_storage<T>;
+
+    storage_t mStore{};
+
+public:
+    using value_type = T;
+
+    constexpr optional() = default;
+    constexpr optional(const optional&) = default;
+    constexpr optional(optional&&) = default;
+    constexpr optional(nullopt_t) noexcept { }
+    template<typename ...Args>
+    constexpr explicit optional(in_place_t, Args&& ...args)
+        NOEXCEPT_AS(storage_t{al::in_place, std::forward<Args>(args)...})
+        : mStore{al::in_place, std::forward<Args>(args)...}
+    { }
+    template<typename U, REQUIRES(std::is_constructible<T, U&&>::value
+        && !std::is_same<std::decay_t<U>, al::in_place_t>::value
+        && !std::is_same<std::decay_t<U>, optional<T>>::value
+        && std::is_convertible<U&&, T>::value)>
+    constexpr optional(U&& rhs) NOEXCEPT_AS(storage_t{al::in_place, std::forward<U>(rhs)})
+        : mStore{al::in_place, std::forward<U>(rhs)}
+    { }
+    template<typename U, REQUIRES(std::is_constructible<T, U&&>::value
+        && !std::is_same<std::decay_t<U>, al::in_place_t>::value
+        && !std::is_same<std::decay_t<U>, optional<T>>::value
+        && !std::is_convertible<U&&, T>::value)>
+    constexpr explicit optional(U&& rhs) NOEXCEPT_AS(storage_t{al::in_place, std::forward<U>(rhs)})
+        : mStore{al::in_place, std::forward<U>(rhs)}
+    { }
+    ~optional() = default;
+
+    constexpr optional& operator=(const optional&) = default;
+    constexpr optional& operator=(optional&&) = default;
+    constexpr optional& operator=(nullopt_t) noexcept { mStore.reset(); return *this; }
+    template<typename U=T>
+    constexpr std::enable_if_t<std::is_constructible<T, U>::value
+        && std::is_assignable<T&, U>::value
+        && !std::is_same<std::decay_t<U>, optional<T>>::value
+        && (!std::is_same<std::decay_t<U>, T>::value || !std::is_scalar<U>::value),
+    optional&> operator=(U&& rhs)
     {
-        if(*this)
-            mValue = std::forward<U>(rhs);
+        if(mStore.mHasValue)
+            mStore.mValue = std::forward<U>(rhs);
         else
-            DoConstruct(std::forward<U>(rhs));
+            mStore.construct(std::forward<U>(rhs));
         return *this;
     }
 
-    const T* operator->() const { return std::addressof(mValue); }
-    T* operator->() { return std::addressof(mValue); }
-    const T& operator*() const& { return mValue; }
-    T& operator*() & { return mValue; }
-    const T&& operator*() const&& { return std::move(mValue); }
-    T&& operator*() && { return std::move(mValue); }
+    constexpr const T* operator->() const { return std::addressof(mStore.mValue); }
+    constexpr T* operator->() { return std::addressof(mStore.mValue); }
+    constexpr const T& operator*() const& { return mStore.mValue; }
+    constexpr T& operator*() & { return mStore.mValue; }
+    constexpr const T&& operator*() const&& { return std::move(mStore.mValue); }
+    constexpr T&& operator*() && { return std::move(mStore.mValue); }
 
-    operator bool() const noexcept { return mHasValue; }
-    bool has_value() const noexcept { return mHasValue; }
+    constexpr explicit operator bool() const noexcept { return mStore.mHasValue; }
+    constexpr bool has_value() const noexcept { return mStore.mHasValue; }
 
-    T& value() & { return mValue; }
-    const T& value() const& { return mValue; }
-    T&& value() && { return std::move(mValue); }
-    const T&& value() const&& { return std::move(mValue); }
+    constexpr T& value() & { return mStore.mValue; }
+    constexpr const T& value() const& { return mStore.mValue; }
+    constexpr T&& value() && { return std::move(mStore.mValue); }
+    constexpr const T&& value() const&& { return std::move(mStore.mValue); }
 
     template<typename U>
-    T value_or(U&& defval) const&
-    { return bool{*this} ? **this : static_cast<T>(std::forward<U>(defval)); }
+    constexpr T value_or(U&& defval) const&
+    { return bool(*this) ? **this : static_cast<T>(std::forward<U>(defval)); }
     template<typename U>
-    T value_or(U&& defval) &&
-    { return bool{*this} ? std::move(**this) : static_cast<T>(std::forward<U>(defval)); }
+    constexpr T value_or(U&& defval) &&
+    { return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(defval)); }
 
-    void reset() noexcept
+    template<typename ...Args>
+    constexpr T& emplace(Args&& ...args)
     {
-        if(mHasValue)
-            al::destroy_at(std::addressof(mValue));
-        mHasValue = false;
+        mStore.reset();
+        mStore.construct(std::forward<Args>(args)...);
+        return mStore.mValue;
     }
+    template<typename U, typename ...Args>
+    constexpr std::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
+    T&> emplace(std::initializer_list<U> il, Args&& ...args)
+    {
+        mStore.reset();
+        mStore.construct(il, std::forward<Args>(args)...);
+        return mStore.mValue;
+    }
+
+    constexpr void reset() noexcept { mStore.reset(); }
 };
 
 template<typename T>
-inline optional<typename std::decay<T>::type> make_optional(T&& arg)
-{ return optional<typename std::decay<T>::type>{in_place, std::forward<T>(arg)}; }
+constexpr optional<std::decay_t<T>> make_optional(T&& arg)
+{ return optional<std::decay_t<T>>{in_place, std::forward<T>(arg)}; }
 
 template<typename T, typename... Args>
-inline optional<T> make_optional(Args&& ...args)
+constexpr optional<T> make_optional(Args&& ...args)
 { return optional<T>{in_place, std::forward<Args>(args)...}; }
 
 template<typename T, typename U, typename... Args>
-inline optional<T> make_optional(std::initializer_list<U> il, Args&& ...args)
+constexpr optional<T> make_optional(std::initializer_list<U> il, Args&& ...args)
 { return optional<T>{in_place, il, std::forward<Args>(args)...}; }
 
 #undef REQUIRES
-
+#undef NOEXCEPT_AS
 } // namespace al
 
-#endif /* AL_SPAN_H */
+#endif /* AL_OPTIONAL_H */
diff --git a/common/alspan.h b/common/alspan.h
index cb34d410..1d6cdfe5 100644
--- a/common/alspan.h
+++ b/common/alspan.h
@@ -7,31 +7,26 @@
 #include <iterator>
 #include <type_traits>
 
-namespace al {
+#include "almalloc.h"
+#include "altraits.h"
 
-template<typename T>
-constexpr auto size(T &cont) -> decltype(cont.size())
-{ return cont.size(); }
+namespace al {
 
 template<typename T>
-constexpr auto size(const T &cont) -> decltype(cont.size())
+constexpr auto size(const T &cont) noexcept(noexcept(cont.size())) -> decltype(cont.size())
 { return cont.size(); }
 
 template<typename T, size_t N>
-constexpr size_t size(T (&)[N]) noexcept
+constexpr size_t size(const T (&)[N]) noexcept
 { return N; }
 
-template<typename T>
-constexpr size_t size(std::initializer_list<T> list) noexcept
-{ return list.size(); }
-
 
 template<typename T>
-constexpr auto data(T &cont) -> decltype(cont.data())
+constexpr auto data(T &cont) noexcept(noexcept(cont.data())) -> decltype(cont.data())
 { return cont.data(); }
 
 template<typename T>
-constexpr auto data(const T &cont) -> decltype(cont.data())
+constexpr auto data(const T &cont) noexcept(noexcept(cont.data())) -> decltype(cont.data())
 { return cont.data(); }
 
 template<typename T, size_t N>
@@ -43,53 +38,52 @@ constexpr const T* data(std::initializer_list<T> list) noexcept
 { return list.begin(); }
 
 
-template<typename T, size_t E=static_cast<size_t>(-1)>
+constexpr size_t dynamic_extent{static_cast<size_t>(-1)};
+
+template<typename T, size_t E=dynamic_extent>
 class span;
 
 namespace detail_ {
     template<typename... Ts>
-    struct make_void { using type = void; };
-    template<typename... Ts>
-    using void_t = typename make_void<Ts...>::type;
+    using void_t = void;
 
     template<typename T>
     struct is_span_ : std::false_type { };
     template<typename T, size_t E>
     struct is_span_<span<T,E>> : std::true_type { };
     template<typename T>
-    using is_span = is_span_<typename std::remove_cv<T>::type>;
+    constexpr bool is_span_v = is_span_<std::remove_cv_t<T>>::value;
 
     template<typename T>
     struct is_std_array_ : std::false_type { };
     template<typename T, size_t N>
     struct is_std_array_<std::array<T,N>> : std::true_type { };
     template<typename T>
-    using is_std_array = is_std_array_<typename std::remove_cv<T>::type>;
+    constexpr bool is_std_array_v = is_std_array_<std::remove_cv_t<T>>::value;
 
     template<typename T, typename = void>
-    struct has_size_and_data : std::false_type { };
+    constexpr bool has_size_and_data = false;
     template<typename T>
-    struct has_size_and_data<T,
+    constexpr bool has_size_and_data<T,
         void_t<decltype(al::size(std::declval<T>())), decltype(al::data(std::declval<T>()))>>
-        : std::true_type { };
+        = true;
 
-    template<typename T>
-    using remove_pointer_t = typename std::remove_pointer<T>::type;
+    template<typename T, typename U>
+    constexpr bool is_array_compatible = std::is_convertible<T(*)[],U(*)[]>::value;
+
+    template<typename C, typename T>
+    constexpr bool is_valid_container = !is_span_v<C> && !is_std_array_v<C>
+        && !std::is_array<C>::value && has_size_and_data<C>
+        && is_array_compatible<std::remove_pointer_t<decltype(al::data(std::declval<C&>()))>,T>;
 } // namespace detail_
 
-#define REQUIRES(...) bool rt_=true, typename std::enable_if<rt_ && (__VA_ARGS__),bool>::type = true
-#define IS_VALID_CONTAINER(C)                                                 \
-    !detail_::is_span<C>::value && !detail_::is_std_array<C>::value &&        \
-    !std::is_array<C>::value && detail_::has_size_and_data<C>::value &&       \
-    std::is_convertible<detail_::remove_pointer_t<decltype(al::data(std::declval<C&>()))>(*)[],element_type(*)[]>::value
+#define REQUIRES(...) std::enable_if_t<(__VA_ARGS__),bool> = true
 
 template<typename T, size_t E>
 class span {
-    static constexpr size_t dynamic_extent{static_cast<size_t>(-1)};
-
 public:
     using element_type = T;
-    using value_type = typename std::remove_cv<T>::type;
+    using value_type = std::remove_cv_t<T>;
     using index_type = size_t;
     using difference_type = ptrdiff_t;
 
@@ -105,23 +99,36 @@ public:
 
     static constexpr size_t extent{E};
 
-    template<REQUIRES(extent==0)>
+    template<bool is0=(extent == 0), REQUIRES(is0)>
     constexpr span() noexcept { }
-    constexpr span(pointer ptr, index_type /*count*/) : mData{ptr} { }
-    constexpr span(pointer first, pointer /*last*/) : mData{first} { }
-    constexpr span(element_type (&arr)[E]) noexcept : span{al::data(arr), al::size(arr)} { }
+    template<typename U>
+    constexpr explicit span(U iter, index_type) : mData{to_address(iter)} { }
+    template<typename U, typename V, REQUIRES(!std::is_convertible<V,size_t>::value)>
+    constexpr explicit span(U first, V) : mData{to_address(first)} { }
+
+    constexpr span(type_identity_t<element_type> (&arr)[E]) noexcept
+        : span{al::data(arr), al::size(arr)}
+    { }
     constexpr span(std::array<value_type,E> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
-    template<REQUIRES(std::is_const<element_type>::value)>
-    constexpr span(const std::array<value_type,E> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
-    template<typename U, REQUIRES(IS_VALID_CONTAINER(U))>
-    constexpr span(U &cont) : span{al::data(cont), al::size(cont)} { }
-    template<typename U, REQUIRES(IS_VALID_CONTAINER(const U))>
-    constexpr span(const U &cont) : span{al::data(cont), al::size(cont)} { }
-    template<typename U, REQUIRES(!std::is_same<element_type,U>::value && std::is_convertible<U(*)[],element_type(*)[]>::value)>
-    constexpr span(const span<U,E> &span_) noexcept : span{al::data(span_), al::size(span_)} { }
+    template<typename U=T, REQUIRES(std::is_const<U>::value)>
+    constexpr span(const std::array<value_type,E> &arr) noexcept
+      : span{al::data(arr), al::size(arr)}
+    { }
+
+    template<typename U, REQUIRES(detail_::is_valid_container<U, element_type>)>
+    constexpr explicit span(U&& cont) : span{al::data(cont), al::size(cont)} { }
+
+    template<typename U, index_type N, REQUIRES(!std::is_same<element_type,U>::value
+        && detail_::is_array_compatible<U,element_type> && N == dynamic_extent)>
+    constexpr explicit span(const span<U,N> &span_) noexcept
+        : span{al::data(span_), al::size(span_)}
+    { }
+    template<typename U, index_type N, REQUIRES(!std::is_same<element_type,U>::value
+        && detail_::is_array_compatible<U,element_type> && N == extent)>
+    constexpr span(const span<U,N> &span_) noexcept : span{al::data(span_), al::size(span_)} { }
     constexpr span(const span&) noexcept = default;
 
-    span& operator=(const span &rhs) noexcept = default;
+    constexpr span& operator=(const span &rhs) noexcept = default;
 
     constexpr reference front() const { return *mData; }
     constexpr reference back() const { return *(mData+E-1); }
@@ -137,10 +144,12 @@ public:
     constexpr const_iterator cbegin() const noexcept { return mData; }
     constexpr const_iterator cend() const noexcept { return mData+E; }
 
-    constexpr reverse_iterator rbegin() const noexcept { return end(); }
-    constexpr reverse_iterator rend() const noexcept { return begin(); }
-    constexpr const_reverse_iterator crbegin() const noexcept { return cend(); }
-    constexpr const_reverse_iterator crend() const noexcept { return cbegin(); }
+    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
+    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
+    constexpr const_reverse_iterator crbegin() const noexcept
+    { return const_reverse_iterator{cend()}; }
+    constexpr const_reverse_iterator crend() const noexcept
+    { return const_reverse_iterator{cbegin()}; }
 
     template<size_t C>
     constexpr span<element_type,C> first() const
@@ -156,12 +165,19 @@ public:
         return span<element_type,C>{mData+(E-C), C};
     }
 
-    template<size_t O, size_t C, size_t RealC=((C==dynamic_extent) ? E-O : C)>
-    constexpr span<element_type,RealC> subspan() const
+    template<size_t O, size_t C>
+    constexpr auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
     {
         static_assert(E >= O, "Offset exceeds extent");
-        static_assert(E-O >= RealC, "New size exceeds original capacity");
-        return span<element_type,RealC>{mData+O, RealC};
+        static_assert(E-O >= C, "New size exceeds original capacity");
+        return span<element_type,C>{mData+O, C};
+    }
+
+    template<size_t O, size_t C=dynamic_extent>
+    constexpr auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,E-O>>
+    {
+        static_assert(E >= O, "Offset exceeds extent");
+        return span<element_type,E-O>{mData+O, E-O};
     }
 
     /* NOTE: Can't declare objects of a specialized template class prior to
@@ -170,19 +186,18 @@ public:
      */
     constexpr span<element_type,dynamic_extent> first(size_t count) const;
     constexpr span<element_type,dynamic_extent> last(size_t count) const;
-    constexpr span<element_type,dynamic_extent> subspan(size_t offset, size_t count=dynamic_extent) const;
+    constexpr span<element_type,dynamic_extent> subspan(size_t offset,
+        size_t count=dynamic_extent) const;
 
 private:
     pointer mData{nullptr};
 };
 
 template<typename T>
-class span<T,static_cast<size_t>(-1)> {
-    static constexpr size_t dynamic_extent{static_cast<size_t>(-1)};
-
+class span<T,dynamic_extent> {
 public:
     using element_type = T;
-    using value_type = typename std::remove_cv<T>::type;
+    using value_type = std::remove_cv_t<T>;
     using index_type = size_t;
     using difference_type = ptrdiff_t;
 
@@ -196,26 +211,37 @@ public:
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-    static constexpr size_t extent{static_cast<size_t>(-1)};
+    static constexpr size_t extent{dynamic_extent};
 
     constexpr span() noexcept = default;
-    constexpr span(pointer ptr, index_type count) : mData{ptr}, mDataEnd{ptr+count} { }
-    constexpr span(pointer first, pointer last) : mData{first}, mDataEnd{last} { }
+    template<typename U>
+    constexpr span(U iter, index_type count)
+        : mData{to_address(iter)}, mDataEnd{to_address(iter)+count}
+    { }
+    template<typename U, typename V, REQUIRES(!std::is_convertible<V,size_t>::value)>
+    constexpr span(U first, V last) : span{to_address(first), static_cast<size_t>(last-first)}
+    { }
+
     template<size_t N>
-    constexpr span(element_type (&arr)[N]) noexcept : span{al::data(arr), al::size(arr)} { }
+    constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept
+        : span{al::data(arr), al::size(arr)}
+    { }
     template<size_t N>
     constexpr span(std::array<value_type,N> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
-    template<size_t N, REQUIRES(std::is_const<element_type>::value)>
-    constexpr span(const std::array<value_type,N> &arr) noexcept : span{al::data(arr), al::size(arr)} { }
-    template<typename U, REQUIRES(IS_VALID_CONTAINER(U))>
-    constexpr span(U &cont) : span{al::data(cont), al::size(cont)} { }
-    template<typename U, REQUIRES(IS_VALID_CONTAINER(const U))>
-    constexpr span(const U &cont) : span{al::data(cont), al::size(cont)} { }
-    template<typename U, size_t N, REQUIRES((!std::is_same<element_type,U>::value || extent != N) && std::is_convertible<U(*)[],element_type(*)[]>::value)>
+    template<size_t N, typename U=T, REQUIRES(std::is_const<U>::value)>
+    constexpr span(const std::array<value_type,N> &arr) noexcept
+      : span{al::data(arr), al::size(arr)}
+    { }
+
+    template<typename U, REQUIRES(detail_::is_valid_container<U, element_type>)>
+    constexpr span(U&& cont) : span{al::data(cont), al::size(cont)} { }
+
+    template<typename U, size_t N, REQUIRES((!std::is_same<element_type,U>::value || extent != N)
+        && detail_::is_array_compatible<U,element_type>)>
     constexpr span(const span<U,N> &span_) noexcept : span{al::data(span_), al::size(span_)} { }
     constexpr span(const span&) noexcept = default;
 
-    span& operator=(const span &rhs) noexcept = default;
+    constexpr span& operator=(const span &rhs) noexcept = default;
 
     constexpr reference front() const { return *mData; }
     constexpr reference back() const { return *(mDataEnd-1); }
@@ -232,10 +258,12 @@ public:
     constexpr const_iterator cbegin() const noexcept { return mData; }
     constexpr const_iterator cend() const noexcept { return mDataEnd; }
 
-    constexpr reverse_iterator rbegin() const noexcept { return end(); }
-    constexpr reverse_iterator rend() const noexcept { return begin(); }
-    constexpr const_reverse_iterator crbegin() const noexcept { return cend(); }
-    constexpr const_reverse_iterator crend() const noexcept { return cbegin(); }
+    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
+    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
+    constexpr const_reverse_iterator crbegin() const noexcept
+    { return const_reverse_iterator{cend()}; }
+    constexpr const_reverse_iterator crend() const noexcept
+    { return const_reverse_iterator{cbegin()}; }
 
     template<size_t C>
     constexpr span<element_type,C> first() const
@@ -251,9 +279,13 @@ public:
     constexpr span last(size_t count) const
     { return (count >= size()) ? *this : span{mDataEnd-count, mDataEnd}; }
 
+    template<size_t O, size_t C>
+    constexpr auto subspan() const -> std::enable_if_t<C!=dynamic_extent,span<element_type,C>>
+    { return span<element_type,C>{mData+O, C}; }
+
     template<size_t O, size_t C=dynamic_extent>
-    constexpr span<element_type,C> subspan() const
-    { return span<element_type,C>{mData+O, (C!=dynamic_extent) ? mData+C : mDataEnd}; }
+    constexpr auto subspan() const -> std::enable_if_t<C==dynamic_extent,span<element_type,C>>
+    { return span<element_type,C>{mData+O, mDataEnd}; }
 
     constexpr span subspan(size_t offset, size_t count=dynamic_extent) const
     {
@@ -282,14 +314,39 @@ constexpr inline auto span<T,E>::last(size_t count) const -> span<element_type,d
 }
 
 template<typename T, size_t E>
-constexpr inline auto span<T,E>::subspan(size_t offset, size_t count) const -> span<element_type,dynamic_extent>
+constexpr inline auto span<T,E>::subspan(size_t offset, size_t count) const
+    -> span<element_type,dynamic_extent>
 {
     return (offset > size()) ? span<element_type>{} :
         (count >= size()-offset) ? span<element_type>{mData+offset, mData+extent} :
         span<element_type>{mData+offset, mData+offset+count};
 }
 
-#undef IS_VALID_CONTAINER
+/* Helpers to deal with the lack of user-defined deduction guides (C++17). */
+template<typename T, typename U>
+constexpr auto as_span(T ptr, U count_or_end)
+{
+    using value_type = typename std::pointer_traits<T>::element_type;
+    return span<value_type>{ptr, count_or_end};
+}
+template<typename T, size_t N>
+constexpr auto as_span(T (&arr)[N]) noexcept { return span<T,N>{al::data(arr), al::size(arr)}; }
+template<typename T, size_t N>
+constexpr auto as_span(std::array<T,N> &arr) noexcept
+{ return span<T,N>{al::data(arr), al::size(arr)}; }
+template<typename T, size_t N>
+constexpr auto as_span(const std::array<T,N> &arr) noexcept
+{ return span<std::add_const_t<T>,N>{al::data(arr), al::size(arr)}; }
+template<typename U, REQUIRES(!detail_::is_span_v<U> && !detail_::is_std_array_v<U>
+    && !std::is_array<U>::value && detail_::has_size_and_data<U>)>
+constexpr auto as_span(U&& cont)
+{
+    using value_type = std::remove_pointer_t<decltype(al::data(std::declval<U&>()))>;
+    return span<value_type>{al::data(cont), al::size(cont)};
+}
+template<typename T, size_t N>
+constexpr auto as_span(span<T,N> span_) noexcept { return span_; }
+
 #undef REQUIRES
 
 } // namespace al
diff --git a/common/alstring.h b/common/alstring.h
index 194e54a1..6c5004ee 100644
--- a/common/alstring.h
+++ b/common/alstring.h
@@ -2,22 +2,11 @@
 #define AL_STRING_H
 
 #include <cstddef>
-#include <string>
-
-#include "almalloc.h"
+#include <cstring>
 
 
 namespace al {
 
-template<typename T, typename Tr=std::char_traits<T>>
-using basic_string = std::basic_string<T, Tr, al::allocator<T>>;
-
-using string = basic_string<char>;
-using wstring = basic_string<wchar_t>;
-using u16string = basic_string<char16_t>;
-using u32string = basic_string<char32_t>;
-
-
 /* These would be better served by using a string_view-like span/view with
  * case-insensitive char traits.
  */
diff --git a/common/altraits.h b/common/altraits.h
new file mode 100644
index 00000000..7ce0422e
--- /dev/null
+++ b/common/altraits.h
@@ -0,0 +1,14 @@
+#ifndef COMMON_ALTRAITS_H
+#define COMMON_ALTRAITS_H
+
+namespace al {
+
+template<typename T>
+struct type_identity { using type = T; };
+
+template<typename T>
+using type_identity_t = typename type_identity<T>::type;
+
+} // namespace al
+
+#endif /* COMMON_ALTRAITS_H */
diff --git a/common/comptr.h b/common/comptr.h
new file mode 100644
index 00000000..cdc6dec0
--- /dev/null
+++ b/common/comptr.h
@@ -0,0 +1,68 @@
+#ifndef COMMON_COMPTR_H
+#define COMMON_COMPTR_H
+
+#include <cstddef>
+#include <utility>
+
+#include "opthelpers.h"
+
+
+template<typename T>
+class ComPtr {
+    T *mPtr{nullptr};
+
+public:
+    ComPtr() noexcept = default;
+    ComPtr(const ComPtr &rhs) : mPtr{rhs.mPtr} { if(mPtr) mPtr->AddRef(); }
+    ComPtr(ComPtr&& rhs) noexcept : mPtr{rhs.mPtr} { rhs.mPtr = nullptr; }
+    ComPtr(std::nullptr_t) noexcept { }
+    explicit ComPtr(T *ptr) noexcept : mPtr{ptr} { }
+    ~ComPtr() { if(mPtr) mPtr->Release(); }
+
+    ComPtr& operator=(const ComPtr &rhs)
+    {
+        if(!rhs.mPtr)
+        {
+            if(mPtr)
+                mPtr->Release();
+            mPtr = nullptr;
+        }
+        else
+        {
+            rhs.mPtr->AddRef();
+            try {
+                if(mPtr)
+                    mPtr->Release();
+                mPtr = rhs.mPtr;
+            }
+            catch(...) {
+                rhs.mPtr->Release();
+                throw;
+            }
+        }
+        return *this;
+    }
+    ComPtr& operator=(ComPtr&& rhs)
+    {
+        if(&rhs != this) LIKELY
+        {
+            if(mPtr) mPtr->Release();
+            mPtr = std::exchange(rhs.mPtr, nullptr);
+        }
+        return *this;
+    }
+
+    explicit operator bool() const noexcept { return mPtr != nullptr; }
+
+    T& operator*() const noexcept { return *mPtr; }
+    T* operator->() const noexcept { return mPtr; }
+    T* get() const noexcept { return mPtr; }
+    T** getPtr() noexcept { return &mPtr; }
+
+    T* release() noexcept { return std::exchange(mPtr, nullptr); }
+
+    void swap(ComPtr &rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
+    void swap(ComPtr&& rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
+};
+
+#endif
diff --git a/common/endiantest.h b/common/endiantest.h
deleted file mode 100644
index 0a20eb91..00000000
--- a/common/endiantest.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef AL_ENDIANTEST_H
-#define AL_ENDIANTEST_H
-
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
-#define IS_LITTLE_ENDIAN (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#else
-static const union {
-    unsigned int u;
-    unsigned char b[sizeof(unsigned int)];
-} EndianTest = { 1 };
-#define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
-#endif
-
-#endif /* AL_ENDIANTEST_H */
diff --git a/common/intrusive_ptr.h b/common/intrusive_ptr.h
index 595c831d..27075347 100644
--- a/common/intrusive_ptr.h
+++ b/common/intrusive_ptr.h
@@ -1,6 +1,8 @@
 #ifndef INTRUSIVE_PTR_H
 #define INTRUSIVE_PTR_H
 
+#include <utility>
+
 #include "atomic.h"
 #include "opthelpers.h"
 
@@ -13,10 +15,10 @@ class intrusive_ref {
 
 public:
     unsigned int add_ref() noexcept { return IncrementRef(mRef); }
-    unsigned int release() noexcept
+    unsigned int dec_ref() noexcept
     {
         auto ref = DecrementRef(mRef);
-        if UNLIKELY(ref == 0)
+        if(ref == 0) UNLIKELY
             delete static_cast<T*>(this);
         return ref;
     }
@@ -56,43 +58,41 @@ public:
     { rhs.mPtr = nullptr; }
     intrusive_ptr(std::nullptr_t) noexcept { }
     explicit intrusive_ptr(T *ptr) noexcept : mPtr{ptr} { }
-    ~intrusive_ptr() { if(mPtr) mPtr->release(); }
+    ~intrusive_ptr() { if(mPtr) mPtr->dec_ref(); }
 
     intrusive_ptr& operator=(const intrusive_ptr &rhs) noexcept
     {
+        static_assert(noexcept(std::declval<T*>()->dec_ref()), "dec_ref must be noexcept");
+
         if(rhs.mPtr) rhs.mPtr->add_ref();
-        if(mPtr) mPtr->release();
+        if(mPtr) mPtr->dec_ref();
         mPtr = rhs.mPtr;
         return *this;
     }
     intrusive_ptr& operator=(intrusive_ptr&& rhs) noexcept
     {
-        if(mPtr)
-            mPtr->release();
-        mPtr = rhs.mPtr;
-        rhs.mPtr = nullptr;
+        if(&rhs != this) LIKELY
+        {
+            if(mPtr) mPtr->dec_ref();
+            mPtr = std::exchange(rhs.mPtr, nullptr);
+        }
         return *this;
     }
 
-    operator bool() const noexcept { return mPtr != nullptr; }
+    explicit operator bool() const noexcept { return mPtr != nullptr; }
 
     T& operator*() const noexcept { return *mPtr; }
     T* operator->() const noexcept { return mPtr; }
     T* get() const noexcept { return mPtr; }
 
-    void reset() noexcept
+    void reset(T *ptr=nullptr) noexcept
     {
         if(mPtr)
-            mPtr->release();
-        mPtr = nullptr;
+            mPtr->dec_ref();
+        mPtr = ptr;
     }
 
-    T* release() noexcept
-    {
-        T *ret{mPtr};
-        mPtr = nullptr;
-        return ret;
-    }
+    T* release() noexcept { return std::exchange(mPtr, nullptr); }
 
     void swap(intrusive_ptr &rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
     void swap(intrusive_ptr&& rhs) noexcept { std::swap(mPtr, rhs.mPtr); }
diff --git a/common/math_defs.h b/common/math_defs.h
deleted file mode 100644
index 0362a956..00000000
--- a/common/math_defs.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef AL_MATH_DEFS_H
-#define AL_MATH_DEFS_H
-
-#include <math.h>
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-constexpr inline float Deg2Rad(float x) noexcept { return x * static_cast<float>(M_PI/180.0); }
-constexpr inline float Rad2Deg(float x) noexcept { return x * static_cast<float>(180.0/M_PI); }
-
-namespace al {
-
-template<typename Real>
-struct MathDefs { };
-
-template<>
-struct MathDefs<float> {
-    static constexpr inline float Pi() noexcept { return static_cast<float>(M_PI); }
-    static constexpr inline float Tau() noexcept { return static_cast<float>(M_PI * 2.0); }
-};
-
-template<>
-struct MathDefs<double> {
-    static constexpr inline double Pi() noexcept { return M_PI; }
-    static constexpr inline double Tau() noexcept { return M_PI * 2.0; }
-};
-
-} // namespace al
-
-#endif /* AL_MATH_DEFS_H */
diff --git a/common/opthelpers.h b/common/opthelpers.h
index 58578c15..596c2455 100644
--- a/common/opthelpers.h
+++ b/common/opthelpers.h
@@ -1,39 +1,93 @@
 #ifndef OPTHELPERS_H
 #define OPTHELPERS_H
 
+#include <cstdint>
+#include <utility>
+#include <memory>
+
 #ifdef __has_builtin
 #define HAS_BUILTIN __has_builtin
 #else
 #define HAS_BUILTIN(x) (0)
 #endif
 
+#ifdef __has_cpp_attribute
+#define HAS_ATTRIBUTE __has_cpp_attribute
+#else
+#define HAS_ATTRIBUTE(x) (0)
+#endif
+
 #ifdef __GNUC__
-/* LIKELY optimizes the case where the condition is true. The condition is not
- * required to be true, but it can result in more optimal code for the true
- * path at the expense of a less optimal false path.
- */
-#define LIKELY(x) (__builtin_expect(!!(x), !false))
-/* The opposite of LIKELY, optimizing the case where the condition is false. */
-#define UNLIKELY(x) (__builtin_expect(!!(x), false))
-/* Unlike LIKELY, ASSUME requires the condition to be true or else it invokes
- * undefined behavior. It's essentially an assert without actually checking the
- * condition at run-time, allowing for stronger optimizations than LIKELY.
+#define force_inline [[gnu::always_inline]] inline
+#elif defined(_MSC_VER)
+#define force_inline __forceinline
+#else
+#define force_inline inline
+#endif
+
+/* Unlike the likely attribute, ASSUME requires the condition to be true or
+ * else it invokes undefined behavior. It's essentially an assert without
+ * actually checking the condition at run-time, allowing for stronger
+ * optimizations than the likely attribute.
  */
 #if HAS_BUILTIN(__builtin_assume)
 #define ASSUME __builtin_assume
+#elif defined(_MSC_VER)
+#define ASSUME __assume
+#elif __has_attribute(assume)
+#define ASSUME(x) [[assume(x)]]
+#elif HAS_BUILTIN(__builtin_unreachable)
+#define ASSUME(x) do { if(x) break; __builtin_unreachable(); } while(0)
+#else
+#define ASSUME(x) ((void)0)
+#endif
+
+/* This shouldn't be needed since unknown attributes are ignored, but older
+ * versions of GCC choke on the attribute syntax in certain situations.
+ */
+#if HAS_ATTRIBUTE(likely)
+#define LIKELY [[likely]]
+#define UNLIKELY [[unlikely]]
 #else
-#define ASSUME(x) do { if(!(x)) __builtin_unreachable(); } while(0)
+#define LIKELY
+#define UNLIKELY
 #endif
 
-#else /* __GNUC__ */
+namespace al {
 
-#define LIKELY(x) (!!(x))
-#define UNLIKELY(x) (!!(x))
-#ifdef _MSC_VER
-#define ASSUME __assume
+template<typename T>
+constexpr std::underlying_type_t<T> to_underlying(T e) noexcept
+{ return static_cast<std::underlying_type_t<T>>(e); }
+
+[[noreturn]] inline void unreachable()
+{
+#if HAS_BUILTIN(__builtin_unreachable)
+    __builtin_unreachable();
 #else
-#define ASSUME(x) ((void)0)
-#endif /* _MSC_VER */
-#endif /* __GNUC__ */
+    ASSUME(false);
+#endif
+}
+
+template<std::size_t alignment, typename T>
+force_inline constexpr auto assume_aligned(T *ptr) noexcept
+{
+#ifdef __cpp_lib_assume_aligned
+    return std::assume_aligned<alignment,T>(ptr);
+#elif HAS_BUILTIN(__builtin_assume_aligned)
+    return static_cast<T*>(__builtin_assume_aligned(ptr, alignment));
+#elif defined(_MSC_VER)
+    constexpr std::size_t alignment_mask{(1<<alignment) - 1};
+    if((reinterpret_cast<std::uintptr_t>(ptr)&alignment_mask) == 0)
+        return ptr;
+    __assume(0);
+#elif defined(__ICC)
+    __assume_aligned(ptr, alignment);
+    return ptr;
+#else
+    return ptr;
+#endif
+}
+
+} // namespace al
 
 #endif /* OPTHELPERS_H */
diff --git a/common/phase_shifter.h b/common/phase_shifter.h
new file mode 100644
index 00000000..0d4166bc
--- /dev/null
+++ b/common/phase_shifter.h
@@ -0,0 +1,214 @@
+#ifndef PHASE_SHIFTER_H
+#define PHASE_SHIFTER_H
+
+#ifdef HAVE_SSE_INTRINSICS
+#include <xmmintrin.h>
+#elif defined(HAVE_NEON)
+#include <arm_neon.h>
+#endif
+
+#include <array>
+#include <stddef.h>
+
+#include "alcomplex.h"
+#include "alspan.h"
+
+
+/* Implements a wide-band +90 degree phase-shift. Note that this should be
+ * given one sample less of a delay (FilterSize/2 - 1) compared to the direct
+ * signal delay (FilterSize/2) to properly align.
+ */
+template<size_t FilterSize>
+struct PhaseShifterT {
+    static_assert(FilterSize >= 16, "FilterSize needs to be at least 16");
+    static_assert((FilterSize&(FilterSize-1)) == 0, "FilterSize needs to be power-of-two");
+
+    alignas(16) std::array<float,FilterSize/2> mCoeffs{};
+
+    /* Some notes on this filter construction.
+     *
+     * A wide-band phase-shift filter needs a delay to maintain linearity. A
+     * dirac impulse in the center of a time-domain buffer represents a filter
+     * passing all frequencies through as-is with a pure delay. Converting that
+     * to the frequency domain, adjusting the phase of each frequency bin by
+     * +90 degrees, then converting back to the time domain, results in a FIR
+     * filter that applies a +90 degree wide-band phase-shift.
+     *
+     * A particularly notable aspect of the time-domain filter response is that
+     * every other coefficient is 0. This allows doubling the effective size of
+     * the filter, by storing only the non-0 coefficients and double-stepping
+     * over the input to apply it.
+     *
+     * Additionally, the resulting filter is independent of the sample rate.
+     * The same filter can be applied regardless of the device's sample rate
+     * and achieve the same effect.
+     */
+    PhaseShifterT()
+    {
+        using complex_d = std::complex<double>;
+        constexpr size_t fft_size{FilterSize};
+        constexpr size_t half_size{fft_size / 2};
+
+        auto fftBuffer = std::make_unique<complex_d[]>(fft_size);
+        std::fill_n(fftBuffer.get(), fft_size, complex_d{});
+        fftBuffer[half_size] = 1.0;
+
+        forward_fft(al::as_span(fftBuffer.get(), fft_size));
+        for(size_t i{0};i < half_size+1;++i)
+            fftBuffer[i] = complex_d{-fftBuffer[i].imag(), fftBuffer[i].real()};
+        for(size_t i{half_size+1};i < fft_size;++i)
+            fftBuffer[i] = std::conj(fftBuffer[fft_size - i]);
+        inverse_fft(al::as_span(fftBuffer.get(), fft_size));
+
+        auto fftiter = fftBuffer.get() + half_size + (FilterSize/2 - 1);
+        for(float &coeff : mCoeffs)
+        {
+            coeff = static_cast<float>(fftiter->real() / double{fft_size});
+            fftiter -= 2;
+        }
+    }
+
+    void process(al::span<float> dst, const float *RESTRICT src) const;
+
+private:
+#if defined(HAVE_NEON)
+    /* There doesn't seem to be NEON intrinsics to do this kind of stipple
+     * shuffling, so there's two custom methods for it.
+     */
+    static auto shuffle_2020(float32x4_t a, float32x4_t b)
+    {
+        float32x4_t ret{vmovq_n_f32(vgetq_lane_f32(a, 0))};
+        ret = vsetq_lane_f32(vgetq_lane_f32(a, 2), ret, 1);
+        ret = vsetq_lane_f32(vgetq_lane_f32(b, 0), ret, 2);
+        ret = vsetq_lane_f32(vgetq_lane_f32(b, 2), ret, 3);
+        return ret;
+    }
+    static auto shuffle_3131(float32x4_t a, float32x4_t b)
+    {
+        float32x4_t ret{vmovq_n_f32(vgetq_lane_f32(a, 1))};
+        ret = vsetq_lane_f32(vgetq_lane_f32(a, 3), ret, 1);
+        ret = vsetq_lane_f32(vgetq_lane_f32(b, 1), ret, 2);
+        ret = vsetq_lane_f32(vgetq_lane_f32(b, 3), ret, 3);
+        return ret;
+    }
+    static auto unpacklo(float32x4_t a, float32x4_t b)
+    {
+        float32x2x2_t result{vzip_f32(vget_low_f32(a), vget_low_f32(b))};
+        return vcombine_f32(result.val[0], result.val[1]);
+    }
+    static auto unpackhi(float32x4_t a, float32x4_t b)
+    {
+        float32x2x2_t result{vzip_f32(vget_high_f32(a), vget_high_f32(b))};
+        return vcombine_f32(result.val[0], result.val[1]);
+    }
+    static auto load4(float32_t a, float32_t b, float32_t c, float32_t d)
+    {
+        float32x4_t ret{vmovq_n_f32(a)};
+        ret = vsetq_lane_f32(b, ret, 1);
+        ret = vsetq_lane_f32(c, ret, 2);
+        ret = vsetq_lane_f32(d, ret, 3);
+        return ret;
+    }
+#endif
+};
+
+template<size_t S>
+inline void PhaseShifterT<S>::process(al::span<float> dst, const float *RESTRICT src) const
+{
+#ifdef HAVE_SSE_INTRINSICS
+    if(size_t todo{dst.size()>>1})
+    {
+        auto *out = reinterpret_cast<__m64*>(dst.data());
+        do {
+            __m128 r04{_mm_setzero_ps()};
+            __m128 r14{_mm_setzero_ps()};
+            for(size_t j{0};j < mCoeffs.size();j+=4)
+            {
+                const __m128 coeffs{_mm_load_ps(&mCoeffs[j])};
+                const __m128 s0{_mm_loadu_ps(&src[j*2])};
+                const __m128 s1{_mm_loadu_ps(&src[j*2 + 4])};
+
+                __m128 s{_mm_shuffle_ps(s0, s1, _MM_SHUFFLE(2, 0, 2, 0))};
+                r04 = _mm_add_ps(r04, _mm_mul_ps(s, coeffs));
+
+                s = _mm_shuffle_ps(s0, s1, _MM_SHUFFLE(3, 1, 3, 1));
+                r14 = _mm_add_ps(r14, _mm_mul_ps(s, coeffs));
+            }
+            src += 2;
+
+            __m128 r4{_mm_add_ps(_mm_unpackhi_ps(r04, r14), _mm_unpacklo_ps(r04, r14))};
+            r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+
+            _mm_storel_pi(out, r4);
+            ++out;
+        } while(--todo);
+    }
+    if((dst.size()&1))
+    {
+        __m128 r4{_mm_setzero_ps()};
+        for(size_t j{0};j < mCoeffs.size();j+=4)
+        {
+            const __m128 coeffs{_mm_load_ps(&mCoeffs[j])};
+            const __m128 s{_mm_setr_ps(src[j*2], src[j*2 + 2], src[j*2 + 4], src[j*2 + 6])};
+            r4 = _mm_add_ps(r4, _mm_mul_ps(s, coeffs));
+        }
+        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
+        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+
+        dst.back() = _mm_cvtss_f32(r4);
+    }
+
+#elif defined(HAVE_NEON)
+
+    size_t pos{0};
+    if(size_t todo{dst.size()>>1})
+    {
+        do {
+            float32x4_t r04{vdupq_n_f32(0.0f)};
+            float32x4_t r14{vdupq_n_f32(0.0f)};
+            for(size_t j{0};j < mCoeffs.size();j+=4)
+            {
+                const float32x4_t coeffs{vld1q_f32(&mCoeffs[j])};
+                const float32x4_t s0{vld1q_f32(&src[j*2])};
+                const float32x4_t s1{vld1q_f32(&src[j*2 + 4])};
+
+                r04 = vmlaq_f32(r04, shuffle_2020(s0, s1), coeffs);
+                r14 = vmlaq_f32(r14, shuffle_3131(s0, s1), coeffs);
+            }
+            src += 2;
+
+            float32x4_t r4{vaddq_f32(unpackhi(r04, r14), unpacklo(r04, r14))};
+            float32x2_t r2{vadd_f32(vget_low_f32(r4), vget_high_f32(r4))};
+
+            vst1_f32(&dst[pos], r2);
+            pos += 2;
+        } while(--todo);
+    }
+    if((dst.size()&1))
+    {
+        float32x4_t r4{vdupq_n_f32(0.0f)};
+        for(size_t j{0};j < mCoeffs.size();j+=4)
+        {
+            const float32x4_t coeffs{vld1q_f32(&mCoeffs[j])};
+            const float32x4_t s{load4(src[j*2], src[j*2 + 2], src[j*2 + 4], src[j*2 + 6])};
+            r4 = vmlaq_f32(r4, s, coeffs);
+        }
+        r4 = vaddq_f32(r4, vrev64q_f32(r4));
+        dst[pos] = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
+    }
+
+#else
+
+    for(float &output : dst)
+    {
+        float ret{0.0f};
+        for(size_t j{0};j < mCoeffs.size();++j)
+            ret += src[j*2] * mCoeffs[j];
+
+        output = ret;
+        ++src;
+    }
+#endif
+}
+
+#endif /* PHASE_SHIFTER_H */
diff --git a/common/polyphase_resampler.cpp b/common/polyphase_resampler.cpp
new file mode 100644
index 00000000..14f7e40d
--- /dev/null
+++ b/common/polyphase_resampler.cpp
@@ -0,0 +1,222 @@
+
+#include "polyphase_resampler.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "alnumbers.h"
+#include "opthelpers.h"
+
+
+namespace {
+
+constexpr double Epsilon{1e-9};
+
+using uint = unsigned int;
+
+/* This is the normalized cardinal sine (sinc) function.
+ *
+ *   sinc(x) = { 1,                   x = 0
+ *             { sin(pi x) / (pi x),  otherwise.
+ */
+double Sinc(const double x)
+{
+    if(std::abs(x) < Epsilon) UNLIKELY
+        return 1.0;
+    return std::sin(al::numbers::pi*x) / (al::numbers::pi*x);
+}
+
+/* The zero-order modified Bessel function of the first kind, used for the
+ * Kaiser window.
+ *
+ *   I_0(x) = sum_{k=0}^inf (1 / k!)^2 (x / 2)^(2 k)
+ *          = sum_{k=0}^inf ((x / 2)^k / k!)^2
+ */
+constexpr double BesselI_0(const double x)
+{
+    // Start at k=1 since k=0 is trivial.
+    const double x2{x/2.0};
+    double term{1.0};
+    double sum{1.0};
+    int k{1};
+
+    // Let the integration converge until the term of the sum is no longer
+    // significant.
+    double last_sum{};
+    do {
+        const double y{x2 / k};
+        ++k;
+        last_sum = sum;
+        term *= y * y;
+        sum += term;
+    } while(sum != last_sum);
+    return sum;
+}
+
+/* Calculate a Kaiser window from the given beta value and a normalized k
+ * [-1, 1].
+ *
+ *   w(k) = { I_0(B sqrt(1 - k^2)) / I_0(B),  -1 <= k <= 1
+ *          { 0,                              elsewhere.
+ *
+ * Where k can be calculated as:
+ *
+ *   k = i / l,         where -l <= i <= l.
+ *
+ * or:
+ *
+ *   k = 2 i / M - 1,   where 0 <= i <= M.
+ */
+double Kaiser(const double b, const double k)
+{
+    if(!(k >= -1.0 && k <= 1.0))
+        return 0.0;
+    return BesselI_0(b * std::sqrt(1.0 - k*k)) / BesselI_0(b);
+}
+
+// Calculates the greatest common divisor of a and b.
+constexpr uint Gcd(uint x, uint y)
+{
+    while(y > 0)
+    {
+        const uint z{y};
+        y = x % y;
+        x = z;
+    }
+    return x;
+}
+
+/* Calculates the size (order) of the Kaiser window.  Rejection is in dB and
+ * the transition width is normalized frequency (0.5 is nyquist).
+ *
+ *   M = { ceil((r - 7.95) / (2.285 2 pi f_t)),  r > 21
+ *       { ceil(5.79 / 2 pi f_t),                r <= 21.
+ *
+ */
+constexpr uint CalcKaiserOrder(const double rejection, const double transition)
+{
+    const double w_t{2.0 * al::numbers::pi * transition};
+    if(rejection > 21.0) LIKELY
+        return static_cast<uint>(std::ceil((rejection - 7.95) / (2.285 * w_t)));
+    return static_cast<uint>(std::ceil(5.79 / w_t));
+}
+
+// Calculates the beta value of the Kaiser window.  Rejection is in dB.
+constexpr double CalcKaiserBeta(const double rejection)
+{
+    if(rejection > 50.0) LIKELY
+        return 0.1102 * (rejection - 8.7);
+    if(rejection >= 21.0)
+        return (0.5842 * std::pow(rejection - 21.0, 0.4)) +
+               (0.07886 * (rejection - 21.0));
+    return 0.0;
+}
+
+/* Calculates a point on the Kaiser-windowed sinc filter for the given half-
+ * width, beta, gain, and cutoff.  The point is specified in non-normalized
+ * samples, from 0 to M, where M = (2 l + 1).
+ *
+ *   w(k) 2 p f_t sinc(2 f_t x)
+ *
+ *   x    -- centered sample index (i - l)
+ *   k    -- normalized and centered window index (x / l)
+ *   w(k) -- window function (Kaiser)
+ *   p    -- gain compensation factor when sampling
+ *   f_t  -- normalized center frequency (or cutoff; 0.5 is nyquist)
+ */
+double SincFilter(const uint l, const double b, const double gain, const double cutoff,
+    const uint i)
+{
+    const double x{static_cast<double>(i) - l};
+    return Kaiser(b, x / l) * 2.0 * gain * cutoff * Sinc(2.0 * cutoff * x);
+}
+
+} // namespace
+
+// Calculate the resampling metrics and build the Kaiser-windowed sinc filter
+// that's used to cut frequencies above the destination nyquist.
+void PPhaseResampler::init(const uint srcRate, const uint dstRate)
+{
+    const uint gcd{Gcd(srcRate, dstRate)};
+    mP = dstRate / gcd;
+    mQ = srcRate / gcd;
+
+    /* The cutoff is adjusted by half the transition width, so the transition
+     * ends before the nyquist (0.5).  Both are scaled by the downsampling
+     * factor.
+     */
+    double cutoff, width;
+    if(mP > mQ)
+    {
+        cutoff = 0.475 / mP;
+        width = 0.05 / mP;
+    }
+    else
+    {
+        cutoff = 0.475 / mQ;
+        width = 0.05 / mQ;
+    }
+    // A rejection of -180 dB is used for the stop band. Round up when
+    // calculating the left offset to avoid increasing the transition width.
+    const uint l{(CalcKaiserOrder(180.0, width)+1) / 2};
+    const double beta{CalcKaiserBeta(180.0)};
+    mM = l*2 + 1;
+    mL = l;
+    mF.resize(mM);
+    for(uint i{0};i < mM;i++)
+        mF[i] = SincFilter(l, beta, mP, cutoff, i);
+}
+
+// Perform the upsample-filter-downsample resampling operation using a
+// polyphase filter implementation.
+void PPhaseResampler::process(const uint inN, const double *in, const uint outN, double *out)
+{
+    if(outN == 0) UNLIKELY
+        return;
+
+    // Handle in-place operation.
+    std::vector<double> workspace;
+    double *work{out};
+    if(work == in) UNLIKELY
+    {
+        workspace.resize(outN);
+        work = workspace.data();
+    }
+
+    // Resample the input.
+    const uint p{mP}, q{mQ}, m{mM}, l{mL};
+    const double *f{mF.data()};
+    for(uint i{0};i < outN;i++)
+    {
+        // Input starts at l to compensate for the filter delay.  This will
+        // drop any build-up from the first half of the filter.
+        size_t j_f{(l + q*i) % p};
+        size_t j_s{(l + q*i) / p};
+
+        // Only take input when 0 <= j_s < inN.
+        double r{0.0};
+        if(j_f < m) LIKELY
+        {
+            size_t filt_len{(m-j_f+p-1) / p};
+            if(j_s+1 > inN) LIKELY
+            {
+                size_t skip{std::min<size_t>(j_s+1 - inN, filt_len)};
+                j_f += p*skip;
+                j_s -= skip;
+                filt_len -= skip;
+            }
+            if(size_t todo{std::min<size_t>(j_s+1, filt_len)}) LIKELY
+            {
+                do {
+                    r += f[j_f] * in[j_s];
+                    j_f += p;
+                    --j_s;
+                } while(--todo);
+            }
+        }
+        work[i] = r;
+    }
+    // Clean up after in-place operation.
+    if(work != out)
+        std::copy_n(work, outN, out);
+}
diff --git a/common/polyphase_resampler.h b/common/polyphase_resampler.h
new file mode 100644
index 00000000..557485bb
--- /dev/null
+++ b/common/polyphase_resampler.h
@@ -0,0 +1,47 @@
+#ifndef POLYPHASE_RESAMPLER_H
+#define POLYPHASE_RESAMPLER_H
+
+#include <vector>
+
+
+using uint = unsigned int;
+
+/* This is a polyphase sinc-filtered resampler. It is built for very high
+ * quality results, rather than real-time performance.
+ *
+ *              Upsample                      Downsample
+ *
+ *              p/q = 3/2                     p/q = 3/5
+ *
+ *          M-+-+-+->                     M-+-+-+->
+ *         -------------------+          ---------------------+
+ *   p  s * f f f f|f|        |    p  s * f f f f f           |
+ *   |  0 *   0 0 0|0|0       |    |  0 *   0 0 0 0|0|        |
+ *   v  0 *     0 0|0|0 0     |    v  0 *     0 0 0|0|0       |
+ *      s *       f|f|f f f   |       s *       f f|f|f f     |
+ *      0 *        |0|0 0 0 0 |       0 *         0|0|0 0 0   |
+ *         --------+=+--------+       0 *          |0|0 0 0 0 |
+ *          d . d .|d|. d . d            ----------+=+--------+
+ *                                        d . . . .|d|. . . .
+ *          q->
+ *                                        q-+-+-+->
+ *
+ *   P_f(i,j) = q i mod p + pj
+ *   P_s(i,j) = floor(q i / p) - j
+ *   d[i=0..N-1] = sum_{j=0}^{floor((M - 1) / p)} {
+ *                   { f[P_f(i,j)] s[P_s(i,j)],  P_f(i,j) < M
+ *                   { 0,                        P_f(i,j) >= M. }
+ */
+
+struct PPhaseResampler {
+    void init(const uint srcRate, const uint dstRate);
+    void process(const uint inN, const double *in, const uint outN, double *out);
+
+    explicit operator bool() const noexcept { return !mF.empty(); }
+
+private:
+    uint mP, mQ, mM, mL;
+    std::vector<double> mF;
+};
+
+#endif /* POLYPHASE_RESAMPLER_H */
diff --git a/common/pragmadefs.h b/common/pragmadefs.h
index 1d0af066..9f0a711f 100644
--- a/common/pragmadefs.h
+++ b/common/pragmadefs.h
@@ -9,7 +9,7 @@
 #else
 #if defined(__GNUC__) || defined(__clang__)
 #define DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
-#define DIAGNOSTIC_POP _Pragma("GCC diagnostic push")
+#define DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
 #else
 #define DIAGNOSTIC_PUSH
 #define DIAGNOSTIC_POP
diff --git a/alc/ringbuffer.cpp b/common/ringbuffer.cpp
index 1f72f4b1..0aec1d49 100644
--- a/alc/ringbuffer.cpp
+++ b/common/ringbuffer.cpp
@@ -24,13 +24,12 @@
 
 #include <algorithm>
 #include <climits>
-#include <cstdint>
 #include <stdexcept>
 
 #include "almalloc.h"
 
 
-RingBufferPtr CreateRingBuffer(size_t sz, size_t elem_sz, int limit_writes)
+RingBufferPtr RingBuffer::Create(size_t sz, size_t elem_sz, int limit_writes)
 {
     size_t power_of_two{0u};
     if(sz > 0)
@@ -50,7 +49,7 @@ RingBufferPtr CreateRingBuffer(size_t sz, size_t elem_sz, int limit_writes)
         throw std::overflow_error{"Ring buffer size overflow"};
 
     const size_t bufbytes{power_of_two * elem_sz};
-    RingBufferPtr rb{new (FamCount{bufbytes}) RingBuffer{bufbytes}};
+    RingBufferPtr rb{new(FamCount(bufbytes)) RingBuffer{bufbytes}};
     rb->mWriteSize = limit_writes ? sz : (power_of_two-1);
     rb->mSizeMask = power_of_two - 1;
     rb->mElemSize = elem_sz;
@@ -66,21 +65,6 @@ void RingBuffer::reset() noexcept
 }
 
 
-size_t RingBuffer::readSpace() const noexcept
-{
-    size_t w = mWritePtr.load(std::memory_order_acquire);
-    size_t r = mReadPtr.load(std::memory_order_acquire);
-    return (w-r) & mSizeMask;
-}
-
-size_t RingBuffer::writeSpace() const noexcept
-{
-    size_t w = mWritePtr.load(std::memory_order_acquire);
-    size_t r = mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask;
-    return (r-w-1) & mSizeMask;
-}
-
-
 size_t RingBuffer::read(void *dest, size_t cnt) noexcept
 {
     const size_t free_cnt{readSpace()};
@@ -176,20 +160,9 @@ size_t RingBuffer::write(const void *src, size_t cnt) noexcept
 }
 
 
-void RingBuffer::readAdvance(size_t cnt) noexcept
-{
-    mReadPtr.fetch_add(cnt, std::memory_order_acq_rel);
-}
-
-void RingBuffer::writeAdvance(size_t cnt) noexcept
-{
-    mWritePtr.fetch_add(cnt, std::memory_order_acq_rel);
-}
-
-
-ll_ringbuffer_data_pair RingBuffer::getReadVector() const noexcept
+auto RingBuffer::getReadVector() const noexcept -> DataPair
 {
-    ll_ringbuffer_data_pair ret;
+    DataPair ret;
 
     size_t w{mWritePtr.load(std::memory_order_acquire)};
     size_t r{mReadPtr.load(std::memory_order_acquire)};
@@ -219,9 +192,9 @@ ll_ringbuffer_data_pair RingBuffer::getReadVector() const noexcept
     return ret;
 }
 
-ll_ringbuffer_data_pair RingBuffer::getWriteVector() const noexcept
+auto RingBuffer::getWriteVector() const noexcept -> DataPair
 {
-    ll_ringbuffer_data_pair ret;
+    DataPair ret;
 
     size_t w{mWritePtr.load(std::memory_order_acquire)};
     size_t r{mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask};
diff --git a/alc/ringbuffer.h b/common/ringbuffer.h
index 3151fdcb..2a3797b0 100644
--- a/alc/ringbuffer.h
+++ b/common/ringbuffer.h
@@ -1,10 +1,9 @@
 #ifndef RINGBUFFER_H
 #define RINGBUFFER_H
 
-#include <stddef.h>
-
 #include <atomic>
 #include <memory>
+#include <stddef.h>
 #include <utility>
 
 #include "albyte.h"
@@ -17,14 +16,8 @@
  * single-consumer/single-provider operation.
  */
 
-struct ll_ringbuffer_data {
-    al::byte *buf;
-    size_t len;
-};
-using ll_ringbuffer_data_pair = std::pair<ll_ringbuffer_data,ll_ringbuffer_data>;
-
-
 struct RingBuffer {
+private:
     std::atomic<size_t> mWritePtr{0u};
     std::atomic<size_t> mReadPtr{0u};
     size_t mWriteSize{0u};
@@ -33,6 +26,14 @@ struct RingBuffer {
 
     al::FlexArray<al::byte, 16> mBuffer;
 
+public:
+    struct Data {
+        al::byte *buf;
+        size_t len;
+    };
+    using DataPair = std::pair<Data,Data>;
+
+
     RingBuffer(const size_t count) : mBuffer{count} { }
 
     /** Reset the read and write pointers to zero. This is not thread safe. */
@@ -43,19 +44,25 @@ struct RingBuffer {
      * hold the current readable data. If the readable data is in one segment
      * the second segment has zero length.
      */
-    ll_ringbuffer_data_pair getReadVector() const noexcept;
+    DataPair getReadVector() const noexcept;
     /**
      * The non-copying data writer. Returns two ringbuffer data pointers that
      * hold the current writeable data. If the writeable data is in one segment
      * the second segment has zero length.
      */
-    ll_ringbuffer_data_pair getWriteVector() const noexcept;
+    DataPair getWriteVector() const noexcept;
 
     /**
      * Return the number of elements available for reading. This is the number
      * of elements in front of the read pointer and behind the write pointer.
      */
-    size_t readSpace() const noexcept;
+    size_t readSpace() const noexcept
+    {
+        const size_t w{mWritePtr.load(std::memory_order_acquire)};
+        const size_t r{mReadPtr.load(std::memory_order_acquire)};
+        return (w-r) & mSizeMask;
+    }
+
     /**
      * The copying data reader. Copy at most `cnt' elements into `dest'.
      * Returns the actual number of elements copied.
@@ -67,31 +74,42 @@ struct RingBuffer {
      */
     size_t peek(void *dest, size_t cnt) const noexcept;
     /** Advance the read pointer `cnt' places. */
-    void readAdvance(size_t cnt) noexcept;
+    void readAdvance(size_t cnt) noexcept
+    { mReadPtr.fetch_add(cnt, std::memory_order_acq_rel); }
+
 
     /**
      * Return the number of elements available for writing. This is the number
      * of elements in front of the write pointer and behind the read pointer.
      */
-    size_t writeSpace() const noexcept;
+    size_t writeSpace() const noexcept
+    {
+        const size_t w{mWritePtr.load(std::memory_order_acquire)};
+        const size_t r{mReadPtr.load(std::memory_order_acquire) + mWriteSize - mSizeMask};
+        return (r-w-1) & mSizeMask;
+    }
+
     /**
      * The copying data writer. Copy at most `cnt' elements from `src'. Returns
      * the actual number of elements copied.
      */
     size_t write(const void *src, size_t cnt) noexcept;
     /** Advance the write pointer `cnt' places. */
-    void writeAdvance(size_t cnt) noexcept;
+    void writeAdvance(size_t cnt) noexcept
+    { mWritePtr.fetch_add(cnt, std::memory_order_acq_rel); }
+
+    size_t getElemSize() const noexcept { return mElemSize; }
+
+    /**
+     * Create a new ringbuffer to hold at least `sz' elements of `elem_sz'
+     * bytes. The number of elements is rounded up to the next power of two
+     * (even if it is already a power of two, to ensure the requested amount
+     * can be written).
+     */
+    static std::unique_ptr<RingBuffer> Create(size_t sz, size_t elem_sz, int limit_writes);
 
     DEF_FAM_NEWDEL(RingBuffer, mBuffer)
 };
 using RingBufferPtr = std::unique_ptr<RingBuffer>;
 
-
-/**
- * Create a new ringbuffer to hold at least `sz' elements of `elem_sz' bytes.
- * The number of elements is rounded up to the next power of two (even if it is
- * already a power of two, to ensure the requested amount can be written).
- */
-RingBufferPtr CreateRingBuffer(size_t sz, size_t elem_sz, int limit_writes);
-
 #endif /* RINGBUFFER_H */
diff --git a/common/strutils.cpp b/common/strutils.cpp
index 870a0ed3..d0418eff 100644
--- a/common/strutils.cpp
+++ b/common/strutils.cpp
@@ -46,7 +46,8 @@ namespace al {
 al::optional<std::string> getenv(const char *envname)
 {
     const char *str{std::getenv(envname)};
-    if(str && str[0] != '\0') return str;
+    if(str && str[0] != '\0')
+        return str;
     return al::nullopt;
 }
 
@@ -54,7 +55,8 @@ al::optional<std::string> getenv(const char *envname)
 al::optional<std::wstring> getenv(const WCHAR *envname)
 {
     const WCHAR *str{_wgetenv(envname)};
-    if(str && str[0] != L'\0') return str;
+    if(str && str[0] != L'\0')
+        return str;
     return al::nullopt;
 }
 #endif
diff --git a/common/threads.cpp b/common/threads.cpp
index ff01de42..19a6bbf0 100644
--- a/common/threads.cpp
+++ b/common/threads.cpp
@@ -20,18 +20,22 @@
 
 #include "config.h"
 
+#include "opthelpers.h"
 #include "threads.h"
 
 #include <system_error>
 
 
 #ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 
 #include <limits>
 
 void althrd_setname(const char *name)
 {
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(_M_ARM)
+
 #define MS_VC_EXCEPTION 0x406D1388
 #pragma pack(push,8)
     struct {
@@ -52,7 +56,9 @@ void althrd_setname(const char *name)
     __except(EXCEPTION_CONTINUE_EXECUTION) {
     }
 #undef MS_VC_EXCEPTION
+
 #else
+
     (void)name;
 #endif
 }
@@ -73,48 +79,66 @@ semaphore::~semaphore()
 
 void semaphore::post()
 {
-    if(!ReleaseSemaphore(mSem, 1, nullptr))
+    if(!ReleaseSemaphore(static_cast<HANDLE>(mSem), 1, nullptr))
         throw std::system_error(std::make_error_code(std::errc::value_too_large));
 }
 
 void semaphore::wait() noexcept
-{ WaitForSingleObject(mSem, INFINITE); }
+{ WaitForSingleObject(static_cast<HANDLE>(mSem), INFINITE); }
 
 bool semaphore::try_wait() noexcept
-{ return WaitForSingleObject(mSem, 0) == WAIT_OBJECT_0; }
+{ return WaitForSingleObject(static_cast<HANDLE>(mSem), 0) == WAIT_OBJECT_0; }
 
 } // namespace al
 
 #else
 
-#if defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP)
 #include <pthread.h>
 #ifdef HAVE_PTHREAD_NP_H
 #include <pthread_np.h>
 #endif
+#include <tuple>
+
+namespace {
+
+using setname_t1 = int(*)(const char*);
+using setname_t2 = int(*)(pthread_t, const char*);
+using setname_t3 = void(*)(pthread_t, const char*);
+using setname_t4 = int(*)(pthread_t, const char*, void*);
+
+void setname_caller(setname_t1 func, const char *name)
+{ func(name); }
+
+void setname_caller(setname_t2 func, const char *name)
+{ func(pthread_self(), name); }
+
+void setname_caller(setname_t3 func, const char *name)
+{ func(pthread_self(), name); }
+
+void setname_caller(setname_t4 func, const char *name)
+{ func(pthread_self(), "%s", static_cast<void*>(const_cast<char*>(name))); }
+
+} // namespace
 
 void althrd_setname(const char *name)
 {
 #if defined(HAVE_PTHREAD_SET_NAME_NP)
-    pthread_set_name_np(pthread_self(), name);
-#elif defined(PTHREAD_SETNAME_NP_ONE_PARAM)
-    pthread_setname_np(name);
-#elif defined(PTHREAD_SETNAME_NP_THREE_PARAMS)
-    pthread_setname_np(pthread_self(), "%s", (void*)name);
-#else
-    pthread_setname_np(pthread_self(), name);
+    setname_caller(pthread_set_name_np, name);
+#elif defined(HAVE_PTHREAD_SETNAME_NP)
+    setname_caller(pthread_setname_np, name);
 #endif
+    /* Avoid unused function/parameter warnings. */
+    std::ignore = name;
+    std::ignore = static_cast<void(*)(setname_t1,const char*)>(&setname_caller);
+    std::ignore = static_cast<void(*)(setname_t2,const char*)>(&setname_caller);
+    std::ignore = static_cast<void(*)(setname_t3,const char*)>(&setname_caller);
+    std::ignore = static_cast<void(*)(setname_t4,const char*)>(&setname_caller);
 }
 
-#else
-
-void althrd_setname(const char*) { }
-#endif
+#ifdef __APPLE__
 
 namespace al {
 
-#ifdef __APPLE__
-
 semaphore::semaphore(unsigned int initial)
 {
     mSem = dispatch_semaphore_create(initial);
@@ -134,10 +158,14 @@ void semaphore::wait() noexcept
 bool semaphore::try_wait() noexcept
 { return dispatch_semaphore_wait(mSem, DISPATCH_TIME_NOW) == 0; }
 
+} // namespace al
+
 #else /* !__APPLE__ */
 
 #include <cerrno>
 
+namespace al {
+
 semaphore::semaphore(unsigned int initial)
 {
     if(sem_init(&mSem, 0, initial) != 0)
@@ -162,8 +190,8 @@ void semaphore::wait() noexcept
 bool semaphore::try_wait() noexcept
 { return sem_trywait(&mSem) == 0; }
 
-#endif /* __APPLE__ */
-
 } // namespace al
 
+#endif /* __APPLE__ */
+
 #endif /* _WIN32 */
diff --git a/common/threads.h b/common/threads.h
index ff571a66..1cdb5d8f 100644
--- a/common/threads.h
+++ b/common/threads.h
@@ -11,12 +11,9 @@
 #define FORCE_ALIGN
 #endif
 
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#elif defined(__APPLE__)
+#if defined(__APPLE__)
 #include <dispatch/dispatch.h>
-#else
+#elif !defined(_WIN32)
 #include <semaphore.h>
 #endif
 
@@ -26,7 +23,7 @@ namespace al {
 
 class semaphore {
 #ifdef _WIN32
-    using native_type = HANDLE;
+    using native_type = void*;
 #elif defined(__APPLE__)
     using native_type = dispatch_semaphore_t;
 #else
diff --git a/common/vecmat.h b/common/vecmat.h
index 7186ec6c..a45f262f 100644
--- a/common/vecmat.h
+++ b/common/vecmat.h
@@ -6,22 +6,27 @@
 #include <cstddef>
 #include <limits>
 
+#include "alspan.h"
+
 
 namespace alu {
 
-class Vector {
-    alignas(16) std::array<float,4> mVals;
+template<typename T>
+class VectorR {
+    static_assert(std::is_floating_point<T>::value, "Must use floating-point types");
+    alignas(16) T mVals[4];
 
 public:
-    Vector() noexcept = default;
-    constexpr Vector(float a, float b, float c, float d) noexcept
-      : mVals{{a, b, c, d}}
-    { }
+    constexpr VectorR() noexcept = default;
+    constexpr VectorR(const VectorR&) noexcept = default;
+    constexpr explicit VectorR(T a, T b, T c, T d) noexcept : mVals{a, b, c, d} { }
 
-    float& operator[](size_t idx) noexcept { return mVals[idx]; }
-    constexpr const float& operator[](size_t idx) const noexcept { return mVals[idx]; }
+    constexpr VectorR& operator=(const VectorR&) noexcept = default;
 
-    Vector& operator+=(const Vector &rhs) noexcept
+    constexpr T& operator[](size_t idx) noexcept { return mVals[idx]; }
+    constexpr const T& operator[](size_t idx) const noexcept { return mVals[idx]; }
+
+    constexpr VectorR& operator+=(const VectorR &rhs) noexcept
     {
         mVals[0] += rhs.mVals[0];
         mVals[1] += rhs.mVals[1];
@@ -30,56 +35,85 @@ public:
         return *this;
     }
 
-    float normalize()
+    constexpr VectorR operator-(const VectorR &rhs) const noexcept
     {
-        const float length{std::sqrt(mVals[0]*mVals[0] + mVals[1]*mVals[1] + mVals[2]*mVals[2])};
-        if(length > std::numeric_limits<float>::epsilon())
+        return VectorR{mVals[0] - rhs.mVals[0], mVals[1] - rhs.mVals[1],
+            mVals[2] - rhs.mVals[2], mVals[3] - rhs.mVals[3]};
+    }
+
+    constexpr T normalize(T limit = std::numeric_limits<T>::epsilon())
+    {
+        limit = std::max(limit, std::numeric_limits<T>::epsilon());
+        const T length_sqr{mVals[0]*mVals[0] + mVals[1]*mVals[1] + mVals[2]*mVals[2]};
+        if(length_sqr > limit*limit)
         {
-            float inv_length = 1.0f/length;
+            const T length{std::sqrt(length_sqr)};
+            T inv_length{T{1}/length};
             mVals[0] *= inv_length;
             mVals[1] *= inv_length;
             mVals[2] *= inv_length;
             return length;
         }
-        mVals[0] = mVals[1] = mVals[2] = 0.0f;
-        return 0.0f;
+        mVals[0] = mVals[1] = mVals[2] = T{0};
+        return T{0};
     }
+
+    constexpr VectorR cross_product(const alu::VectorR<T> &rhs) const noexcept
+    {
+        return VectorR{
+            mVals[1]*rhs.mVals[2] - mVals[2]*rhs.mVals[1],
+            mVals[2]*rhs.mVals[0] - mVals[0]*rhs.mVals[2],
+            mVals[0]*rhs.mVals[1] - mVals[1]*rhs.mVals[0],
+            T{0}};
+    }
+
+    constexpr T dot_product(const alu::VectorR<T> &rhs) const noexcept
+    { return mVals[0]*rhs.mVals[0] + mVals[1]*rhs.mVals[1] + mVals[2]*rhs.mVals[2]; }
 };
+using Vector = VectorR<float>;
 
-class Matrix {
-    alignas(16) std::array<std::array<float,4>,4> mVals;
+template<typename T>
+class MatrixR {
+    static_assert(std::is_floating_point<T>::value, "Must use floating-point types");
+    alignas(16) T mVals[16];
 
 public:
-    Matrix() noexcept = default;
-    constexpr Matrix(float aa, float ab, float ac, float ad,
-                     float ba, float bb, float bc, float bd,
-                     float ca, float cb, float cc, float cd,
-                     float da, float db, float dc, float dd) noexcept
-      : mVals{{{{aa, ab, ac, ad}}, {{ba, bb, bc, bd}}, {{ca, cb, cc, cd}}, {{da, db, dc, dd}}}}
+    constexpr MatrixR() noexcept = default;
+    constexpr MatrixR(const MatrixR&) noexcept = default;
+    constexpr explicit MatrixR(
+        T aa, T ab, T ac, T ad,
+        T ba, T bb, T bc, T bd,
+        T ca, T cb, T cc, T cd,
+        T da, T db, T dc, T dd) noexcept
+        : mVals{aa,ab,ac,ad, ba,bb,bc,bd, ca,cb,cc,cd, da,db,dc,dd}
     { }
 
-    std::array<float,4>& operator[](size_t idx) noexcept { return mVals[idx]; }
-    constexpr const std::array<float,4>& operator[](size_t idx) const noexcept { return mVals[idx]; }
+    constexpr MatrixR& operator=(const MatrixR&) noexcept = default;
 
-    void setRow(size_t idx, float a, float b, float c, float d) noexcept
-    {
-        mVals[idx][0] = a;
-        mVals[idx][1] = b;
-        mVals[idx][2] = c;
-        mVals[idx][3] = d;
-    }
+    constexpr auto operator[](size_t idx) noexcept { return al::span<T,4>{&mVals[idx*4], 4}; }
+    constexpr auto operator[](size_t idx) const noexcept
+    { return al::span<const T,4>{&mVals[idx*4], 4}; }
 
-    static const Matrix &Identity() noexcept
+    static constexpr MatrixR Identity() noexcept
     {
-        static constexpr Matrix identity{
-            1.0f, 0.0f, 0.0f, 0.0f,
-            0.0f, 1.0f, 0.0f, 0.0f,
-            0.0f, 0.0f, 1.0f, 0.0f,
-            0.0f, 0.0f, 0.0f, 1.0f
-        };
-        return identity;
+        return MatrixR{
+            T{1}, T{0}, T{0}, T{0},
+            T{0}, T{1}, T{0}, T{0},
+            T{0}, T{0}, T{1}, T{0},
+            T{0}, T{0}, T{0}, T{1}};
     }
 };
+using Matrix = MatrixR<float>;
+
+template<typename T>
+constexpr VectorR<T> operator*(const MatrixR<T> &mtx, const VectorR<T> &vec) noexcept
+{
+    return VectorR<T>{
+        vec[0]*mtx[0][0] + vec[1]*mtx[1][0] + vec[2]*mtx[2][0] + vec[3]*mtx[3][0],
+        vec[0]*mtx[0][1] + vec[1]*mtx[1][1] + vec[2]*mtx[2][1] + vec[3]*mtx[3][1],
+        vec[0]*mtx[0][2] + vec[1]*mtx[1][2] + vec[2]*mtx[2][2] + vec[3]*mtx[3][2],
+        vec[0]*mtx[0][3] + vec[1]*mtx[1][3] + vec[2]*mtx[2][3] + vec[3]*mtx[3][3]};
+}
 
 } // namespace alu
 
diff --git a/common/win_main_utf8.h b/common/win_main_utf8.h
index 242d3b8a..077af533 100644
--- a/common/win_main_utf8.h
+++ b/common/win_main_utf8.h
@@ -13,10 +13,23 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <shellapi.h>
+#include <wchar.h>
+
+#ifdef __cplusplus
+#include <memory>
+
+#define STATIC_CAST(...) static_cast<__VA_ARGS__>
+#define REINTERPRET_CAST(...) reinterpret_cast<__VA_ARGS__>
+
+#else
+
+#define STATIC_CAST(...) (__VA_ARGS__)
+#define REINTERPRET_CAST(...) (__VA_ARGS__)
+#endif
 
 static FILE *my_fopen(const char *fname, const char *mode)
 {
-    WCHAR *wname=NULL, *wmode=NULL;
+    wchar_t *wname=NULL, *wmode=NULL;
     int namelen, modelen;
     FILE *file = NULL;
     errno_t err;
@@ -30,7 +43,12 @@ static FILE *my_fopen(const char *fname, const char *mode)
         return NULL;
     }
 
-    wname = (WCHAR*)calloc(sizeof(WCHAR), namelen+modelen);
+#ifdef __cplusplus
+    auto strbuf = std::make_unique<wchar_t[]>(static_cast<size_t>(namelen)+modelen);
+    wname = strbuf.get();
+#else
+    wname = (wchar_t*)calloc(sizeof(wchar_t), (size_t)namelen + modelen);
+#endif
     wmode = wname + namelen;
     MultiByteToWideChar(CP_UTF8, 0, fname, -1, wname, namelen);
     MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, modelen);
@@ -42,56 +60,58 @@ static FILE *my_fopen(const char *fname, const char *mode)
         file = NULL;
     }
 
+#ifndef __cplusplus
     free(wname);
-
+#endif
     return file;
 }
 #define fopen my_fopen
 
 
-static char **arglist;
-static void cleanup_arglist(void)
-{
-    free(arglist);
-}
+/* SDL overrides main and provides UTF-8 args for us. */
+#if !defined(SDL_MAIN_NEEDED) && !defined(SDL_MAIN_AVAILABLE)
+int my_main(int, char**);
+#define main my_main
 
-static void GetUnicodeArgs(int *argc, char ***argv)
+#ifdef __cplusplus
+extern "C"
+#endif
+int wmain(int argc, wchar_t **wargv)
 {
+    char **argv;
     size_t total;
-    wchar_t **args;
-    int nargs, i;
-
-    args = CommandLineToArgvW(GetCommandLineW(), &nargs);
-    if(!args)
-    {
-        fprintf(stderr, "Failed to get command line args: %ld\n", GetLastError());
-        exit(EXIT_FAILURE);
-    }
+    int i;
 
-    total = sizeof(**argv) * nargs;
-    for(i = 0;i < nargs;i++)
-        total += WideCharToMultiByte(CP_UTF8, 0, args[i], -1, NULL, 0, NULL, NULL);
+    total = sizeof(*argv) * STATIC_CAST(size_t)(argc);
+    for(i = 0;i < argc;i++)
+        total += STATIC_CAST(size_t)(WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, NULL, 0, NULL,
+            NULL));
 
-    atexit(cleanup_arglist);
-    arglist = *argv = (char**)calloc(1, total);
-    (*argv)[0] = (char*)(*argv + nargs);
-    for(i = 0;i < nargs-1;i++)
+#ifdef __cplusplus
+    auto argbuf = std::make_unique<char[]>(total);
+    argv = reinterpret_cast<char**>(argbuf.get());
+#else
+    argv = (char**)calloc(1, total);
+#endif
+    argv[0] = REINTERPRET_CAST(char*)(argv + argc);
+    for(i = 0;i < argc-1;i++)
     {
-        int len = WideCharToMultiByte(CP_UTF8, 0, args[i], -1, (*argv)[i], 65535, NULL, NULL);
-        (*argv)[i+1] = (*argv)[i] + len;
+        int len = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i], 65535, NULL, NULL);
+        argv[i+1] = argv[i] + len;
     }
-    WideCharToMultiByte(CP_UTF8, 0, args[i], -1, (*argv)[i], 65535, NULL, NULL);
-    *argc = nargs;
-
-    LocalFree(args);
-}
-#define GET_UNICODE_ARGS(argc, argv) GetUnicodeArgs(argc, argv)
+    WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i], 65535, NULL, NULL);
 
+#ifdef __cplusplus
+    return main(argc, argv);
 #else
+    i = main(argc, argv);
 
-/* Do nothing. */
-#define GET_UNICODE_ARGS(argc, argv)
-
+    free(argv);
+    return i;
 #endif
+}
+#endif /* !defined(SDL_MAIN_NEEDED) && !defined(SDL_MAIN_AVAILABLE) */
+
+#endif /* _WIN32 */
 
 #endif /* WIN_MAIN_UTF8_H */
diff --git a/config.h.in b/config.h.in
index 4a1e2b00..477d8c77 100644
--- a/config.h.in
+++ b/config.h.in
@@ -1,9 +1,5 @@
-/* API declaration export attribute */
-#define AL_API  ${EXPORT_DECL}
-#define ALC_API ${EXPORT_DECL}
-
-/* Define a restrict macro for non-aliased pointers */
-#define RESTRICT ${RESTRICT_DECL}
+/* Define if deprecated EAX extensions are enabled */
+#cmakedefine ALSOFT_EAX
 
 /* Define if HRTF data is embedded in the library */
 #cmakedefine ALSOFT_EMBED_HRTF_DATA
@@ -20,6 +16,9 @@
 /* Define if we have the getopt function */
 #cmakedefine HAVE_GETOPT
 
+/* Define if we have DBus/RTKit */
+#cmakedefine HAVE_RTKIT
+
 /* Define if we have SSE CPU extensions */
 #cmakedefine HAVE_SSE
 #cmakedefine HAVE_SSE2
@@ -35,15 +34,15 @@
 /* Define if we have the OSS backend */
 #cmakedefine HAVE_OSS
 
+/* Define if we have the PipeWire backend */
+#cmakedefine HAVE_PIPEWIRE
+
 /* Define if we have the Solaris backend */
 #cmakedefine HAVE_SOLARIS
 
 /* Define if we have the SndIO backend */
 #cmakedefine HAVE_SNDIO
 
-/* Define if we have the QSA backend */
-#cmakedefine HAVE_QSA
-
 /* Define if we have the WASAPI backend */
 #cmakedefine HAVE_WASAPI
 
@@ -68,21 +67,15 @@
 /* Define if we have the OpenSL backend */
 #cmakedefine HAVE_OPENSL
 
+/* Define if we have the Oboe backend */
+#cmakedefine HAVE_OBOE
+
 /* Define if we have the Wave Writer backend */
 #cmakedefine HAVE_WAVE
 
 /* Define if we have the SDL2 backend */
 #cmakedefine HAVE_SDL2
 
-/* Define if we have the stat function */
-#cmakedefine HAVE_STAT
-
-/* Define to the size of a long int type */
-#cmakedefine SIZEOF_LONG ${SIZEOF_LONG}
-
-/* Define if we have GCC's format attribute */
-#cmakedefine HAVE_GCC_FORMAT
-
 /* Define if we have dlfcn.h */
 #cmakedefine HAVE_DLFCN_H
 
@@ -92,18 +85,12 @@
 /* Define if we have malloc.h */
 #cmakedefine HAVE_MALLOC_H
 
-/* Define if we have dirent.h */
-#cmakedefine HAVE_DIRENT_H
-
 /* Define if we have cpuid.h */
 #cmakedefine HAVE_CPUID_H
 
 /* Define if we have intrin.h */
 #cmakedefine HAVE_INTRIN_H
 
-/* Define if we have sys/sysconf.h */
-#cmakedefine HAVE_SYS_SYSCONF_H
-
 /* Define if we have guiddef.h */
 #cmakedefine HAVE_GUIDDEF_H
 
@@ -116,12 +103,6 @@
 /* Define if we have the __cpuid() intrinsic */
 #cmakedefine HAVE_CPUID_INTRINSIC
 
-/* Define if we have the _BitScanForward64() intrinsic */
-#cmakedefine HAVE_BITSCANFORWARD64_INTRINSIC
-
-/* Define if we have the _BitScanForward() intrinsic */
-#cmakedefine HAVE_BITSCANFORWARD_INTRINSIC
-
 /* Define if we have SSE intrinsics */
 #cmakedefine HAVE_SSE_INTRINSICS
 
@@ -131,11 +112,8 @@
 /* Define if we have pthread_setname_np() */
 #cmakedefine HAVE_PTHREAD_SETNAME_NP
 
-/* Define if pthread_setname_np() only accepts one parameter */
-#cmakedefine PTHREAD_SETNAME_NP_ONE_PARAM
-
-/* Define if pthread_setname_np() accepts three parameters */
-#cmakedefine PTHREAD_SETNAME_NP_THREE_PARAMS
-
 /* Define if we have pthread_set_name_np() */
 #cmakedefine HAVE_PTHREAD_SET_NAME_NP
+
+/* Define the installation data directory */
+#cmakedefine ALSOFT_INSTALL_DATADIR "@ALSOFT_INSTALL_DATADIR@"
diff --git a/core/ambdec.cpp b/core/ambdec.cpp
new file mode 100644
index 00000000..8ca182c4
--- /dev/null
+++ b/core/ambdec.cpp
@@ -0,0 +1,306 @@
+
+#include "config.h"
+
+#include "ambdec.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdio>
+#include <iterator>
+#include <sstream>
+#include <string>
+
+#include "albit.h"
+#include "alfstream.h"
+#include "alspan.h"
+#include "opthelpers.h"
+
+
+namespace {
+
+std::string read_word(std::istream &f)
+{
+    std::string ret;
+    f >> ret;
+    return ret;
+}
+
+bool is_at_end(const std::string &buffer, std::size_t endpos)
+{
+    while(endpos < buffer.length() && std::isspace(buffer[endpos]))
+        ++endpos;
+    return !(endpos < buffer.length() && buffer[endpos] != '#');
+}
+
+
+enum class ReaderScope {
+    Global,
+    Speakers,
+    LFMatrix,
+    HFMatrix,
+};
+
+#ifdef __USE_MINGW_ANSI_STDIO
+[[gnu::format(gnu_printf,2,3)]]
+#else
+[[gnu::format(printf,2,3)]]
+#endif
+al::optional<std::string> make_error(size_t linenum, const char *fmt, ...)
+{
+    al::optional<std::string> ret;
+    auto &str = ret.emplace();
+
+    str.resize(256);
+    int printed{std::snprintf(const_cast<char*>(str.data()), str.length(), "Line %zu: ", linenum)};
+    if(printed < 0) printed = 0;
+    auto plen = std::min(static_cast<size_t>(printed), str.length());
+
+    std::va_list args, args2;
+    va_start(args, fmt);
+    va_copy(args2, args);
+    const int msglen{std::vsnprintf(&str[plen], str.size()-plen, fmt, args)};
+    if(msglen >= 0 && static_cast<size_t>(msglen) >= str.size()-plen)
+    {
+        str.resize(static_cast<size_t>(msglen) + plen + 1u);
+        std::vsnprintf(&str[plen], str.size()-plen, fmt, args2);
+    }
+    va_end(args2);
+    va_end(args);
+
+    return ret;
+}
+
+} // namespace
+
+AmbDecConf::~AmbDecConf() = default;
+
+
+al::optional<std::string> AmbDecConf::load(const char *fname) noexcept
+{
+    al::ifstream f{fname};
+    if(!f.is_open())
+        return std::string("Failed to open file \"")+fname+"\"";
+
+    ReaderScope scope{ReaderScope::Global};
+    size_t speaker_pos{0};
+    size_t lfmatrix_pos{0};
+    size_t hfmatrix_pos{0};
+    size_t linenum{0};
+
+    std::string buffer;
+    while(f.good() && std::getline(f, buffer))
+    {
+        ++linenum;
+
+        std::istringstream istr{buffer};
+        std::string command{read_word(istr)};
+        if(command.empty() || command[0] == '#')
+            continue;
+
+        if(command == "/}")
+        {
+            if(scope == ReaderScope::Global)
+                return make_error(linenum, "Unexpected /} in global scope");
+            scope = ReaderScope::Global;
+            continue;
+        }
+
+        if(scope == ReaderScope::Speakers)
+        {
+            if(command == "add_spkr")
+            {
+                if(speaker_pos == NumSpeakers)
+                    return make_error(linenum, "Too many speakers specified");
+
+                AmbDecConf::SpeakerConf &spkr = Speakers[speaker_pos++];
+                istr >> spkr.Name;
+                istr >> spkr.Distance;
+                istr >> spkr.Azimuth;
+                istr >> spkr.Elevation;
+                istr >> spkr.Connection;
+            }
+            else
+                return make_error(linenum, "Unexpected speakers command: %s", command.c_str());
+        }
+        else if(scope == ReaderScope::LFMatrix || scope == ReaderScope::HFMatrix)
+        {
+            auto &gains = (scope == ReaderScope::LFMatrix) ? LFOrderGain : HFOrderGain;
+            auto *matrix = (scope == ReaderScope::LFMatrix) ? LFMatrix : HFMatrix;
+            auto &pos = (scope == ReaderScope::LFMatrix) ? lfmatrix_pos : hfmatrix_pos;
+
+            if(command == "order_gain")
+            {
+                size_t toread{(ChanMask > Ambi3OrderMask) ? 5u : 4u};
+                std::size_t curgain{0u};
+                float value{};
+                while(toread)
+                {
+                    --toread;
+                    istr >> value;
+                    if(curgain < al::size(gains))
+                        gains[curgain++] = value;
+                }
+            }
+            else if(command == "add_row")
+            {
+                if(pos == NumSpeakers)
+                    return make_error(linenum, "Too many matrix rows specified");
+
+                unsigned int mask{ChanMask};
+
+                AmbDecConf::CoeffArray &mtxrow = matrix[pos++];
+                mtxrow.fill(0.0f);
+
+                float value{};
+                while(mask)
+                {
+                    auto idx = static_cast<unsigned>(al::countr_zero(mask));
+                    mask &= ~(1u << idx);
+
+                    istr >> value;
+                    if(idx < mtxrow.size())
+                        mtxrow[idx] = value;
+                }
+            }
+            else
+                return make_error(linenum, "Unexpected matrix command: %s", command.c_str());
+        }
+        // Global scope commands
+        else if(command == "/description")
+        {
+            while(istr.good() && std::isspace(istr.peek()))
+                istr.ignore();
+            std::getline(istr, Description);
+            while(!Description.empty() && std::isspace(Description.back()))
+                Description.pop_back();
+        }
+        else if(command == "/version")
+        {
+            if(Version)
+                return make_error(linenum, "Duplicate version definition");
+            istr >> Version;
+            if(Version != 3)
+                return make_error(linenum, "Unsupported version: %d", Version);
+        }
+        else if(command == "/dec/chan_mask")
+        {
+            if(ChanMask)
+                return make_error(linenum, "Duplicate chan_mask definition");
+            istr >> std::hex >> ChanMask >> std::dec;
+
+            if(!ChanMask || ChanMask > Ambi4OrderMask)
+                return make_error(linenum, "Invalid chan_mask: 0x%x", ChanMask);
+            if(ChanMask > Ambi3OrderMask && CoeffScale == AmbDecScale::FuMa)
+                return make_error(linenum, "FuMa not compatible with over third-order");
+        }
+        else if(command == "/dec/freq_bands")
+        {
+            if(FreqBands)
+                return make_error(linenum, "Duplicate freq_bands");
+            istr >> FreqBands;
+            if(FreqBands != 1 && FreqBands != 2)
+                return make_error(linenum, "Invalid freq_bands: %u", FreqBands);
+        }
+        else if(command == "/dec/speakers")
+        {
+            if(NumSpeakers)
+                return make_error(linenum, "Duplicate speakers");
+            istr >> NumSpeakers;
+            if(!NumSpeakers)
+                return make_error(linenum, "Invalid speakers: %zu", NumSpeakers);
+            Speakers = std::make_unique<SpeakerConf[]>(NumSpeakers);
+        }
+        else if(command == "/dec/coeff_scale")
+        {
+            if(CoeffScale != AmbDecScale::Unset)
+                return make_error(linenum, "Duplicate coeff_scale");
+
+            std::string scale{read_word(istr)};
+            if(scale == "n3d") CoeffScale = AmbDecScale::N3D;
+            else if(scale == "sn3d") CoeffScale = AmbDecScale::SN3D;
+            else if(scale == "fuma") CoeffScale = AmbDecScale::FuMa;
+            else
+                return make_error(linenum, "Unexpected coeff_scale: %s", scale.c_str());
+
+            if(ChanMask > Ambi3OrderMask && CoeffScale == AmbDecScale::FuMa)
+                return make_error(linenum, "FuMa not compatible with over third-order");
+        }
+        else if(command == "/opt/xover_freq")
+        {
+            istr >> XOverFreq;
+        }
+        else if(command == "/opt/xover_ratio")
+        {
+            istr >> XOverRatio;
+        }
+        else if(command == "/opt/input_scale" || command == "/opt/nfeff_comp"
+            || command == "/opt/delay_comp" || command == "/opt/level_comp")
+        {
+            /* Unused */
+            read_word(istr);
+        }
+        else if(command == "/speakers/{")
+        {
+            if(!NumSpeakers)
+                return make_error(linenum, "Speakers defined without a count");
+            scope = ReaderScope::Speakers;
+        }
+        else if(command == "/lfmatrix/{" || command == "/hfmatrix/{" || command == "/matrix/{")
+        {
+            if(!NumSpeakers)
+                return make_error(linenum, "Matrix defined without a speaker count");
+            if(!ChanMask)
+                return make_error(linenum, "Matrix defined without a channel mask");
+
+            if(!Matrix)
+            {
+                Matrix = std::make_unique<CoeffArray[]>(NumSpeakers * FreqBands);
+                LFMatrix = Matrix.get();
+                HFMatrix = LFMatrix + NumSpeakers*(FreqBands-1);
+            }
+
+            if(FreqBands == 1)
+            {
+                if(command != "/matrix/{")
+                    return make_error(linenum, "Unexpected \"%s\" for a single-band decoder",
+                        command.c_str());
+                scope = ReaderScope::HFMatrix;
+            }
+            else
+            {
+                if(command == "/lfmatrix/{")
+                    scope = ReaderScope::LFMatrix;
+                else if(command == "/hfmatrix/{")
+                    scope = ReaderScope::HFMatrix;
+                else
+                    return make_error(linenum, "Unexpected \"%s\" for a dual-band decoder",
+                        command.c_str());
+            }
+        }
+        else if(command == "/end")
+        {
+            const auto endpos = static_cast<std::size_t>(istr.tellg());
+            if(!is_at_end(buffer, endpos))
+                return make_error(linenum, "Extra junk on end: %s", buffer.substr(endpos).c_str());
+
+            if(speaker_pos < NumSpeakers || hfmatrix_pos < NumSpeakers
+                || (FreqBands == 2 && lfmatrix_pos < NumSpeakers))
+                return make_error(linenum, "Incomplete decoder definition");
+            if(CoeffScale == AmbDecScale::Unset)
+                return make_error(linenum, "No coefficient scaling defined");
+
+            return al::nullopt;
+        }
+        else
+            return make_error(linenum, "Unexpected command: %s", command.c_str());
+
+        istr.clear();
+        const auto endpos = static_cast<std::size_t>(istr.tellg());
+        if(!is_at_end(buffer, endpos))
+            return make_error(linenum, "Extra junk on line: %s", buffer.substr(endpos).c_str());
+        buffer.clear();
+    }
+    return make_error(linenum, "Unexpected end of file");
+}
diff --git a/alc/ambdec.h b/core/ambdec.h
index ff7b71ee..7f739781 100644
--- a/alc/ambdec.h
+++ b/core/ambdec.h
@@ -1,15 +1,17 @@
-#ifndef AMBDEC_H
-#define AMBDEC_H
+#ifndef CORE_AMBDEC_H
+#define CORE_AMBDEC_H
 
 #include <array>
+#include <memory>
 #include <string>
 
-#include "ambidefs.h"
-#include "vector.h"
+#include "aloptional.h"
+#include "core/ambidefs.h"
 
 /* Helpers to read .ambdec configuration files. */
 
 enum class AmbDecScale {
+    Unset,
     N3D,
     SN3D,
     FuMa,
@@ -20,7 +22,7 @@ struct AmbDecConf {
 
     unsigned int ChanMask{0u};
     unsigned int FreqBands{0u}; /* Must be 1 or 2 */
-    AmbDecScale CoeffScale{};
+    AmbDecScale CoeffScale{AmbDecScale::Unset};
 
     float XOverFreq{0.0f};
     float XOverRatio{0.0f};
@@ -32,17 +34,22 @@ struct AmbDecConf {
         float Elevation{0.0f};
         std::string Connection;
     };
-    al::vector<SpeakerConf> Speakers;
+    size_t NumSpeakers{0};
+    std::unique_ptr<SpeakerConf[]> Speakers;
+
+    using CoeffArray = std::array<float,MaxAmbiChannels>;
+    std::unique_ptr<CoeffArray[]> Matrix;
 
-    using CoeffArray = std::array<float,MAX_AMBI_CHANNELS>;
     /* Unused when FreqBands == 1 */
-    float LFOrderGain[MAX_AMBI_ORDER+1]{};
-    al::vector<CoeffArray> LFMatrix;
+    float LFOrderGain[MaxAmbiOrder+1]{};
+    CoeffArray *LFMatrix;
+
+    float HFOrderGain[MaxAmbiOrder+1]{};
+    CoeffArray *HFMatrix;
 
-    float HFOrderGain[MAX_AMBI_ORDER+1]{};
-    al::vector<CoeffArray> HFMatrix;
+    ~AmbDecConf();
 
-    int load(const char *fname) noexcept;
+    al::optional<std::string> load(const char *fname) noexcept;
 };
 
-#endif /* AMBDEC_H */
+#endif /* CORE_AMBDEC_H */
diff --git a/core/ambidefs.cpp b/core/ambidefs.cpp
new file mode 100644
index 00000000..70d6f356
--- /dev/null
+++ b/core/ambidefs.cpp
@@ -0,0 +1,308 @@
+
+#include "config.h"
+
+#include "ambidefs.h"
+
+#include "alnumbers.h"
+
+
+namespace {
+
+using AmbiChannelFloatArray = std::array<float,MaxAmbiChannels>;
+
+constexpr auto inv_sqrt2f = static_cast<float>(1.0/al::numbers::sqrt2);
+constexpr auto inv_sqrt3f = static_cast<float>(1.0/al::numbers::sqrt3);
+
+
+/* These HF gains are derived from the same 32-point speaker array. The scale
+ * factor between orders represents the same scale factors for any (regular)
+ * speaker array decoder. e.g. Given a first-order source and second-order
+ * output, applying an HF scale of HFScales[1][0] / HFScales[2][0] to channel 0
+ * will result in that channel being subsequently decoded for second-order as
+ * if it was a first-order decoder for that same speaker array.
+ */
+constexpr std::array<std::array<float,MaxAmbiOrder+1>,MaxAmbiOrder+1> HFScales{{
+    {{ 4.000000000e+00f, 2.309401077e+00f, 1.192569588e+00f, 7.189495850e-01f }},
+    {{ 4.000000000e+00f, 2.309401077e+00f, 1.192569588e+00f, 7.189495850e-01f }},
+    {{ 2.981423970e+00f, 2.309401077e+00f, 1.192569588e+00f, 7.189495850e-01f }},
+    {{ 2.359168820e+00f, 2.031565936e+00f, 1.444598386e+00f, 7.189495850e-01f }},
+    /* 1.947005434e+00f, 1.764337084e+00f, 1.424707344e+00f, 9.755104127e-01f, 4.784482742e-01f */
+}};
+
+/* Same as above, but using a 10-point horizontal-only speaker array. Should
+ * only be used when the device is mixing in 2D B-Format for horizontal-only
+ * output.
+ */
+constexpr std::array<std::array<float,MaxAmbiOrder+1>,MaxAmbiOrder+1> HFScales2D{{
+    {{ 2.236067977e+00f, 1.581138830e+00f, 9.128709292e-01f, 6.050756345e-01f }},
+    {{ 2.236067977e+00f, 1.581138830e+00f, 9.128709292e-01f, 6.050756345e-01f }},
+    {{ 1.825741858e+00f, 1.581138830e+00f, 9.128709292e-01f, 6.050756345e-01f }},
+    {{ 1.581138830e+00f, 1.460781803e+00f, 1.118033989e+00f, 6.050756345e-01f }},
+    /* 1.414213562e+00f, 1.344997024e+00f, 1.144122806e+00f, 8.312538756e-01f, 4.370160244e-01f */
+}};
+
+
+/* This calculates a first-order "upsampler" matrix. It combines a first-order
+ * decoder matrix with a max-order encoder matrix, creating a matrix that
+ * behaves as if the B-Format input signal is first decoded to a speaker array
+ * at first-order, then those speaker feeds are encoded to a higher-order
+ * signal. While not perfect, this should accurately encode a lower-order
+ * signal into a higher-order signal.
+ */
+constexpr std::array<std::array<float,4>,8> FirstOrderDecoder{{
+    {{ 1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f, }},
+    {{ 1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f, }},
+    {{ 1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f,  1.250000000e-01f, }},
+    {{ 1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f, }},
+    {{ 1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f, }},
+    {{ 1.250000000e-01f,  1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f, }},
+    {{ 1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f,  1.250000000e-01f, }},
+    {{ 1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f, -1.250000000e-01f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,8> FirstOrderEncoder{{
+    CalcAmbiCoeffs( inv_sqrt3f,  inv_sqrt3f,  inv_sqrt3f),
+    CalcAmbiCoeffs( inv_sqrt3f,  inv_sqrt3f, -inv_sqrt3f),
+    CalcAmbiCoeffs(-inv_sqrt3f,  inv_sqrt3f,  inv_sqrt3f),
+    CalcAmbiCoeffs(-inv_sqrt3f,  inv_sqrt3f, -inv_sqrt3f),
+    CalcAmbiCoeffs( inv_sqrt3f, -inv_sqrt3f,  inv_sqrt3f),
+    CalcAmbiCoeffs( inv_sqrt3f, -inv_sqrt3f, -inv_sqrt3f),
+    CalcAmbiCoeffs(-inv_sqrt3f, -inv_sqrt3f,  inv_sqrt3f),
+    CalcAmbiCoeffs(-inv_sqrt3f, -inv_sqrt3f, -inv_sqrt3f),
+}};
+static_assert(FirstOrderDecoder.size() == FirstOrderEncoder.size(), "First-order mismatch");
+
+/* This calculates a 2D first-order "upsampler" matrix. Same as the first-order
+ * matrix, just using a more optimized speaker array for horizontal-only
+ * content.
+ */
+constexpr std::array<std::array<float,4>,4> FirstOrder2DDecoder{{
+    {{ 2.500000000e-01f,  2.041241452e-01f, 0.0f,  2.041241452e-01f, }},
+    {{ 2.500000000e-01f,  2.041241452e-01f, 0.0f, -2.041241452e-01f, }},
+    {{ 2.500000000e-01f, -2.041241452e-01f, 0.0f,  2.041241452e-01f, }},
+    {{ 2.500000000e-01f, -2.041241452e-01f, 0.0f, -2.041241452e-01f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,4> FirstOrder2DEncoder{{
+    CalcAmbiCoeffs( inv_sqrt2f, 0.0f,  inv_sqrt2f),
+    CalcAmbiCoeffs( inv_sqrt2f, 0.0f, -inv_sqrt2f),
+    CalcAmbiCoeffs(-inv_sqrt2f, 0.0f,  inv_sqrt2f),
+    CalcAmbiCoeffs(-inv_sqrt2f, 0.0f, -inv_sqrt2f),
+}};
+static_assert(FirstOrder2DDecoder.size() == FirstOrder2DEncoder.size(), "First-order 2D mismatch");
+
+
+/* This calculates a second-order "upsampler" matrix. Same as the first-order
+ * matrix, just using a slightly more dense speaker array suitable for second-
+ * order content.
+ */
+constexpr std::array<std::array<float,9>,12> SecondOrderDecoder{{
+    {{ 8.333333333e-02f,  0.000000000e+00f, -7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f, -1.443375673e-01f,  1.167715449e-01f, }},
+    {{ 8.333333333e-02f, -1.227808683e-01f,  0.000000000e+00f,  7.588274978e-02f, -1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, }},
+    {{ 8.333333333e-02f, -7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, }},
+    {{ 8.333333333e-02f,  0.000000000e+00f,  7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f,  1.443375673e-01f,  1.167715449e-01f, }},
+    {{ 8.333333333e-02f, -1.227808683e-01f,  0.000000000e+00f, -7.588274978e-02f,  1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, }},
+    {{ 8.333333333e-02f,  7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, }},
+    {{ 8.333333333e-02f,  0.000000000e+00f, -7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f,  1.443375673e-01f,  1.167715449e-01f, }},
+    {{ 8.333333333e-02f,  1.227808683e-01f,  0.000000000e+00f, -7.588274978e-02f, -1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, }},
+    {{ 8.333333333e-02f,  7.588274978e-02f,  1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f,  1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, }},
+    {{ 8.333333333e-02f,  0.000000000e+00f,  7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f, -1.591525047e-02f, -1.443375673e-01f,  1.167715449e-01f, }},
+    {{ 8.333333333e-02f,  1.227808683e-01f,  0.000000000e+00f,  7.588274978e-02f,  1.443375673e-01f,  0.000000000e+00f, -9.316949906e-02f,  0.000000000e+00f, -7.216878365e-02f, }},
+    {{ 8.333333333e-02f, -7.588274978e-02f, -1.227808683e-01f,  0.000000000e+00f,  0.000000000e+00f,  1.443375673e-01f,  1.090847495e-01f,  0.000000000e+00f, -4.460276122e-02f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,12> SecondOrderEncoder{{
+    CalcAmbiCoeffs( 0.000000000e+00f, -5.257311121e-01f,  8.506508084e-01f),
+    CalcAmbiCoeffs(-8.506508084e-01f,  0.000000000e+00f,  5.257311121e-01f),
+    CalcAmbiCoeffs(-5.257311121e-01f,  8.506508084e-01f,  0.000000000e+00f),
+    CalcAmbiCoeffs( 0.000000000e+00f,  5.257311121e-01f,  8.506508084e-01f),
+    CalcAmbiCoeffs(-8.506508084e-01f,  0.000000000e+00f, -5.257311121e-01f),
+    CalcAmbiCoeffs( 5.257311121e-01f, -8.506508084e-01f,  0.000000000e+00f),
+    CalcAmbiCoeffs( 0.000000000e+00f, -5.257311121e-01f, -8.506508084e-01f),
+    CalcAmbiCoeffs( 8.506508084e-01f,  0.000000000e+00f, -5.257311121e-01f),
+    CalcAmbiCoeffs( 5.257311121e-01f,  8.506508084e-01f,  0.000000000e+00f),
+    CalcAmbiCoeffs( 0.000000000e+00f,  5.257311121e-01f, -8.506508084e-01f),
+    CalcAmbiCoeffs( 8.506508084e-01f,  0.000000000e+00f,  5.257311121e-01f),
+    CalcAmbiCoeffs(-5.257311121e-01f, -8.506508084e-01f,  0.000000000e+00f),
+}};
+static_assert(SecondOrderDecoder.size() == SecondOrderEncoder.size(), "Second-order mismatch");
+
+/* This calculates a 2D second-order "upsampler" matrix. Same as the second-
+ * order matrix, just using a more optimized speaker array for horizontal-only
+ * content.
+ */
+constexpr std::array<std::array<float,9>,6> SecondOrder2DDecoder{{
+    {{ 1.666666667e-01f, -9.622504486e-02f, 0.0f,  1.666666667e-01f, -1.490711985e-01f, 0.0f, 0.0f, 0.0f,  8.606629658e-02f, }},
+    {{ 1.666666667e-01f, -1.924500897e-01f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, -1.721325932e-01f, }},
+    {{ 1.666666667e-01f, -9.622504486e-02f, 0.0f, -1.666666667e-01f,  1.490711985e-01f, 0.0f, 0.0f, 0.0f,  8.606629658e-02f, }},
+    {{ 1.666666667e-01f,  9.622504486e-02f, 0.0f, -1.666666667e-01f, -1.490711985e-01f, 0.0f, 0.0f, 0.0f,  8.606629658e-02f, }},
+    {{ 1.666666667e-01f,  1.924500897e-01f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, -1.721325932e-01f, }},
+    {{ 1.666666667e-01f,  9.622504486e-02f, 0.0f,  1.666666667e-01f,  1.490711985e-01f, 0.0f, 0.0f, 0.0f,  8.606629658e-02f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,6> SecondOrder2DEncoder{{
+    CalcAmbiCoeffs(-0.50000000000f, 0.0f,  0.86602540379f),
+    CalcAmbiCoeffs(-1.00000000000f, 0.0f,  0.00000000000f),
+    CalcAmbiCoeffs(-0.50000000000f, 0.0f, -0.86602540379f),
+    CalcAmbiCoeffs( 0.50000000000f, 0.0f, -0.86602540379f),
+    CalcAmbiCoeffs( 1.00000000000f, 0.0f,  0.00000000000f),
+    CalcAmbiCoeffs( 0.50000000000f, 0.0f,  0.86602540379f),
+}};
+static_assert(SecondOrder2DDecoder.size() == SecondOrder2DEncoder.size(),
+    "Second-order 2D mismatch");
+
+
+/* This calculates a third-order "upsampler" matrix. Same as the first-order
+ * matrix, just using a more dense speaker array suitable for third-order
+ * content.
+ */
+constexpr std::array<std::array<float,16>,20> ThirdOrderDecoder{{
+    {{ 5.000000000e-02f,  3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f, -1.256118221e-01f,  0.000000000e+00f,  1.126112056e-01f,  7.944389175e-02f,  0.000000000e+00f,  2.421151497e-02f,  0.000000000e+00f, }},
+    {{ 5.000000000e-02f, -3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f,  1.256118221e-01f,  0.000000000e+00f, -1.126112056e-01f,  7.944389175e-02f,  0.000000000e+00f,  2.421151497e-02f,  0.000000000e+00f, }},
+    {{ 5.000000000e-02f,  3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f, -1.256118221e-01f,  0.000000000e+00f,  1.126112056e-01f, -7.944389175e-02f,  0.000000000e+00f, -2.421151497e-02f,  0.000000000e+00f, }},
+    {{ 5.000000000e-02f, -3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f,  6.454972244e-02f,  9.045084972e-02f,  0.000000000e+00f, -1.232790000e-02f,  1.256118221e-01f,  0.000000000e+00f, -1.126112056e-01f, -7.944389175e-02f,  0.000000000e+00f, -2.421151497e-02f,  0.000000000e+00f, }},
+    {{ 5.000000000e-02f,  8.090169944e-02f,  0.000000000e+00f,  3.090169944e-02f,  6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f, -7.763237543e-02f,  0.000000000e+00f, -2.950836627e-02f,  0.000000000e+00f, -1.497759251e-01f,  0.000000000e+00f, -7.763237543e-02f, }},
+    {{ 5.000000000e-02f,  8.090169944e-02f,  0.000000000e+00f, -3.090169944e-02f, -6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f, -7.763237543e-02f,  0.000000000e+00f, -2.950836627e-02f,  0.000000000e+00f,  1.497759251e-01f,  0.000000000e+00f,  7.763237543e-02f, }},
+    {{ 5.000000000e-02f, -8.090169944e-02f,  0.000000000e+00f,  3.090169944e-02f, -6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f,  7.763237543e-02f,  0.000000000e+00f,  2.950836627e-02f,  0.000000000e+00f, -1.497759251e-01f,  0.000000000e+00f, -7.763237543e-02f, }},
+    {{ 5.000000000e-02f, -8.090169944e-02f,  0.000000000e+00f, -3.090169944e-02f,  6.454972244e-02f,  0.000000000e+00f, -5.590169944e-02f,  0.000000000e+00f, -7.216878365e-02f,  7.763237543e-02f,  0.000000000e+00f,  2.950836627e-02f,  0.000000000e+00f,  1.497759251e-01f,  0.000000000e+00f,  7.763237543e-02f, }},
+    {{ 5.000000000e-02f,  0.000000000e+00f,  3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f,  6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  3.034486645e-02f, -6.779013272e-02f,  1.659481923e-01f,  4.797944664e-02f, }},
+    {{ 5.000000000e-02f,  0.000000000e+00f,  3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f, -6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f,  3.034486645e-02f,  6.779013272e-02f,  1.659481923e-01f, -4.797944664e-02f, }},
+    {{ 5.000000000e-02f,  0.000000000e+00f, -3.090169944e-02f,  8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f, -6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -3.034486645e-02f, -6.779013272e-02f, -1.659481923e-01f,  4.797944664e-02f, }},
+    {{ 5.000000000e-02f,  0.000000000e+00f, -3.090169944e-02f, -8.090169944e-02f,  0.000000000e+00f,  0.000000000e+00f, -3.454915028e-02f,  6.454972244e-02f,  8.449668365e-02f,  0.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f, -3.034486645e-02f,  6.779013272e-02f, -1.659481923e-01f, -4.797944664e-02f, }},
+    {{ 5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f,  6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f,  6.338656910e-02f, -1.092600649e-02f, -7.364853795e-02f,  1.011266756e-01f, -7.086833869e-02f, -1.482646439e-02f, }},
+    {{ 5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f, -6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f, -6.338656910e-02f, -1.092600649e-02f, -7.364853795e-02f, -1.011266756e-01f, -7.086833869e-02f,  1.482646439e-02f, }},
+    {{ 5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f,  5.000000000e-02f, -6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f, -6.338656910e-02f,  1.092600649e-02f, -7.364853795e-02f,  1.011266756e-01f, -7.086833869e-02f, -1.482646439e-02f, }},
+    {{ 5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f,  6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f,  6.338656910e-02f,  1.092600649e-02f, -7.364853795e-02f, -1.011266756e-01f, -7.086833869e-02f,  1.482646439e-02f, }},
+    {{ 5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f,  6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f, -6.338656910e-02f, -1.092600649e-02f,  7.364853795e-02f,  1.011266756e-01f,  7.086833869e-02f, -1.482646439e-02f, }},
+    {{ 5.000000000e-02f,  5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f, -6.454972244e-02f, -6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f,  1.016220987e-01f,  6.338656910e-02f, -1.092600649e-02f,  7.364853795e-02f, -1.011266756e-01f,  7.086833869e-02f,  1.482646439e-02f, }},
+    {{ 5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f,  5.000000000e-02f, -6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f, -6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f,  6.338656910e-02f,  1.092600649e-02f,  7.364853795e-02f,  1.011266756e-01f,  7.086833869e-02f, -1.482646439e-02f, }},
+    {{ 5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f, -5.000000000e-02f,  6.454972244e-02f,  6.454972244e-02f,  0.000000000e+00f,  6.454972244e-02f,  0.000000000e+00f, -1.016220987e-01f, -6.338656910e-02f,  1.092600649e-02f,  7.364853795e-02f, -1.011266756e-01f,  7.086833869e-02f,  1.482646439e-02f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,20> ThirdOrderEncoder{{
+    CalcAmbiCoeffs( 0.35682208976f,  0.93417235897f,  0.00000000000f),
+    CalcAmbiCoeffs(-0.35682208976f,  0.93417235897f,  0.00000000000f),
+    CalcAmbiCoeffs( 0.35682208976f, -0.93417235897f,  0.00000000000f),
+    CalcAmbiCoeffs(-0.35682208976f, -0.93417235897f,  0.00000000000f),
+    CalcAmbiCoeffs( 0.93417235897f,  0.00000000000f,  0.35682208976f),
+    CalcAmbiCoeffs( 0.93417235897f,  0.00000000000f, -0.35682208976f),
+    CalcAmbiCoeffs(-0.93417235897f,  0.00000000000f,  0.35682208976f),
+    CalcAmbiCoeffs(-0.93417235897f,  0.00000000000f, -0.35682208976f),
+    CalcAmbiCoeffs( 0.00000000000f,  0.35682208976f,  0.93417235897f),
+    CalcAmbiCoeffs( 0.00000000000f,  0.35682208976f, -0.93417235897f),
+    CalcAmbiCoeffs( 0.00000000000f, -0.35682208976f,  0.93417235897f),
+    CalcAmbiCoeffs( 0.00000000000f, -0.35682208976f, -0.93417235897f),
+    CalcAmbiCoeffs(     inv_sqrt3f,      inv_sqrt3f,      inv_sqrt3f),
+    CalcAmbiCoeffs(     inv_sqrt3f,      inv_sqrt3f,     -inv_sqrt3f),
+    CalcAmbiCoeffs(    -inv_sqrt3f,      inv_sqrt3f,      inv_sqrt3f),
+    CalcAmbiCoeffs(    -inv_sqrt3f,      inv_sqrt3f,     -inv_sqrt3f),
+    CalcAmbiCoeffs(     inv_sqrt3f,     -inv_sqrt3f,      inv_sqrt3f),
+    CalcAmbiCoeffs(     inv_sqrt3f,     -inv_sqrt3f,     -inv_sqrt3f),
+    CalcAmbiCoeffs(    -inv_sqrt3f,     -inv_sqrt3f,      inv_sqrt3f),
+    CalcAmbiCoeffs(    -inv_sqrt3f,     -inv_sqrt3f,     -inv_sqrt3f),
+}};
+static_assert(ThirdOrderDecoder.size() == ThirdOrderEncoder.size(), "Third-order mismatch");
+
+/* This calculates a 2D third-order "upsampler" matrix. Same as the third-order
+ * matrix, just using a more optimized speaker array for horizontal-only
+ * content.
+ */
+constexpr std::array<std::array<float,16>,8> ThirdOrder2DDecoder{{
+    {{ 1.250000000e-01f, -5.523559567e-02f, 0.0f,  1.333505242e-01f, -9.128709292e-02f, 0.0f, 0.0f, 0.0f,  9.128709292e-02f, -1.104247249e-01f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  4.573941867e-02f, }},
+    {{ 1.250000000e-01f, -1.333505242e-01f, 0.0f,  5.523559567e-02f, -9.128709292e-02f, 0.0f, 0.0f, 0.0f, -9.128709292e-02f,  4.573941867e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.104247249e-01f, }},
+    {{ 1.250000000e-01f, -1.333505242e-01f, 0.0f, -5.523559567e-02f,  9.128709292e-02f, 0.0f, 0.0f, 0.0f, -9.128709292e-02f,  4.573941867e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  1.104247249e-01f, }},
+    {{ 1.250000000e-01f, -5.523559567e-02f, 0.0f, -1.333505242e-01f,  9.128709292e-02f, 0.0f, 0.0f, 0.0f,  9.128709292e-02f, -1.104247249e-01f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -4.573941867e-02f, }},
+    {{ 1.250000000e-01f,  5.523559567e-02f, 0.0f, -1.333505242e-01f, -9.128709292e-02f, 0.0f, 0.0f, 0.0f,  9.128709292e-02f,  1.104247249e-01f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -4.573941867e-02f, }},
+    {{ 1.250000000e-01f,  1.333505242e-01f, 0.0f, -5.523559567e-02f, -9.128709292e-02f, 0.0f, 0.0f, 0.0f, -9.128709292e-02f, -4.573941867e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  1.104247249e-01f, }},
+    {{ 1.250000000e-01f,  1.333505242e-01f, 0.0f,  5.523559567e-02f,  9.128709292e-02f, 0.0f, 0.0f, 0.0f, -9.128709292e-02f, -4.573941867e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.104247249e-01f, }},
+    {{ 1.250000000e-01f,  5.523559567e-02f, 0.0f,  1.333505242e-01f,  9.128709292e-02f, 0.0f, 0.0f, 0.0f,  9.128709292e-02f,  1.104247249e-01f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  4.573941867e-02f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,8> ThirdOrder2DEncoder{{
+    CalcAmbiCoeffs(-0.38268343237f, 0.0f,  0.92387953251f),
+    CalcAmbiCoeffs(-0.92387953251f, 0.0f,  0.38268343237f),
+    CalcAmbiCoeffs(-0.92387953251f, 0.0f, -0.38268343237f),
+    CalcAmbiCoeffs(-0.38268343237f, 0.0f, -0.92387953251f),
+    CalcAmbiCoeffs( 0.38268343237f, 0.0f, -0.92387953251f),
+    CalcAmbiCoeffs( 0.92387953251f, 0.0f, -0.38268343237f),
+    CalcAmbiCoeffs( 0.92387953251f, 0.0f,  0.38268343237f),
+    CalcAmbiCoeffs( 0.38268343237f, 0.0f,  0.92387953251f),
+}};
+static_assert(ThirdOrder2DDecoder.size() == ThirdOrder2DEncoder.size(), "Third-order 2D mismatch");
+
+
+/* This calculates a 2D fourth-order "upsampler" matrix. There is no 3D fourth-
+ * order upsampler since fourth-order is the max order we'll be supporting for
+ * the foreseeable future. This is only necessary for mixing horizontal-only
+ * fourth-order content to 3D.
+ */
+constexpr std::array<std::array<float,25>,10> FourthOrder2DDecoder{{
+    {{ 1.000000000e-01f,  3.568220898e-02f, 0.0f,  1.098185471e-01f,  6.070619982e-02f, 0.0f, 0.0f, 0.0f,  8.355491589e-02f,  7.735682057e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  5.620301997e-02f,  8.573754253e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  2.785781628e-02f, }},
+    {{ 1.000000000e-01f,  9.341723590e-02f, 0.0f,  6.787159473e-02f,  9.822469464e-02f, 0.0f, 0.0f, 0.0f, -3.191513794e-02f,  2.954767620e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -9.093839659e-02f, -5.298871540e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -7.293270986e-02f, }},
+    {{ 1.000000000e-01f,  1.154700538e-01f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, -1.032795559e-01f, -9.561828875e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  9.014978717e-02f, }},
+    {{ 1.000000000e-01f,  9.341723590e-02f, 0.0f, -6.787159473e-02f, -9.822469464e-02f, 0.0f, 0.0f, 0.0f, -3.191513794e-02f,  2.954767620e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  9.093839659e-02f,  5.298871540e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -7.293270986e-02f, }},
+    {{ 1.000000000e-01f,  3.568220898e-02f, 0.0f, -1.098185471e-01f, -6.070619982e-02f, 0.0f, 0.0f, 0.0f,  8.355491589e-02f,  7.735682057e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -5.620301997e-02f, -8.573754253e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  2.785781628e-02f, }},
+    {{ 1.000000000e-01f, -3.568220898e-02f, 0.0f, -1.098185471e-01f,  6.070619982e-02f, 0.0f, 0.0f, 0.0f,  8.355491589e-02f, -7.735682057e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -5.620301997e-02f,  8.573754253e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  2.785781628e-02f, }},
+    {{ 1.000000000e-01f, -9.341723590e-02f, 0.0f, -6.787159473e-02f,  9.822469464e-02f, 0.0f, 0.0f, 0.0f, -3.191513794e-02f, -2.954767620e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  9.093839659e-02f, -5.298871540e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -7.293270986e-02f, }},
+    {{ 1.000000000e-01f, -1.154700538e-01f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, -1.032795559e-01f,  9.561828875e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000000e+00f,  0.000000000e+00f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  9.014978717e-02f, }},
+    {{ 1.000000000e-01f, -9.341723590e-02f, 0.0f,  6.787159473e-02f, -9.822469464e-02f, 0.0f, 0.0f, 0.0f, -3.191513794e-02f, -2.954767620e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -9.093839659e-02f,  5.298871540e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -7.293270986e-02f, }},
+    {{ 1.000000000e-01f, -3.568220898e-02f, 0.0f,  1.098185471e-01f, -6.070619982e-02f, 0.0f, 0.0f, 0.0f,  8.355491589e-02f, -7.735682057e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  5.620301997e-02f, -8.573754253e-02f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  2.785781628e-02f, }},
+}};
+constexpr std::array<AmbiChannelFloatArray,10> FourthOrder2DEncoder{{
+    CalcAmbiCoeffs( 3.090169944e-01f,  0.000000000e+00f,  9.510565163e-01f),
+    CalcAmbiCoeffs( 8.090169944e-01f,  0.000000000e+00f,  5.877852523e-01f),
+    CalcAmbiCoeffs( 1.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f),
+    CalcAmbiCoeffs( 8.090169944e-01f,  0.000000000e+00f, -5.877852523e-01f),
+    CalcAmbiCoeffs( 3.090169944e-01f,  0.000000000e+00f, -9.510565163e-01f),
+    CalcAmbiCoeffs(-3.090169944e-01f,  0.000000000e+00f, -9.510565163e-01f),
+    CalcAmbiCoeffs(-8.090169944e-01f,  0.000000000e+00f, -5.877852523e-01f),
+    CalcAmbiCoeffs(-1.000000000e+00f,  0.000000000e+00f,  0.000000000e+00f),
+    CalcAmbiCoeffs(-8.090169944e-01f,  0.000000000e+00f,  5.877852523e-01f),
+    CalcAmbiCoeffs(-3.090169944e-01f,  0.000000000e+00f,  9.510565163e-01f),
+}};
+static_assert(FourthOrder2DDecoder.size() == FourthOrder2DEncoder.size(), "Fourth-order 2D mismatch");
+
+
+template<size_t N, size_t M>
+auto CalcAmbiUpsampler(const std::array<std::array<float,N>,M> &decoder,
+    const std::array<AmbiChannelFloatArray,M> &encoder)
+{
+    std::array<AmbiChannelFloatArray,N> res{};
+
+    for(size_t i{0};i < decoder[0].size();++i)
+    {
+        for(size_t j{0};j < encoder[0].size();++j)
+        {
+            double sum{0.0};
+            for(size_t k{0};k < decoder.size();++k)
+                sum += double{decoder[k][i]} * encoder[k][j];
+            res[i][j] = static_cast<float>(sum);
+        }
+    }
+
+    return res;
+}
+
+} // namespace
+
+const std::array<AmbiChannelFloatArray,4> AmbiScale::FirstOrderUp{CalcAmbiUpsampler(FirstOrderDecoder, FirstOrderEncoder)};
+const std::array<AmbiChannelFloatArray,4> AmbiScale::FirstOrder2DUp{CalcAmbiUpsampler(FirstOrder2DDecoder, FirstOrder2DEncoder)};
+const std::array<AmbiChannelFloatArray,9> AmbiScale::SecondOrderUp{CalcAmbiUpsampler(SecondOrderDecoder, SecondOrderEncoder)};
+const std::array<AmbiChannelFloatArray,9> AmbiScale::SecondOrder2DUp{CalcAmbiUpsampler(SecondOrder2DDecoder, SecondOrder2DEncoder)};
+const std::array<AmbiChannelFloatArray,16> AmbiScale::ThirdOrderUp{CalcAmbiUpsampler(ThirdOrderDecoder, ThirdOrderEncoder)};
+const std::array<AmbiChannelFloatArray,16> AmbiScale::ThirdOrder2DUp{CalcAmbiUpsampler(ThirdOrder2DDecoder, ThirdOrder2DEncoder)};
+const std::array<AmbiChannelFloatArray,25> AmbiScale::FourthOrder2DUp{CalcAmbiUpsampler(FourthOrder2DDecoder, FourthOrder2DEncoder)};
+
+
+std::array<float,MaxAmbiOrder+1> AmbiScale::GetHFOrderScales(const uint src_order,
+    const uint dev_order, const bool horizontalOnly) noexcept
+{
+    std::array<float,MaxAmbiOrder+1> res{};
+
+    if(!horizontalOnly)
+    {
+        for(size_t i{0};i < MaxAmbiOrder+1;++i)
+            res[i] = HFScales[src_order][i] / HFScales[dev_order][i];
+    }
+    else
+    {
+        for(size_t i{0};i < MaxAmbiOrder+1;++i)
+            res[i] = HFScales2D[src_order][i] / HFScales2D[dev_order][i];
+    }
+
+    return res;
+}
diff --git a/core/ambidefs.h b/core/ambidefs.h
new file mode 100644
index 00000000..b7d2bcd1
--- /dev/null
+++ b/core/ambidefs.h
@@ -0,0 +1,250 @@
+#ifndef CORE_AMBIDEFS_H
+#define CORE_AMBIDEFS_H
+
+#include <array>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "alnumbers.h"
+
+
+using uint = unsigned int;
+
+/* The maximum number of Ambisonics channels. For a given order (o), the size
+ * needed will be (o+1)**2, thus zero-order has 1, first-order has 4, second-
+ * order has 9, third-order has 16, and fourth-order has 25.
+ */
+constexpr uint8_t MaxAmbiOrder{3};
+constexpr inline size_t AmbiChannelsFromOrder(size_t order) noexcept
+{ return (order+1) * (order+1); }
+constexpr size_t MaxAmbiChannels{AmbiChannelsFromOrder(MaxAmbiOrder)};
+
+/* A bitmask of ambisonic channels for 0 to 4th order. This only specifies up
+ * to 4th order, which is the highest order a 32-bit mask value can specify (a
+ * 64-bit mask could handle up to 7th order).
+ */
+constexpr uint Ambi0OrderMask{0x00000001};
+constexpr uint Ambi1OrderMask{0x0000000f};
+constexpr uint Ambi2OrderMask{0x000001ff};
+constexpr uint Ambi3OrderMask{0x0000ffff};
+constexpr uint Ambi4OrderMask{0x01ffffff};
+
+/* A bitmask of ambisonic channels with height information. If none of these
+ * channels are used/needed, there's no height (e.g. with most surround sound
+ * speaker setups). This is ACN ordering, with bit 0 being ACN 0, etc.
+ */
+constexpr uint AmbiPeriphonicMask{0xfe7ce4};
+
+/* The maximum number of ambisonic channels for 2D (non-periphonic)
+ * representation. This is 2 per each order above zero-order, plus 1 for zero-
+ * order. Or simply, o*2 + 1.
+ */
+constexpr inline size_t Ambi2DChannelsFromOrder(size_t order) noexcept
+{ return order*2 + 1; }
+constexpr size_t MaxAmbi2DChannels{Ambi2DChannelsFromOrder(MaxAmbiOrder)};
+
+
+/* NOTE: These are scale factors as applied to Ambisonics content. Decoder
+ * coefficients should be divided by these values to get proper scalings.
+ */
+struct AmbiScale {
+    static auto& FromN3D() noexcept
+    {
+        static constexpr const std::array<float,MaxAmbiChannels> ret{{
+            1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+            1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
+        }};
+        return ret;
+    }
+    static auto& FromSN3D() noexcept
+    {
+        static constexpr const std::array<float,MaxAmbiChannels> ret{{
+            1.000000000f, /* ACN  0, sqrt(1) */
+            1.732050808f, /* ACN  1, sqrt(3) */
+            1.732050808f, /* ACN  2, sqrt(3) */
+            1.732050808f, /* ACN  3, sqrt(3) */
+            2.236067978f, /* ACN  4, sqrt(5) */
+            2.236067978f, /* ACN  5, sqrt(5) */
+            2.236067978f, /* ACN  6, sqrt(5) */
+            2.236067978f, /* ACN  7, sqrt(5) */
+            2.236067978f, /* ACN  8, sqrt(5) */
+            2.645751311f, /* ACN  9, sqrt(7) */
+            2.645751311f, /* ACN 10, sqrt(7) */
+            2.645751311f, /* ACN 11, sqrt(7) */
+            2.645751311f, /* ACN 12, sqrt(7) */
+            2.645751311f, /* ACN 13, sqrt(7) */
+            2.645751311f, /* ACN 14, sqrt(7) */
+            2.645751311f, /* ACN 15, sqrt(7) */
+        }};
+        return ret;
+    }
+    static auto& FromFuMa() noexcept
+    {
+        static constexpr const std::array<float,MaxAmbiChannels> ret{{
+            1.414213562f, /* ACN  0 (W), sqrt(2) */
+            1.732050808f, /* ACN  1 (Y), sqrt(3) */
+            1.732050808f, /* ACN  2 (Z), sqrt(3) */
+            1.732050808f, /* ACN  3 (X), sqrt(3) */
+            1.936491673f, /* ACN  4 (V), sqrt(15)/2 */
+            1.936491673f, /* ACN  5 (T), sqrt(15)/2 */
+            2.236067978f, /* ACN  6 (R), sqrt(5) */
+            1.936491673f, /* ACN  7 (S), sqrt(15)/2 */
+            1.936491673f, /* ACN  8 (U), sqrt(15)/2 */
+            2.091650066f, /* ACN  9 (Q), sqrt(35/8) */
+            1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
+            2.231093404f, /* ACN 11 (M), sqrt(224/45) */
+            2.645751311f, /* ACN 12 (K), sqrt(7) */
+            2.231093404f, /* ACN 13 (L), sqrt(224/45) */
+            1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
+            2.091650066f, /* ACN 15 (P), sqrt(35/8) */
+        }};
+        return ret;
+    }
+    static auto& FromUHJ() noexcept
+    {
+        static constexpr const std::array<float,MaxAmbiChannels> ret{{
+            1.000000000f, /* ACN  0 (W), sqrt(1) */
+            1.224744871f, /* ACN  1 (Y), sqrt(3/2) */
+            1.224744871f, /* ACN  2 (Z), sqrt(3/2) */
+            1.224744871f, /* ACN  3 (X), sqrt(3/2) */
+            /* Higher orders not relevant for UHJ. */
+            1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+        }};
+        return ret;
+    }
+
+    /* Retrieves per-order HF scaling factors for "upsampling" ambisonic data. */
+    static std::array<float,MaxAmbiOrder+1> GetHFOrderScales(const uint src_order,
+        const uint dev_order, const bool horizontalOnly) noexcept;
+
+    static const std::array<std::array<float,MaxAmbiChannels>,4> FirstOrderUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,4> FirstOrder2DUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,9> SecondOrderUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,9> SecondOrder2DUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,16> ThirdOrderUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,16> ThirdOrder2DUp;
+    static const std::array<std::array<float,MaxAmbiChannels>,25> FourthOrder2DUp;
+};
+
+struct AmbiIndex {
+    static auto& FromFuMa() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
+            0,  /* W */
+            3,  /* X */
+            1,  /* Y */
+            2,  /* Z */
+            6,  /* R */
+            7,  /* S */
+            5,  /* T */
+            8,  /* U */
+            4,  /* V */
+            12, /* K */
+            13, /* L */
+            11, /* M */
+            14, /* N */
+            10, /* O */
+            15, /* P */
+            9,  /* Q */
+        }};
+        return ret;
+    }
+    static auto& FromFuMa2D() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
+            0,  /* W */
+            3,  /* X */
+            1,  /* Y */
+            8,  /* U */
+            4,  /* V */
+            15, /* P */
+            9,  /* Q */
+        }};
+        return ret;
+    }
+
+    static auto& FromACN() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
+            0,  1,  2,  3,  4,  5,  6,  7,
+            8,  9, 10, 11, 12, 13, 14, 15
+        }};
+        return ret;
+    }
+    static auto& FromACN2D() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
+            0, 1,3, 4,8, 9,15
+        }};
+        return ret;
+    }
+
+    static auto& OrderFromChannel() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
+            0, 1,1,1, 2,2,2,2,2, 3,3,3,3,3,3,3,
+        }};
+        return ret;
+    }
+    static auto& OrderFrom2DChannel() noexcept
+    {
+        static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
+            0, 1,1, 2,2, 3,3,
+        }};
+        return ret;
+    }
+};
+
+
+/**
+ * Calculates ambisonic encoder coefficients using the X, Y, and Z direction
+ * components, which must represent a normalized (unit length) vector.
+ *
+ * NOTE: The components use ambisonic coordinates. As a result:
+ *
+ * Ambisonic Y = OpenAL -X
+ * Ambisonic Z = OpenAL Y
+ * Ambisonic X = OpenAL -Z
+ *
+ * The components are ordered such that OpenAL's X, Y, and Z are the first,
+ * second, and third parameters respectively -- simply negate X and Z.
+ */
+constexpr auto CalcAmbiCoeffs(const float y, const float z, const float x)
+{
+    const float xx{x*x}, yy{y*y}, zz{z*z}, xy{x*y}, yz{y*z}, xz{x*z};
+
+    return std::array<float,MaxAmbiChannels>{{
+        /* Zeroth-order */
+        1.0f, /* ACN 0 = 1 */
+        /* First-order */
+        al::numbers::sqrt3_v<float> * y, /* ACN 1 = sqrt(3) * Y */
+        al::numbers::sqrt3_v<float> * z, /* ACN 2 = sqrt(3) * Z */
+        al::numbers::sqrt3_v<float> * x, /* ACN 3 = sqrt(3) * X */
+        /* Second-order */
+        3.872983346e+00f * xy,               /* ACN 4 = sqrt(15) * X * Y */
+        3.872983346e+00f * yz,               /* ACN 5 = sqrt(15) * Y * Z */
+        1.118033989e+00f * (3.0f*zz - 1.0f), /* ACN 6 = sqrt(5)/2 * (3*Z*Z - 1) */
+        3.872983346e+00f * xz,               /* ACN 7 = sqrt(15) * X * Z */
+        1.936491673e+00f * (xx - yy),        /* ACN 8 = sqrt(15)/2 * (X*X - Y*Y) */
+        /* Third-order */
+        2.091650066e+00f * (y*(3.0f*xx - yy)),   /* ACN  9 = sqrt(35/8) * Y * (3*X*X - Y*Y) */
+        1.024695076e+01f * (z*xy),               /* ACN 10 = sqrt(105) * Z * X * Y */
+        1.620185175e+00f * (y*(5.0f*zz - 1.0f)), /* ACN 11 = sqrt(21/8) * Y * (5*Z*Z - 1) */
+        1.322875656e+00f * (z*(5.0f*zz - 3.0f)), /* ACN 12 = sqrt(7)/2 * Z * (5*Z*Z - 3) */
+        1.620185175e+00f * (x*(5.0f*zz - 1.0f)), /* ACN 13 = sqrt(21/8) * X * (5*Z*Z - 1) */
+        5.123475383e+00f * (z*(xx - yy)),        /* ACN 14 = sqrt(105)/2 * Z * (X*X - Y*Y) */
+        2.091650066e+00f * (x*(xx - 3.0f*yy)),   /* ACN 15 = sqrt(35/8) * X * (X*X - 3*Y*Y) */
+        /* Fourth-order */
+        /* ACN 16 = sqrt(35)*3/2 * X * Y * (X*X - Y*Y) */
+        /* ACN 17 = sqrt(35/2)*3/2 * (3*X*X - Y*Y) * Y * Z */
+        /* ACN 18 = sqrt(5)*3/2 * X * Y * (7*Z*Z - 1) */
+        /* ACN 19 = sqrt(5/2)*3/2 * Y * Z * (7*Z*Z - 3) */
+        /* ACN 20 = 3/8 * (35*Z*Z*Z*Z - 30*Z*Z + 3) */
+        /* ACN 21 = sqrt(5/2)*3/2 * X * Z * (7*Z*Z - 3) */
+        /* ACN 22 = sqrt(5)*3/4 * (X*X - Y*Y) * (7*Z*Z - 1) */
+        /* ACN 23 = sqrt(35/2)*3/2 * (X*X - 3*Y*Y) * X * Z */
+        /* ACN 24 = sqrt(35)*3/8 * (X*X*X*X - 6*X*X*Y*Y + Y*Y*Y*Y) */
+    }};
+}
+
+#endif /* CORE_AMBIDEFS_H */
diff --git a/core/async_event.h b/core/async_event.h
new file mode 100644
index 00000000..5a2f5f91
--- /dev/null
+++ b/core/async_event.h
@@ -0,0 +1,55 @@
+#ifndef CORE_EVENT_H
+#define CORE_EVENT_H
+
+#include "almalloc.h"
+
+struct EffectState;
+
+using uint = unsigned int;
+
+
+struct AsyncEvent {
+    enum : uint {
+        /* User event types. */
+        SourceStateChange,
+        BufferCompleted,
+        Disconnected,
+        UserEventCount,
+
+        /* Internal events, always processed. */
+        ReleaseEffectState = 128,
+
+        /* End event thread processing. */
+        KillThread,
+    };
+
+    enum class SrcState {
+        Reset,
+        Stop,
+        Play,
+        Pause
+    };
+
+    const uint EnumType;
+    union {
+        char dummy;
+        struct {
+            uint id;
+            SrcState state;
+        } srcstate;
+        struct {
+            uint id;
+            uint count;
+        } bufcomp;
+        struct {
+            char msg[244];
+        } disconnect;
+        EffectState *mEffectState;
+    } u{};
+
+    constexpr AsyncEvent(uint type) noexcept : EnumType{type} { }
+
+    DISABLE_ALLOC()
+};
+
+#endif
diff --git a/core/bformatdec.cpp b/core/bformatdec.cpp
new file mode 100644
index 00000000..129b9976
--- /dev/null
+++ b/core/bformatdec.cpp
@@ -0,0 +1,170 @@
+
+#include "config.h"
+
+#include "bformatdec.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <utility>
+
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "filters/splitter.h"
+#include "front_stablizer.h"
+#include "mixer.h"
+#include "opthelpers.h"
+
+
+BFormatDec::BFormatDec(const size_t inchans, const al::span<const ChannelDec> coeffs,
+    const al::span<const ChannelDec> coeffslf, const float xover_f0norm,
+    std::unique_ptr<FrontStablizer> stablizer)
+    : mStablizer{std::move(stablizer)}, mDualBand{!coeffslf.empty()}, mChannelDec{inchans}
+{
+    if(!mDualBand)
+    {
+        for(size_t j{0};j < mChannelDec.size();++j)
+        {
+            float *outcoeffs{mChannelDec[j].mGains.Single};
+            for(const ChannelDec &incoeffs : coeffs)
+                *(outcoeffs++) = incoeffs[j];
+        }
+    }
+    else
+    {
+        mChannelDec[0].mXOver.init(xover_f0norm);
+        for(size_t j{1};j < mChannelDec.size();++j)
+            mChannelDec[j].mXOver = mChannelDec[0].mXOver;
+
+        for(size_t j{0};j < mChannelDec.size();++j)
+        {
+            float *outcoeffs{mChannelDec[j].mGains.Dual[sHFBand]};
+            for(const ChannelDec &incoeffs : coeffs)
+                *(outcoeffs++) = incoeffs[j];
+
+            outcoeffs = mChannelDec[j].mGains.Dual[sLFBand];
+            for(const ChannelDec &incoeffs : coeffslf)
+                *(outcoeffs++) = incoeffs[j];
+        }
+    }
+}
+
+
+void BFormatDec::process(const al::span<FloatBufferLine> OutBuffer,
+    const FloatBufferLine *InSamples, const size_t SamplesToDo)
+{
+    ASSUME(SamplesToDo > 0);
+
+    if(mDualBand)
+    {
+        const al::span<float> hfSamples{mSamples[sHFBand].data(), SamplesToDo};
+        const al::span<float> lfSamples{mSamples[sLFBand].data(), SamplesToDo};
+        for(auto &chandec : mChannelDec)
+        {
+            chandec.mXOver.process({InSamples->data(), SamplesToDo}, hfSamples.data(),
+                lfSamples.data());
+            MixSamples(hfSamples, OutBuffer, chandec.mGains.Dual[sHFBand],
+                chandec.mGains.Dual[sHFBand], 0, 0);
+            MixSamples(lfSamples, OutBuffer, chandec.mGains.Dual[sLFBand],
+                chandec.mGains.Dual[sLFBand], 0, 0);
+            ++InSamples;
+        }
+    }
+    else
+    {
+        for(auto &chandec : mChannelDec)
+        {
+            MixSamples({InSamples->data(), SamplesToDo}, OutBuffer, chandec.mGains.Single,
+                chandec.mGains.Single, 0, 0);
+            ++InSamples;
+        }
+    }
+}
+
+void BFormatDec::processStablize(const al::span<FloatBufferLine> OutBuffer,
+    const FloatBufferLine *InSamples, const size_t lidx, const size_t ridx, const size_t cidx,
+    const size_t SamplesToDo)
+{
+    ASSUME(SamplesToDo > 0);
+
+    /* Move the existing direct L/R signal out so it doesn't get processed by
+     * the stablizer.
+     */
+    float *RESTRICT mid{al::assume_aligned<16>(mStablizer->MidDirect.data())};
+    float *RESTRICT side{al::assume_aligned<16>(mStablizer->Side.data())};
+    for(size_t i{0};i < SamplesToDo;++i)
+    {
+        mid[i] = OutBuffer[lidx][i] + OutBuffer[ridx][i];
+        side[i] = OutBuffer[lidx][i] - OutBuffer[ridx][i];
+    }
+    std::fill_n(OutBuffer[lidx].begin(), SamplesToDo, 0.0f);
+    std::fill_n(OutBuffer[ridx].begin(), SamplesToDo, 0.0f);
+
+    /* Decode the B-Format input to OutBuffer. */
+    process(OutBuffer, InSamples, SamplesToDo);
+
+    /* Include the decoded side signal with the direct side signal. */
+    for(size_t i{0};i < SamplesToDo;++i)
+        side[i] += OutBuffer[lidx][i] - OutBuffer[ridx][i];
+
+    /* Get the decoded mid signal and band-split it. */
+    std::transform(OutBuffer[lidx].cbegin(), OutBuffer[lidx].cbegin()+SamplesToDo,
+        OutBuffer[ridx].cbegin(), mStablizer->Temp.begin(),
+        [](const float l, const float r) noexcept { return l + r; });
+
+    mStablizer->MidFilter.process({mStablizer->Temp.data(), SamplesToDo}, mStablizer->MidHF.data(),
+        mStablizer->MidLF.data());
+
+    /* Apply an all-pass to all channels to match the band-splitter's phase
+     * shift. This is to keep the phase synchronized between the existing
+     * signal and the split mid signal.
+     */
+    const size_t NumChannels{OutBuffer.size()};
+    for(size_t i{0u};i < NumChannels;i++)
+    {
+        /* Skip the left and right channels, which are going to get overwritten,
+         * and substitute the direct mid signal and direct+decoded side signal.
+         */
+        if(i == lidx)
+            mStablizer->ChannelFilters[i].processAllPass({mid, SamplesToDo});
+        else if(i == ridx)
+            mStablizer->ChannelFilters[i].processAllPass({side, SamplesToDo});
+        else
+            mStablizer->ChannelFilters[i].processAllPass({OutBuffer[i].data(), SamplesToDo});
+    }
+
+    /* This pans the separate low- and high-frequency signals between being on
+     * the center channel and the left+right channels. The low-frequency signal
+     * is panned 1/3rd toward center and the high-frequency signal is panned
+     * 1/4th toward center. These values can be tweaked.
+     */
+    const float cos_lf{std::cos(1.0f/3.0f * (al::numbers::pi_v<float>*0.5f))};
+    const float cos_hf{std::cos(1.0f/4.0f * (al::numbers::pi_v<float>*0.5f))};
+    const float sin_lf{std::sin(1.0f/3.0f * (al::numbers::pi_v<float>*0.5f))};
+    const float sin_hf{std::sin(1.0f/4.0f * (al::numbers::pi_v<float>*0.5f))};
+    for(size_t i{0};i < SamplesToDo;i++)
+    {
+        /* Add the direct mid signal to the processed mid signal so it can be
+         * properly combined with the direct+decoded side signal.
+         */
+        const float m{mStablizer->MidLF[i]*cos_lf + mStablizer->MidHF[i]*cos_hf + mid[i]};
+        const float c{mStablizer->MidLF[i]*sin_lf + mStablizer->MidHF[i]*sin_hf};
+        const float s{side[i]};
+
+        /* The generated center channel signal adds to the existing signal,
+         * while the modified left and right channels replace.
+         */
+        OutBuffer[lidx][i] = (m + s) * 0.5f;
+        OutBuffer[ridx][i] = (m - s) * 0.5f;
+        OutBuffer[cidx][i] += c * 0.5f;
+    }
+}
+
+
+std::unique_ptr<BFormatDec> BFormatDec::Create(const size_t inchans,
+    const al::span<const ChannelDec> coeffs, const al::span<const ChannelDec> coeffslf,
+    const float xover_f0norm, std::unique_ptr<FrontStablizer> stablizer)
+{
+    return std::make_unique<BFormatDec>(inchans, coeffs, coeffslf, xover_f0norm,
+        std::move(stablizer));
+}
diff --git a/core/bformatdec.h b/core/bformatdec.h
new file mode 100644
index 00000000..7a27a5a4
--- /dev/null
+++ b/core/bformatdec.h
@@ -0,0 +1,71 @@
+#ifndef CORE_BFORMATDEC_H
+#define CORE_BFORMATDEC_H
+
+#include <array>
+#include <cstddef>
+#include <memory>
+
+#include "almalloc.h"
+#include "alspan.h"
+#include "ambidefs.h"
+#include "bufferline.h"
+#include "devformat.h"
+#include "filters/splitter.h"
+#include "vector.h"
+
+struct FrontStablizer;
+
+
+using ChannelDec = std::array<float,MaxAmbiChannels>;
+
+class BFormatDec {
+    static constexpr size_t sHFBand{0};
+    static constexpr size_t sLFBand{1};
+    static constexpr size_t sNumBands{2};
+
+    struct ChannelDecoder {
+        union MatrixU {
+            float Dual[sNumBands][MAX_OUTPUT_CHANNELS];
+            float Single[MAX_OUTPUT_CHANNELS];
+        } mGains{};
+
+        /* NOTE: BandSplitter filter is unused with single-band decoding. */
+        BandSplitter mXOver;
+    };
+
+    alignas(16) std::array<FloatBufferLine,2> mSamples;
+
+    const std::unique_ptr<FrontStablizer> mStablizer;
+    const bool mDualBand{false};
+
+    /* TODO: This should ideally be a FlexArray, since ChannelDecoder is rather
+     * small and only a few are needed (3, 4, 5, 7, typically). But that can
+     * only be used in a standard layout struct, and a std::unique_ptr member
+     * (mStablizer) causes GCC and Clang to warn it's not.
+     */
+    al::vector<ChannelDecoder> mChannelDec;
+
+public:
+    BFormatDec(const size_t inchans, const al::span<const ChannelDec> coeffs,
+        const al::span<const ChannelDec> coeffslf, const float xover_f0norm,
+        std::unique_ptr<FrontStablizer> stablizer);
+
+    bool hasStablizer() const noexcept { return mStablizer != nullptr; }
+
+    /* Decodes the ambisonic input to the given output channels. */
+    void process(const al::span<FloatBufferLine> OutBuffer, const FloatBufferLine *InSamples,
+        const size_t SamplesToDo);
+
+    /* Decodes the ambisonic input to the given output channels with stablization. */
+    void processStablize(const al::span<FloatBufferLine> OutBuffer,
+        const FloatBufferLine *InSamples, const size_t lidx, const size_t ridx, const size_t cidx,
+        const size_t SamplesToDo);
+
+    static std::unique_ptr<BFormatDec> Create(const size_t inchans,
+        const al::span<const ChannelDec> coeffs, const al::span<const ChannelDec> coeffslf,
+        const float xover_f0norm, std::unique_ptr<FrontStablizer> stablizer);
+
+    DEF_NEWDEL(BFormatDec)
+};
+
+#endif /* CORE_BFORMATDEC_H */
diff --git a/alc/bs2b.cpp b/core/bs2b.cpp
index 00207bc0..303bf9bd 100644
--- a/alc/bs2b.cpp
+++ b/core/bs2b.cpp
@@ -27,8 +27,8 @@
 #include <cmath>
 #include <iterator>
 
+#include "alnumbers.h"
 #include "bs2b.h"
-#include "math_defs.h"
 
 
 /* Set up all data. */
@@ -91,11 +91,11 @@ static void init(struct bs2b *bs2b)
      * $d  = 1 / 2 / pi / $fc;
      * $x  = exp(-1 / $d);
      */
-    x           = std::exp(-al::MathDefs<float>::Tau() * Fc_lo / static_cast<float>(bs2b->srate));
+    x           = std::exp(-al::numbers::pi_v<float>*2.0f*Fc_lo/static_cast<float>(bs2b->srate));
     bs2b->b1_lo = x;
     bs2b->a0_lo = G_lo * (1.0f - x) * g;
 
-    x           = std::exp(-al::MathDefs<float>::Tau() * Fc_hi / static_cast<float>(bs2b->srate));
+    x           = std::exp(-al::numbers::pi_v<float>*2.0f*Fc_hi/static_cast<float>(bs2b->srate));
     bs2b->b1_hi = x;
     bs2b->a0_hi = (1.0f - G_hi * (1.0f - x)) * g;
     bs2b->a1_hi = -x * g;
diff --git a/alc/bs2b.h b/core/bs2b.h
index df717cd4..4d0b9dd8 100644
--- a/alc/bs2b.h
+++ b/core/bs2b.h
@@ -21,8 +21,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef BS2B_H
-#define BS2B_H
+#ifndef CORE_BS2B_H
+#define CORE_BS2B_H
 
 #include "almalloc.h"
 
@@ -86,4 +86,4 @@ void bs2b_clear(bs2b *bs2b);
 
 void bs2b_cross_feed(bs2b *bs2b, float *Left, float *Right, size_t SamplesToDo);
 
-#endif /* BS2B_H */
+#endif /* CORE_BS2B_H */
diff --git a/core/bsinc_defs.h b/core/bsinc_defs.h
new file mode 100644
index 00000000..01bd3c29
--- /dev/null
+++ b/core/bsinc_defs.h
@@ -0,0 +1,12 @@
+#ifndef CORE_BSINC_DEFS_H
+#define CORE_BSINC_DEFS_H
+
+/* The number of distinct scale and phase intervals within the bsinc filter
+ * tables.
+ */
+constexpr unsigned int BSincScaleBits{4};
+constexpr unsigned int BSincScaleCount{1 << BSincScaleBits};
+constexpr unsigned int BSincPhaseBits{5};
+constexpr unsigned int BSincPhaseCount{1 << BSincPhaseBits};
+
+#endif /* CORE_BSINC_DEFS_H */
diff --git a/core/bsinc_tables.cpp b/core/bsinc_tables.cpp
new file mode 100644
index 00000000..693645f4
--- /dev/null
+++ b/core/bsinc_tables.cpp
@@ -0,0 +1,295 @@
+
+#include "bsinc_tables.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+
+#include "alnumbers.h"
+#include "core/mixer/defs.h"
+
+
+namespace {
+
+using uint = unsigned int;
+
+
+/* This is the normalized cardinal sine (sinc) function.
+ *
+ *   sinc(x) = { 1,                   x = 0
+ *             { sin(pi x) / (pi x),  otherwise.
+ */
+constexpr double Sinc(const double x)
+{
+    constexpr double epsilon{std::numeric_limits<double>::epsilon()};
+    if(!(x > epsilon || x < -epsilon))
+        return 1.0;
+    return std::sin(al::numbers::pi*x) / (al::numbers::pi*x);
+}
+
+/* The zero-order modified Bessel function of the first kind, used for the
+ * Kaiser window.
+ *
+ *   I_0(x) = sum_{k=0}^inf (1 / k!)^2 (x / 2)^(2 k)
+ *          = sum_{k=0}^inf ((x / 2)^k / k!)^2
+ */
+constexpr double BesselI_0(const double x) noexcept
+{
+    /* Start at k=1 since k=0 is trivial. */
+    const double x2{x / 2.0};
+    double term{1.0};
+    double sum{1.0};
+    double last_sum{};
+    int k{1};
+
+    /* Let the integration converge until the term of the sum is no longer
+     * significant.
+     */
+    do {
+        const double y{x2 / k};
+        ++k;
+        last_sum = sum;
+        term *= y * y;
+        sum += term;
+    } while(sum != last_sum);
+
+    return sum;
+}
+
+/* Calculate a Kaiser window from the given beta value and a normalized k
+ * [-1, 1].
+ *
+ *   w(k) = { I_0(B sqrt(1 - k^2)) / I_0(B),  -1 <= k <= 1
+ *          { 0,                              elsewhere.
+ *
+ * Where k can be calculated as:
+ *
+ *   k = i / l,         where -l <= i <= l.
+ *
+ * or:
+ *
+ *   k = 2 i / M - 1,   where 0 <= i <= M.
+ */
+constexpr double Kaiser(const double beta, const double k, const double besseli_0_beta)
+{
+    if(!(k >= -1.0 && k <= 1.0))
+        return 0.0;
+    return BesselI_0(beta * std::sqrt(1.0 - k*k)) / besseli_0_beta;
+}
+
+/* Calculates the (normalized frequency) transition width of the Kaiser window.
+ * Rejection is in dB.
+ */
+constexpr double CalcKaiserWidth(const double rejection, const uint order) noexcept
+{
+    if(rejection > 21.19)
+        return (rejection - 7.95) / (2.285 * al::numbers::pi*2.0 * order);
+    /* This enforces a minimum rejection of just above 21.18dB */
+    return 5.79 / (al::numbers::pi*2.0 * order);
+}
+
+/* Calculates the beta value of the Kaiser window. Rejection is in dB. */
+constexpr double CalcKaiserBeta(const double rejection)
+{
+    if(rejection > 50.0)
+        return 0.1102 * (rejection-8.7);
+    else if(rejection >= 21.0)
+        return (0.5842 * std::pow(rejection-21.0, 0.4)) + (0.07886 * (rejection-21.0));
+    return 0.0;
+}
+
+
+struct BSincHeader {
+    double width{};
+    double beta{};
+    double scaleBase{};
+    double scaleRange{};
+    double besseli_0_beta{};
+
+    uint a[BSincScaleCount]{};
+    uint total_size{};
+
+    constexpr BSincHeader(uint Rejection, uint Order) noexcept
+    {
+        width = CalcKaiserWidth(Rejection, Order);
+        beta = CalcKaiserBeta(Rejection);
+        scaleBase = width / 2.0;
+        scaleRange = 1.0 - scaleBase;
+        besseli_0_beta = BesselI_0(beta);
+
+        uint num_points{Order+1};
+        for(uint si{0};si < BSincScaleCount;++si)
+        {
+            const double scale{scaleBase + (scaleRange * (si+1) / BSincScaleCount)};
+            const uint a_{std::min(static_cast<uint>(num_points / 2.0 / scale), num_points)};
+            const uint m{2 * a_};
+
+            a[si] = a_;
+            total_size += 4 * BSincPhaseCount * ((m+3) & ~3u);
+        }
+    }
+};
+
+/* 11th and 23rd order filters (12 and 24-point respectively) with a 60dB drop
+ * at nyquist. Each filter will scale up the order when downsampling, to 23rd
+ * and 47th order respectively.
+ */
+constexpr BSincHeader bsinc12_hdr{60, 11};
+constexpr BSincHeader bsinc24_hdr{60, 23};
+
+
+/* NOTE: GCC 5 has an issue with BSincHeader objects being in an anonymous
+ * namespace while also being used as non-type template parameters.
+ */
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 6
+
+/* The number of sample points is double the a value (rounded up to a multiple
+ * of 4), and scale index 0 includes the doubling for downsampling. bsinc24 is
+ * currently the highest quality filter, and will use the most sample points.
+ */
+constexpr uint BSincPointsMax{(bsinc24_hdr.a[0]*2 + 3) & ~3u};
+static_assert(BSincPointsMax <= MaxResamplerPadding, "MaxResamplerPadding is too small");
+
+template<size_t total_size>
+struct BSincFilterArray {
+    alignas(16) std::array<float, total_size> mTable;
+    const BSincHeader &hdr;
+
+    BSincFilterArray(const BSincHeader &hdr_) : hdr{hdr_}
+    {
+#else
+template<const BSincHeader &hdr>
+struct BSincFilterArray {
+    alignas(16) std::array<float, hdr.total_size> mTable{};
+
+    BSincFilterArray()
+    {
+        constexpr uint BSincPointsMax{(hdr.a[0]*2 + 3) & ~3u};
+        static_assert(BSincPointsMax <= MaxResamplerPadding, "MaxResamplerPadding is too small");
+#endif
+        using filter_type = double[BSincPhaseCount+1][BSincPointsMax];
+        auto filter = std::make_unique<filter_type[]>(BSincScaleCount);
+
+        /* Calculate the Kaiser-windowed Sinc filter coefficients for each
+         * scale and phase index.
+         */
+        for(uint si{0};si < BSincScaleCount;++si)
+        {
+            const uint m{hdr.a[si] * 2};
+            const size_t o{(BSincPointsMax-m) / 2};
+            const double scale{hdr.scaleBase + (hdr.scaleRange * (si+1) / BSincScaleCount)};
+            const double cutoff{scale - (hdr.scaleBase * std::max(1.0, scale*2.0))};
+            const auto a = static_cast<double>(hdr.a[si]);
+            const double l{a - 1.0/BSincPhaseCount};
+
+            /* Do one extra phase index so that the phase delta has a proper
+             * target for its last index.
+             */
+            for(uint pi{0};pi <= BSincPhaseCount;++pi)
+            {
+                const double phase{std::floor(l) + (pi/double{BSincPhaseCount})};
+
+                for(uint i{0};i < m;++i)
+                {
+                    const double x{i - phase};
+                    filter[si][pi][o+i] = Kaiser(hdr.beta, x/l, hdr.besseli_0_beta) * cutoff *
+                        Sinc(cutoff*x);
+                }
+            }
+        }
+
+        size_t idx{0};
+        for(size_t si{0};si < BSincScaleCount;++si)
+        {
+            const size_t m{((hdr.a[si]*2) + 3) & ~3u};
+            const size_t o{(BSincPointsMax-m) / 2};
+
+            /* Write out each phase index's filter and phase delta for this
+             * quality scale.
+             */
+            for(size_t pi{0};pi < BSincPhaseCount;++pi)
+            {
+                for(size_t i{0};i < m;++i)
+                    mTable[idx++] = static_cast<float>(filter[si][pi][o+i]);
+
+                /* Linear interpolation between phases is simplified by pre-
+                 * calculating the delta (b - a) in: x = a + f (b - a)
+                 */
+                for(size_t i{0};i < m;++i)
+                {
+                    const double phDelta{filter[si][pi+1][o+i] - filter[si][pi][o+i]};
+                    mTable[idx++] = static_cast<float>(phDelta);
+                }
+            }
+            /* Calculate and write out each phase index's filter quality scale
+             * deltas. The last scale index doesn't have any scale or scale-
+             * phase deltas.
+             */
+            if(si == BSincScaleCount-1)
+            {
+                for(size_t i{0};i < BSincPhaseCount*m*2;++i)
+                    mTable[idx++] = 0.0f;
+            }
+            else for(size_t pi{0};pi < BSincPhaseCount;++pi)
+            {
+                /* Linear interpolation between scales is also simplified.
+                 *
+                 * Given a difference in the number of points between scales,
+                 * the destination points will be 0, thus: x = a + f (-a)
+                 */
+                for(size_t i{0};i < m;++i)
+                {
+                    const double scDelta{filter[si+1][pi][o+i] - filter[si][pi][o+i]};
+                    mTable[idx++] = static_cast<float>(scDelta);
+                }
+
+                /* This last simplification is done to complete the bilinear
+                 * equation for the combination of phase and scale.
+                 */
+                for(size_t i{0};i < m;++i)
+                {
+                    const double spDelta{(filter[si+1][pi+1][o+i] - filter[si+1][pi][o+i]) -
+                        (filter[si][pi+1][o+i] - filter[si][pi][o+i])};
+                    mTable[idx++] = static_cast<float>(spDelta);
+                }
+            }
+        }
+        assert(idx == hdr.total_size);
+    }
+
+    constexpr const BSincHeader &getHeader() const noexcept { return hdr; }
+    constexpr const float *getTable() const noexcept { return &mTable.front(); }
+};
+
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 6
+const BSincFilterArray<bsinc12_hdr.total_size> bsinc12_filter{bsinc12_hdr};
+const BSincFilterArray<bsinc24_hdr.total_size> bsinc24_filter{bsinc24_hdr};
+#else
+const BSincFilterArray<bsinc12_hdr> bsinc12_filter{};
+const BSincFilterArray<bsinc24_hdr> bsinc24_filter{};
+#endif
+
+template<typename T>
+constexpr BSincTable GenerateBSincTable(const T &filter)
+{
+    BSincTable ret{};
+    const BSincHeader &hdr = filter.getHeader();
+    ret.scaleBase = static_cast<float>(hdr.scaleBase);
+    ret.scaleRange = static_cast<float>(1.0 / hdr.scaleRange);
+    for(size_t i{0};i < BSincScaleCount;++i)
+        ret.m[i] = ((hdr.a[i]*2) + 3) & ~3u;
+    ret.filterOffset[0] = 0;
+    for(size_t i{1};i < BSincScaleCount;++i)
+        ret.filterOffset[i] = ret.filterOffset[i-1] + ret.m[i-1]*4*BSincPhaseCount;
+    ret.Tab = filter.getTable();
+    return ret;
+}
+
+} // namespace
+
+const BSincTable gBSinc12{GenerateBSincTable(bsinc12_filter)};
+const BSincTable gBSinc24{GenerateBSincTable(bsinc24_filter)};
diff --git a/core/bsinc_tables.h b/core/bsinc_tables.h
new file mode 100644
index 00000000..aca4b274
--- /dev/null
+++ b/core/bsinc_tables.h
@@ -0,0 +1,17 @@
+#ifndef CORE_BSINC_TABLES_H
+#define CORE_BSINC_TABLES_H
+
+#include "bsinc_defs.h"
+
+
+struct BSincTable {
+    float scaleBase, scaleRange;
+    unsigned int m[BSincScaleCount];
+    unsigned int filterOffset[BSincScaleCount];
+    const float *Tab;
+};
+
+extern const BSincTable gBSinc12;
+extern const BSincTable gBSinc24;
+
+#endif /* CORE_BSINC_TABLES_H */
diff --git a/core/buffer_storage.cpp b/core/buffer_storage.cpp
new file mode 100644
index 00000000..98ca2c1b
--- /dev/null
+++ b/core/buffer_storage.cpp
@@ -0,0 +1,81 @@
+
+#include "config.h"
+
+#include "buffer_storage.h"
+
+#include <stdint.h>
+
+
+const char *NameFromFormat(FmtType type) noexcept
+{
+    switch(type)
+    {
+    case FmtUByte: return "UInt8";
+    case FmtShort: return "Int16";
+    case FmtFloat: return "Float";
+    case FmtDouble: return "Double";
+    case FmtMulaw: return "muLaw";
+    case FmtAlaw: return "aLaw";
+    case FmtIMA4: return "IMA4 ADPCM";
+    case FmtMSADPCM: return "MS ADPCM";
+    }
+    return "<internal error>";
+}
+
+const char *NameFromFormat(FmtChannels channels) noexcept
+{
+    switch(channels)
+    {
+    case FmtMono: return "Mono";
+    case FmtStereo: return "Stereo";
+    case FmtRear: return "Rear";
+    case FmtQuad: return "Quadraphonic";
+    case FmtX51: return "Surround 5.1";
+    case FmtX61: return "Surround 6.1";
+    case FmtX71: return "Surround 7.1";
+    case FmtBFormat2D: return "B-Format 2D";
+    case FmtBFormat3D: return "B-Format 3D";
+    case FmtUHJ2: return "UHJ2";
+    case FmtUHJ3: return "UHJ3";
+    case FmtUHJ4: return "UHJ4";
+    case FmtSuperStereo: return "Super Stereo";
+    }
+    return "<internal error>";
+}
+
+uint BytesFromFmt(FmtType type) noexcept
+{
+    switch(type)
+    {
+    case FmtUByte: return sizeof(uint8_t);
+    case FmtShort: return sizeof(int16_t);
+    case FmtFloat: return sizeof(float);
+    case FmtDouble: return sizeof(double);
+    case FmtMulaw: return sizeof(uint8_t);
+    case FmtAlaw: return sizeof(uint8_t);
+    case FmtIMA4: break;
+    case FmtMSADPCM: break;
+    }
+    return 0;
+}
+
+uint ChannelsFromFmt(FmtChannels chans, uint ambiorder) noexcept
+{
+    switch(chans)
+    {
+    case FmtMono: return 1;
+    case FmtStereo: return 2;
+    case FmtRear: return 2;
+    case FmtQuad: return 4;
+    case FmtX51: return 6;
+    case FmtX61: return 7;
+    case FmtX71: return 8;
+    case FmtBFormat2D: return (ambiorder*2) + 1;
+    case FmtBFormat3D: return (ambiorder+1) * (ambiorder+1);
+    case FmtUHJ2: return 2;
+    case FmtUHJ3: return 3;
+    case FmtUHJ4: return 4;
+    case FmtSuperStereo: return 2;
+    }
+    return 0;
+}
diff --git a/core/buffer_storage.h b/core/buffer_storage.h
new file mode 100644
index 00000000..282d5b53
--- /dev/null
+++ b/core/buffer_storage.h
@@ -0,0 +1,115 @@
+#ifndef CORE_BUFFER_STORAGE_H
+#define CORE_BUFFER_STORAGE_H
+
+#include <atomic>
+
+#include "albyte.h"
+#include "alnumeric.h"
+#include "alspan.h"
+#include "ambidefs.h"
+
+
+using uint = unsigned int;
+
+/* Storable formats */
+enum FmtType : unsigned char {
+    FmtUByte,
+    FmtShort,
+    FmtFloat,
+    FmtDouble,
+    FmtMulaw,
+    FmtAlaw,
+    FmtIMA4,
+    FmtMSADPCM,
+};
+enum FmtChannels : unsigned char {
+    FmtMono,
+    FmtStereo,
+    FmtRear,
+    FmtQuad,
+    FmtX51, /* (WFX order) */
+    FmtX61, /* (WFX order) */
+    FmtX71, /* (WFX order) */
+    FmtBFormat2D,
+    FmtBFormat3D,
+    FmtUHJ2, /* 2-channel UHJ, aka "BHJ", stereo-compatible */
+    FmtUHJ3, /* 3-channel UHJ, aka "THJ" */
+    FmtUHJ4, /* 4-channel UHJ, aka "PHJ" */
+    FmtSuperStereo, /* Stereo processed with Super Stereo. */
+};
+
+enum class AmbiLayout : unsigned char {
+    FuMa,
+    ACN,
+};
+enum class AmbiScaling : unsigned char {
+    FuMa,
+    SN3D,
+    N3D,
+    UHJ,
+};
+
+const char *NameFromFormat(FmtType type) noexcept;
+const char *NameFromFormat(FmtChannels channels) noexcept;
+
+uint BytesFromFmt(FmtType type) noexcept;
+uint ChannelsFromFmt(FmtChannels chans, uint ambiorder) noexcept;
+inline uint FrameSizeFromFmt(FmtChannels chans, FmtType type, uint ambiorder) noexcept
+{ return ChannelsFromFmt(chans, ambiorder) * BytesFromFmt(type); }
+
+constexpr bool IsBFormat(FmtChannels chans) noexcept
+{ return chans == FmtBFormat2D || chans == FmtBFormat3D; }
+
+/* Super Stereo is considered part of the UHJ family here, since it goes
+ * through similar processing as UHJ, both result in a B-Format signal, and
+ * needs the same consideration as BHJ (three channel result with only two
+ * channel input).
+ */
+constexpr bool IsUHJ(FmtChannels chans) noexcept
+{ return chans == FmtUHJ2 || chans == FmtUHJ3 || chans == FmtUHJ4 || chans == FmtSuperStereo; }
+
+/** Ambisonic formats are either B-Format or UHJ formats. */
+constexpr bool IsAmbisonic(FmtChannels chans) noexcept
+{ return IsBFormat(chans) || IsUHJ(chans); }
+
+constexpr bool Is2DAmbisonic(FmtChannels chans) noexcept
+{
+    return chans == FmtBFormat2D || chans == FmtUHJ2 || chans == FmtUHJ3
+        || chans == FmtSuperStereo;
+}
+
+
+using CallbackType = int(*)(void*, void*, int);
+
+struct BufferStorage {
+    CallbackType mCallback{nullptr};
+    void *mUserData{nullptr};
+
+    al::span<al::byte> mData;
+
+    uint mSampleRate{0u};
+    FmtChannels mChannels{FmtMono};
+    FmtType mType{FmtShort};
+    uint mSampleLen{0u};
+    uint mBlockAlign{0u};
+
+    AmbiLayout mAmbiLayout{AmbiLayout::FuMa};
+    AmbiScaling mAmbiScaling{AmbiScaling::FuMa};
+    uint mAmbiOrder{0u};
+
+    inline uint bytesFromFmt() const noexcept { return BytesFromFmt(mType); }
+    inline uint channelsFromFmt() const noexcept
+    { return ChannelsFromFmt(mChannels, mAmbiOrder); }
+    inline uint frameSizeFromFmt() const noexcept { return channelsFromFmt() * bytesFromFmt(); }
+
+    inline uint blockSizeFromFmt() const noexcept
+    {
+        if(mType == FmtIMA4) return ((mBlockAlign-1)/2 + 4) * channelsFromFmt();
+        if(mType == FmtMSADPCM) return ((mBlockAlign-2)/2 + 7) * channelsFromFmt();
+        return frameSizeFromFmt();
+    };
+
+    inline bool isBFormat() const noexcept { return IsBFormat(mChannels); }
+};
+
+#endif /* CORE_BUFFER_STORAGE_H */
diff --git a/core/bufferline.h b/core/bufferline.h
new file mode 100644
index 00000000..8b445f3f
--- /dev/null
+++ b/core/bufferline.h
@@ -0,0 +1,17 @@
+#ifndef CORE_BUFFERLINE_H
+#define CORE_BUFFERLINE_H
+
+#include <array>
+
+#include "alspan.h"
+
+/* Size for temporary storage of buffer data, in floats. Larger values need
+ * more memory and are harder on cache, while smaller values may need more
+ * iterations for mixing.
+ */
+constexpr int BufferLineSize{1024};
+
+using FloatBufferLine = std::array<float,BufferLineSize>;
+using FloatBufferSpan = al::span<float,BufferLineSize>;
+
+#endif /* CORE_BUFFERLINE_H */
diff --git a/core/context.cpp b/core/context.cpp
new file mode 100644
index 00000000..d68d8327
--- /dev/null
+++ b/core/context.cpp
@@ -0,0 +1,164 @@
+
+#include "config.h"
+
+#include <cassert>
+#include <memory>
+
+#include "async_event.h"
+#include "context.h"
+#include "device.h"
+#include "effectslot.h"
+#include "logging.h"
+#include "ringbuffer.h"
+#include "voice.h"
+#include "voice_change.h"
+
+
+#ifdef __cpp_lib_atomic_is_always_lock_free
+static_assert(std::atomic<ContextBase::AsyncEventBitset>::is_always_lock_free, "atomic<bitset> isn't lock-free");
+#endif
+
+ContextBase::ContextBase(DeviceBase *device) : mDevice{device}
+{ assert(mEnabledEvts.is_lock_free()); }
+
+ContextBase::~ContextBase()
+{
+    size_t count{0};
+    ContextProps *cprops{mParams.ContextUpdate.exchange(nullptr, std::memory_order_relaxed)};
+    if(cprops)
+    {
+        ++count;
+        delete cprops;
+    }
+    cprops = mFreeContextProps.exchange(nullptr, std::memory_order_acquire);
+    while(cprops)
+    {
+        std::unique_ptr<ContextProps> old{cprops};
+        cprops = old->next.load(std::memory_order_relaxed);
+        ++count;
+    }
+    TRACE("Freed %zu context property object%s\n", count, (count==1)?"":"s");
+
+    count = 0;
+    EffectSlotProps *eprops{mFreeEffectslotProps.exchange(nullptr, std::memory_order_acquire)};
+    while(eprops)
+    {
+        std::unique_ptr<EffectSlotProps> old{eprops};
+        eprops = old->next.load(std::memory_order_relaxed);
+        ++count;
+    }
+    TRACE("Freed %zu AuxiliaryEffectSlot property object%s\n", count, (count==1)?"":"s");
+
+    if(EffectSlotArray *curarray{mActiveAuxSlots.exchange(nullptr, std::memory_order_relaxed)})
+    {
+        al::destroy_n(curarray->end(), curarray->size());
+        delete curarray;
+    }
+
+    delete mVoices.exchange(nullptr, std::memory_order_relaxed);
+
+    if(mAsyncEvents)
+    {
+        count = 0;
+        auto evt_vec = mAsyncEvents->getReadVector();
+        if(evt_vec.first.len > 0)
+        {
+            al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf), evt_vec.first.len);
+            count += evt_vec.first.len;
+        }
+        if(evt_vec.second.len > 0)
+        {
+            al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.second.buf), evt_vec.second.len);
+            count += evt_vec.second.len;
+        }
+        if(count > 0)
+            TRACE("Destructed %zu orphaned event%s\n", count, (count==1)?"":"s");
+        mAsyncEvents->readAdvance(count);
+    }
+}
+
+
+void ContextBase::allocVoiceChanges()
+{
+    constexpr size_t clustersize{128};
+
+    VoiceChangeCluster cluster{std::make_unique<VoiceChange[]>(clustersize)};
+    for(size_t i{1};i < clustersize;++i)
+        cluster[i-1].mNext.store(std::addressof(cluster[i]), std::memory_order_relaxed);
+    cluster[clustersize-1].mNext.store(mVoiceChangeTail, std::memory_order_relaxed);
+
+    mVoiceChangeClusters.emplace_back(std::move(cluster));
+    mVoiceChangeTail = mVoiceChangeClusters.back().get();
+}
+
+void ContextBase::allocVoiceProps()
+{
+    constexpr size_t clustersize{32};
+
+    TRACE("Increasing allocated voice properties to %zu\n",
+        (mVoicePropClusters.size()+1) * clustersize);
+
+    VoicePropsCluster cluster{std::make_unique<VoicePropsItem[]>(clustersize)};
+    for(size_t i{1};i < clustersize;++i)
+        cluster[i-1].next.store(std::addressof(cluster[i]), std::memory_order_relaxed);
+    mVoicePropClusters.emplace_back(std::move(cluster));
+
+    VoicePropsItem *oldhead{mFreeVoiceProps.load(std::memory_order_acquire)};
+    do {
+        mVoicePropClusters.back()[clustersize-1].next.store(oldhead, std::memory_order_relaxed);
+    } while(mFreeVoiceProps.compare_exchange_weak(oldhead, mVoicePropClusters.back().get(),
+        std::memory_order_acq_rel, std::memory_order_acquire) == false);
+}
+
+void ContextBase::allocVoices(size_t addcount)
+{
+    constexpr size_t clustersize{32};
+    /* Convert element count to cluster count. */
+    addcount = (addcount+(clustersize-1)) / clustersize;
+
+    if(addcount >= std::numeric_limits<int>::max()/clustersize - mVoiceClusters.size())
+        throw std::runtime_error{"Allocating too many voices"};
+    const size_t totalcount{(mVoiceClusters.size()+addcount) * clustersize};
+    TRACE("Increasing allocated voices to %zu\n", totalcount);
+
+    auto newarray = VoiceArray::Create(totalcount);
+    while(addcount)
+    {
+        mVoiceClusters.emplace_back(std::make_unique<Voice[]>(clustersize));
+        --addcount;
+    }
+
+    auto voice_iter = newarray->begin();
+    for(VoiceCluster &cluster : mVoiceClusters)
+    {
+        for(size_t i{0};i < clustersize;++i)
+            *(voice_iter++) = &cluster[i];
+    }
+
+    if(auto *oldvoices = mVoices.exchange(newarray.release(), std::memory_order_acq_rel))
+    {
+        mDevice->waitForMix();
+        delete oldvoices;
+    }
+}
+
+
+EffectSlot *ContextBase::getEffectSlot()
+{
+    for(auto& cluster : mEffectSlotClusters)
+    {
+        for(size_t i{0};i < EffectSlotClusterSize;++i)
+        {
+            if(!cluster[i].InUse)
+                return &cluster[i];
+        }
+    }
+
+    if(1 >= std::numeric_limits<int>::max()/EffectSlotClusterSize - mEffectSlotClusters.size())
+        throw std::runtime_error{"Allocating too many effect slots"};
+    const size_t totalcount{(mEffectSlotClusters.size()+1) * EffectSlotClusterSize};
+    TRACE("Increasing allocated effect slots to %zu\n", totalcount);
+
+    mEffectSlotClusters.emplace_back(std::make_unique<EffectSlot[]>(EffectSlotClusterSize));
+    return getEffectSlot();
+}
diff --git a/core/context.h b/core/context.h
new file mode 100644
index 00000000..9723eac3
--- /dev/null
+++ b/core/context.h
@@ -0,0 +1,171 @@
+#ifndef CORE_CONTEXT_H
+#define CORE_CONTEXT_H
+
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <cstddef>
+#include <memory>
+#include <thread>
+
+#include "almalloc.h"
+#include "alspan.h"
+#include "async_event.h"
+#include "atomic.h"
+#include "bufferline.h"
+#include "threads.h"
+#include "vecmat.h"
+#include "vector.h"
+
+struct DeviceBase;
+struct EffectSlot;
+struct EffectSlotProps;
+struct RingBuffer;
+struct Voice;
+struct VoiceChange;
+struct VoicePropsItem;
+
+using uint = unsigned int;
+
+
+constexpr float SpeedOfSoundMetersPerSec{343.3f};
+
+constexpr float AirAbsorbGainHF{0.99426f}; /* -0.05dB */
+
+enum class DistanceModel : unsigned char {
+    Disable,
+    Inverse, InverseClamped,
+    Linear, LinearClamped,
+    Exponent, ExponentClamped,
+
+    Default = InverseClamped
+};
+
+
+struct ContextProps {
+    std::array<float,3> Position;
+    std::array<float,3> Velocity;
+    std::array<float,3> OrientAt;
+    std::array<float,3> OrientUp;
+    float Gain;
+    float MetersPerUnit;
+    float AirAbsorptionGainHF;
+
+    float DopplerFactor;
+    float DopplerVelocity;
+    float SpeedOfSound;
+    bool SourceDistanceModel;
+    DistanceModel mDistanceModel;
+
+    std::atomic<ContextProps*> next;
+
+    DEF_NEWDEL(ContextProps)
+};
+
+struct ContextParams {
+    /* Pointer to the most recent property values that are awaiting an update. */
+    std::atomic<ContextProps*> ContextUpdate{nullptr};
+
+    alu::Vector Position{};
+    alu::Matrix Matrix{alu::Matrix::Identity()};
+    alu::Vector Velocity{};
+
+    float Gain{1.0f};
+    float MetersPerUnit{1.0f};
+    float AirAbsorptionGainHF{AirAbsorbGainHF};
+
+    float DopplerFactor{1.0f};
+    float SpeedOfSound{SpeedOfSoundMetersPerSec}; /* in units per sec! */
+
+    bool SourceDistanceModel{false};
+    DistanceModel mDistanceModel{};
+};
+
+struct ContextBase {
+    DeviceBase *const mDevice;
+
+    /* Counter for the pre-mixing updates, in 31.1 fixed point (lowest bit
+     * indicates if updates are currently happening).
+     */
+    RefCount mUpdateCount{0u};
+    std::atomic<bool> mHoldUpdates{false};
+    std::atomic<bool> mStopVoicesOnDisconnect{true};
+
+    float mGainBoost{1.0f};
+
+    /* Linked lists of unused property containers, free to use for future
+     * updates.
+     */
+    std::atomic<ContextProps*> mFreeContextProps{nullptr};
+    std::atomic<VoicePropsItem*> mFreeVoiceProps{nullptr};
+    std::atomic<EffectSlotProps*> mFreeEffectslotProps{nullptr};
+
+    /* The voice change tail is the beginning of the "free" elements, up to and
+     * *excluding* the current. If tail==current, there's no free elements and
+     * new ones need to be allocated. The current voice change is the element
+     * last processed, and any after are pending.
+     */
+    VoiceChange *mVoiceChangeTail{};
+    std::atomic<VoiceChange*> mCurrentVoiceChange{};
+
+    void allocVoiceChanges();
+    void allocVoiceProps();
+
+
+    ContextParams mParams;
+
+    using VoiceArray = al::FlexArray<Voice*>;
+    std::atomic<VoiceArray*> mVoices{};
+    std::atomic<size_t> mActiveVoiceCount{};
+
+    void allocVoices(size_t addcount);
+    al::span<Voice*> getVoicesSpan() const noexcept
+    {
+        return {mVoices.load(std::memory_order_relaxed)->data(),
+            mActiveVoiceCount.load(std::memory_order_relaxed)};
+    }
+    al::span<Voice*> getVoicesSpanAcquired() const noexcept
+    {
+        return {mVoices.load(std::memory_order_acquire)->data(),
+            mActiveVoiceCount.load(std::memory_order_acquire)};
+    }
+
+
+    using EffectSlotArray = al::FlexArray<EffectSlot*>;
+    std::atomic<EffectSlotArray*> mActiveAuxSlots{nullptr};
+
+    std::thread mEventThread;
+    al::semaphore mEventSem;
+    std::unique_ptr<RingBuffer> mAsyncEvents;
+    using AsyncEventBitset = std::bitset<AsyncEvent::UserEventCount>;
+    std::atomic<AsyncEventBitset> mEnabledEvts{0u};
+
+    /* Asynchronous voice change actions are processed as a linked list of
+     * VoiceChange objects by the mixer, which is atomically appended to.
+     * However, to avoid allocating each object individually, they're allocated
+     * in clusters that are stored in a vector for easy automatic cleanup.
+     */
+    using VoiceChangeCluster = std::unique_ptr<VoiceChange[]>;
+    al::vector<VoiceChangeCluster> mVoiceChangeClusters;
+
+    using VoiceCluster = std::unique_ptr<Voice[]>;
+    al::vector<VoiceCluster> mVoiceClusters;
+
+    using VoicePropsCluster = std::unique_ptr<VoicePropsItem[]>;
+    al::vector<VoicePropsCluster> mVoicePropClusters;
+
+
+    static constexpr size_t EffectSlotClusterSize{4};
+    EffectSlot *getEffectSlot();
+
+    using EffectSlotCluster = std::unique_ptr<EffectSlot[]>;
+    al::vector<EffectSlotCluster> mEffectSlotClusters;
+
+
+    ContextBase(DeviceBase *device);
+    ContextBase(const ContextBase&) = delete;
+    ContextBase& operator=(const ContextBase&) = delete;
+    ~ContextBase();
+};
+
+#endif /* CORE_CONTEXT_H */
diff --git a/core/converter.cpp b/core/converter.cpp
new file mode 100644
index 00000000..a5141448
--- /dev/null
+++ b/core/converter.cpp
@@ -0,0 +1,346 @@
+
+#include "config.h"
+
+#include "converter.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <iterator>
+#include <limits.h>
+
+#include "albit.h"
+#include "albyte.h"
+#include "alnumeric.h"
+#include "fpu_ctrl.h"
+
+
+namespace {
+
+constexpr uint MaxPitch{10};
+
+static_assert((BufferLineSize-1)/MaxPitch > 0, "MaxPitch is too large for BufferLineSize!");
+static_assert((INT_MAX>>MixerFracBits)/MaxPitch > BufferLineSize,
+    "MaxPitch and/or BufferLineSize are too large for MixerFracBits!");
+
+/* Base template left undefined. Should be marked =delete, but Clang 3.8.1
+ * chokes on that given the inline specializations.
+ */
+template<DevFmtType T>
+inline float LoadSample(DevFmtType_t<T> val) noexcept;
+
+template<> inline float LoadSample<DevFmtByte>(DevFmtType_t<DevFmtByte> val) noexcept
+{ return val * (1.0f/128.0f); }
+template<> inline float LoadSample<DevFmtShort>(DevFmtType_t<DevFmtShort> val) noexcept
+{ return val * (1.0f/32768.0f); }
+template<> inline float LoadSample<DevFmtInt>(DevFmtType_t<DevFmtInt> val) noexcept
+{ return static_cast<float>(val) * (1.0f/2147483648.0f); }
+template<> inline float LoadSample<DevFmtFloat>(DevFmtType_t<DevFmtFloat> val) noexcept
+{ return val; }
+
+template<> inline float LoadSample<DevFmtUByte>(DevFmtType_t<DevFmtUByte> val) noexcept
+{ return LoadSample<DevFmtByte>(static_cast<int8_t>(val - 128)); }
+template<> inline float LoadSample<DevFmtUShort>(DevFmtType_t<DevFmtUShort> val) noexcept
+{ return LoadSample<DevFmtShort>(static_cast<int16_t>(val - 32768)); }
+template<> inline float LoadSample<DevFmtUInt>(DevFmtType_t<DevFmtUInt> val) noexcept
+{ return LoadSample<DevFmtInt>(static_cast<int32_t>(val - 2147483648u)); }
+
+
+template<DevFmtType T>
+inline void LoadSampleArray(float *RESTRICT dst, const void *src, const size_t srcstep,
+    const size_t samples) noexcept
+{
+    const DevFmtType_t<T> *ssrc = static_cast<const DevFmtType_t<T>*>(src);
+    for(size_t i{0u};i < samples;i++)
+        dst[i] = LoadSample<T>(ssrc[i*srcstep]);
+}
+
+void LoadSamples(float *dst, const void *src, const size_t srcstep, const DevFmtType srctype,
+    const size_t samples) noexcept
+{
+#define HANDLE_FMT(T)                                                         \
+    case T: LoadSampleArray<T>(dst, src, srcstep, samples); break
+    switch(srctype)
+    {
+        HANDLE_FMT(DevFmtByte);
+        HANDLE_FMT(DevFmtUByte);
+        HANDLE_FMT(DevFmtShort);
+        HANDLE_FMT(DevFmtUShort);
+        HANDLE_FMT(DevFmtInt);
+        HANDLE_FMT(DevFmtUInt);
+        HANDLE_FMT(DevFmtFloat);
+    }
+#undef HANDLE_FMT
+}
+
+
+template<DevFmtType T>
+inline DevFmtType_t<T> StoreSample(float) noexcept;
+
+template<> inline float StoreSample<DevFmtFloat>(float val) noexcept
+{ return val; }
+template<> inline int32_t StoreSample<DevFmtInt>(float val) noexcept
+{ return fastf2i(clampf(val*2147483648.0f, -2147483648.0f, 2147483520.0f)); }
+template<> inline int16_t StoreSample<DevFmtShort>(float val) noexcept
+{ return static_cast<int16_t>(fastf2i(clampf(val*32768.0f, -32768.0f, 32767.0f))); }
+template<> inline int8_t StoreSample<DevFmtByte>(float val) noexcept
+{ return static_cast<int8_t>(fastf2i(clampf(val*128.0f, -128.0f, 127.0f))); }
+
+/* Define unsigned output variations. */
+template<> inline uint32_t StoreSample<DevFmtUInt>(float val) noexcept
+{ return static_cast<uint32_t>(StoreSample<DevFmtInt>(val)) + 2147483648u; }
+template<> inline uint16_t StoreSample<DevFmtUShort>(float val) noexcept
+{ return static_cast<uint16_t>(StoreSample<DevFmtShort>(val) + 32768); }
+template<> inline uint8_t StoreSample<DevFmtUByte>(float val) noexcept
+{ return static_cast<uint8_t>(StoreSample<DevFmtByte>(val) + 128); }
+
+template<DevFmtType T>
+inline void StoreSampleArray(void *dst, const float *RESTRICT src, const size_t dststep,
+    const size_t samples) noexcept
+{
+    DevFmtType_t<T> *sdst = static_cast<DevFmtType_t<T>*>(dst);
+    for(size_t i{0u};i < samples;i++)
+        sdst[i*dststep] = StoreSample<T>(src[i]);
+}
+
+
+void StoreSamples(void *dst, const float *src, const size_t dststep, const DevFmtType dsttype,
+    const size_t samples) noexcept
+{
+#define HANDLE_FMT(T)                                                         \
+    case T: StoreSampleArray<T>(dst, src, dststep, samples); break
+    switch(dsttype)
+    {
+        HANDLE_FMT(DevFmtByte);
+        HANDLE_FMT(DevFmtUByte);
+        HANDLE_FMT(DevFmtShort);
+        HANDLE_FMT(DevFmtUShort);
+        HANDLE_FMT(DevFmtInt);
+        HANDLE_FMT(DevFmtUInt);
+        HANDLE_FMT(DevFmtFloat);
+    }
+#undef HANDLE_FMT
+}
+
+
+template<DevFmtType T>
+void Mono2Stereo(float *RESTRICT dst, const void *src, const size_t frames) noexcept
+{
+    const DevFmtType_t<T> *ssrc = static_cast<const DevFmtType_t<T>*>(src);
+    for(size_t i{0u};i < frames;i++)
+        dst[i*2 + 1] = dst[i*2 + 0] = LoadSample<T>(ssrc[i]) * 0.707106781187f;
+}
+
+template<DevFmtType T>
+void Multi2Mono(uint chanmask, const size_t step, const float scale, float *RESTRICT dst,
+    const void *src, const size_t frames) noexcept
+{
+    const DevFmtType_t<T> *ssrc = static_cast<const DevFmtType_t<T>*>(src);
+    std::fill_n(dst, frames, 0.0f);
+    for(size_t c{0};chanmask;++c)
+    {
+        if((chanmask&1)) LIKELY
+        {
+            for(size_t i{0u};i < frames;i++)
+                dst[i] += LoadSample<T>(ssrc[i*step + c]);
+        }
+        chanmask >>= 1;
+    }
+    for(size_t i{0u};i < frames;i++)
+        dst[i] *= scale;
+}
+
+} // namespace
+
+SampleConverterPtr SampleConverter::Create(DevFmtType srcType, DevFmtType dstType, size_t numchans,
+    uint srcRate, uint dstRate, Resampler resampler)
+{
+    if(numchans < 1 || srcRate < 1 || dstRate < 1)
+        return nullptr;
+
+    SampleConverterPtr converter{new(FamCount(numchans)) SampleConverter{numchans}};
+    converter->mSrcType = srcType;
+    converter->mDstType = dstType;
+    converter->mSrcTypeSize = BytesFromDevFmt(srcType);
+    converter->mDstTypeSize = BytesFromDevFmt(dstType);
+
+    converter->mSrcPrepCount = MaxResamplerPadding;
+    converter->mFracOffset = 0;
+    for(auto &chan : converter->mChan)
+    {
+        const al::span<float> buffer{chan.PrevSamples};
+        std::fill(buffer.begin(), buffer.end(), 0.0f);
+    }
+
+    /* Have to set the mixer FPU mode since that's what the resampler code expects. */
+    FPUCtl mixer_mode{};
+    auto step = static_cast<uint>(
+        mind(srcRate*double{MixerFracOne}/dstRate + 0.5, MaxPitch*MixerFracOne));
+    converter->mIncrement = maxu(step, 1);
+    if(converter->mIncrement == MixerFracOne)
+        converter->mResample = [](const InterpState*, const float *RESTRICT src, uint, const uint,
+            const al::span<float> dst) { std::copy_n(src, dst.size(), dst.begin()); };
+    else
+        converter->mResample = PrepareResampler(resampler, converter->mIncrement,
+            &converter->mState);
+
+    return converter;
+}
+
+uint SampleConverter::availableOut(uint srcframes) const
+{
+    if(srcframes < 1)
+    {
+        /* No output samples if there's no input samples. */
+        return 0;
+    }
+
+    const uint prepcount{mSrcPrepCount};
+    if(prepcount < MaxResamplerPadding && MaxResamplerPadding - prepcount >= srcframes)
+    {
+        /* Not enough input samples to generate an output sample. */
+        return 0;
+    }
+
+    uint64_t DataSize64{prepcount};
+    DataSize64 += srcframes;
+    DataSize64 -= MaxResamplerPadding;
+    DataSize64 <<= MixerFracBits;
+    DataSize64 -= mFracOffset;
+
+    /* If we have a full prep, we can generate at least one sample. */
+    return static_cast<uint>(clampu64((DataSize64 + mIncrement-1)/mIncrement, 1,
+        std::numeric_limits<int>::max()));
+}
+
+uint SampleConverter::convert(const void **src, uint *srcframes, void *dst, uint dstframes)
+{
+    const uint SrcFrameSize{static_cast<uint>(mChan.size()) * mSrcTypeSize};
+    const uint DstFrameSize{static_cast<uint>(mChan.size()) * mDstTypeSize};
+    const uint increment{mIncrement};
+    auto SamplesIn = static_cast<const al::byte*>(*src);
+    uint NumSrcSamples{*srcframes};
+
+    FPUCtl mixer_mode{};
+    uint pos{0};
+    while(pos < dstframes && NumSrcSamples > 0)
+    {
+        const uint prepcount{mSrcPrepCount};
+        const uint readable{minu(NumSrcSamples, BufferLineSize - prepcount)};
+
+        if(prepcount < MaxResamplerPadding && MaxResamplerPadding-prepcount >= readable)
+        {
+            /* Not enough input samples to generate an output sample. Store
+             * what we're given for later.
+             */
+            for(size_t chan{0u};chan < mChan.size();chan++)
+                LoadSamples(&mChan[chan].PrevSamples[prepcount], SamplesIn + mSrcTypeSize*chan,
+                    mChan.size(), mSrcType, readable);
+
+            mSrcPrepCount = prepcount + readable;
+            NumSrcSamples = 0;
+            break;
+        }
+
+        float *RESTRICT SrcData{mSrcSamples};
+        float *RESTRICT DstData{mDstSamples};
+        uint DataPosFrac{mFracOffset};
+        uint64_t DataSize64{prepcount};
+        DataSize64 += readable;
+        DataSize64 -= MaxResamplerPadding;
+        DataSize64 <<= MixerFracBits;
+        DataSize64 -= DataPosFrac;
+
+        /* If we have a full prep, we can generate at least one sample. */
+        auto DstSize = static_cast<uint>(
+            clampu64((DataSize64 + increment-1)/increment, 1, BufferLineSize));
+        DstSize = minu(DstSize, dstframes-pos);
+
+        const uint DataPosEnd{DstSize*increment + DataPosFrac};
+        const uint SrcDataEnd{DataPosEnd>>MixerFracBits};
+
+        assert(prepcount+readable >= SrcDataEnd);
+        const uint nextprep{minu(prepcount + readable - SrcDataEnd, MaxResamplerPadding)};
+
+        for(size_t chan{0u};chan < mChan.size();chan++)
+        {
+            const al::byte *SrcSamples{SamplesIn + mSrcTypeSize*chan};
+            al::byte *DstSamples = static_cast<al::byte*>(dst) + mDstTypeSize*chan;
+
+            /* Load the previous samples into the source data first, then the
+             * new samples from the input buffer.
+             */
+            std::copy_n(mChan[chan].PrevSamples, prepcount, SrcData);
+            LoadSamples(SrcData + prepcount, SrcSamples, mChan.size(), mSrcType, readable);
+
+            /* Store as many prep samples for next time as possible, given the
+             * number of output samples being generated.
+             */
+            std::copy_n(SrcData+SrcDataEnd, nextprep, mChan[chan].PrevSamples);
+            std::fill(std::begin(mChan[chan].PrevSamples)+nextprep,
+                std::end(mChan[chan].PrevSamples), 0.0f);
+
+            /* Now resample, and store the result in the output buffer. */
+            mResample(&mState, SrcData+MaxResamplerEdge, DataPosFrac, increment,
+                {DstData, DstSize});
+
+            StoreSamples(DstSamples, DstData, mChan.size(), mDstType, DstSize);
+        }
+
+        /* Update the number of prep samples still available, as well as the
+         * fractional offset.
+         */
+        mSrcPrepCount = nextprep;
+        mFracOffset = DataPosEnd & MixerFracMask;
+
+        /* Update the src and dst pointers in case there's still more to do. */
+        const uint srcread{minu(NumSrcSamples, SrcDataEnd + mSrcPrepCount - prepcount)};
+        SamplesIn += SrcFrameSize*srcread;
+        NumSrcSamples -= srcread;
+
+        dst = static_cast<al::byte*>(dst) + DstFrameSize*DstSize;
+        pos += DstSize;
+    }
+
+    *src = SamplesIn;
+    *srcframes = NumSrcSamples;
+
+    return pos;
+}
+
+
+void ChannelConverter::convert(const void *src, float *dst, uint frames) const
+{
+    if(mDstChans == DevFmtMono)
+    {
+        const float scale{std::sqrt(1.0f / static_cast<float>(al::popcount(mChanMask)))};
+        switch(mSrcType)
+        {
+#define HANDLE_FMT(T) case T: Multi2Mono<T>(mChanMask, mSrcStep, scale, dst, src, frames); break
+        HANDLE_FMT(DevFmtByte);
+        HANDLE_FMT(DevFmtUByte);
+        HANDLE_FMT(DevFmtShort);
+        HANDLE_FMT(DevFmtUShort);
+        HANDLE_FMT(DevFmtInt);
+        HANDLE_FMT(DevFmtUInt);
+        HANDLE_FMT(DevFmtFloat);
+#undef HANDLE_FMT
+        }
+    }
+    else if(mChanMask == 0x1 && mDstChans == DevFmtStereo)
+    {
+        switch(mSrcType)
+        {
+#define HANDLE_FMT(T) case T: Mono2Stereo<T>(dst, src, frames); break
+        HANDLE_FMT(DevFmtByte);
+        HANDLE_FMT(DevFmtUByte);
+        HANDLE_FMT(DevFmtShort);
+        HANDLE_FMT(DevFmtUShort);
+        HANDLE_FMT(DevFmtInt);
+        HANDLE_FMT(DevFmtUInt);
+        HANDLE_FMT(DevFmtFloat);
+#undef HANDLE_FMT
+        }
+    }
+}
diff --git a/core/converter.h b/core/converter.h
new file mode 100644
index 00000000..01becea2
--- /dev/null
+++ b/core/converter.h
@@ -0,0 +1,66 @@
+#ifndef CORE_CONVERTER_H
+#define CORE_CONVERTER_H
+
+#include <chrono>
+#include <cstddef>
+#include <memory>
+
+#include "almalloc.h"
+#include "devformat.h"
+#include "mixer/defs.h"
+
+using uint = unsigned int;
+
+
+struct SampleConverter {
+    DevFmtType mSrcType{};
+    DevFmtType mDstType{};
+    uint mSrcTypeSize{};
+    uint mDstTypeSize{};
+
+    uint mSrcPrepCount{};
+
+    uint mFracOffset{};
+    uint mIncrement{};
+    InterpState mState{};
+    ResamplerFunc mResample{};
+
+    alignas(16) float mSrcSamples[BufferLineSize]{};
+    alignas(16) float mDstSamples[BufferLineSize]{};
+
+    struct ChanSamples {
+        alignas(16) float PrevSamples[MaxResamplerPadding];
+    };
+    al::FlexArray<ChanSamples> mChan;
+
+    SampleConverter(size_t numchans) : mChan{numchans} { }
+
+    uint convert(const void **src, uint *srcframes, void *dst, uint dstframes);
+    uint availableOut(uint srcframes) const;
+
+    using SampleOffset = std::chrono::duration<int64_t, std::ratio<1,MixerFracOne>>;
+    SampleOffset currentInputDelay() const noexcept
+    {
+        const int64_t prep{int64_t{mSrcPrepCount} - MaxResamplerEdge};
+        return SampleOffset{(prep<<MixerFracBits) + mFracOffset};
+    }
+
+    static std::unique_ptr<SampleConverter> Create(DevFmtType srcType, DevFmtType dstType,
+        size_t numchans, uint srcRate, uint dstRate, Resampler resampler);
+
+    DEF_FAM_NEWDEL(SampleConverter, mChan)
+};
+using SampleConverterPtr = std::unique_ptr<SampleConverter>;
+
+struct ChannelConverter {
+    DevFmtType mSrcType{};
+    uint mSrcStep{};
+    uint mChanMask{};
+    DevFmtChannels mDstChans{};
+
+    bool is_active() const noexcept { return mChanMask != 0; }
+
+    void convert(const void *src, float *dst, uint frames) const;
+};
+
+#endif /* CORE_CONVERTER_H */
diff --git a/core/cpu_caps.cpp b/core/cpu_caps.cpp
new file mode 100644
index 00000000..d4b4d86c
--- /dev/null
+++ b/core/cpu_caps.cpp
@@ -0,0 +1,141 @@
+
+#include "config.h"
+
+#include "cpu_caps.h"
+
+#if defined(_WIN32) && (defined(_M_ARM) || defined(_M_ARM64))
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#ifndef PF_ARM_NEON_INSTRUCTIONS_AVAILABLE
+#define PF_ARM_NEON_INSTRUCTIONS_AVAILABLE 19
+#endif
+#endif
+
+#if defined(HAVE_CPUID_H)
+#include <cpuid.h>
+#elif defined(HAVE_INTRIN_H)
+#include <intrin.h>
+#endif
+
+#include <array>
+#include <cctype>
+#include <string>
+
+
+int CPUCapFlags{0};
+
+namespace {
+
+#if defined(HAVE_GCC_GET_CPUID) \
+    && (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64))
+using reg_type = unsigned int;
+inline std::array<reg_type,4> get_cpuid(unsigned int f)
+{
+    std::array<reg_type,4> ret{};
+    __get_cpuid(f, ret.data(), &ret[1], &ret[2], &ret[3]);
+    return ret;
+}
+#define CAN_GET_CPUID
+#elif defined(HAVE_CPUID_INTRINSIC) \
+    && (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64))
+using reg_type = int;
+inline std::array<reg_type,4> get_cpuid(unsigned int f)
+{
+    std::array<reg_type,4> ret{};
+    (__cpuid)(ret.data(), f);
+    return ret;
+}
+#define CAN_GET_CPUID
+#endif
+
+} // namespace
+
+al::optional<CPUInfo> GetCPUInfo()
+{
+    CPUInfo ret;
+
+#ifdef CAN_GET_CPUID
+    auto cpuregs = get_cpuid(0);
+    if(cpuregs[0] == 0)
+        return al::nullopt;
+
+    const reg_type maxfunc{cpuregs[0]};
+
+    cpuregs = get_cpuid(0x80000000);
+    const reg_type maxextfunc{cpuregs[0]};
+
+    ret.mVendor.append(reinterpret_cast<char*>(&cpuregs[1]), 4);
+    ret.mVendor.append(reinterpret_cast<char*>(&cpuregs[3]), 4);
+    ret.mVendor.append(reinterpret_cast<char*>(&cpuregs[2]), 4);
+    auto iter_end = std::remove(ret.mVendor.begin(), ret.mVendor.end(), '\0');
+    iter_end = std::unique(ret.mVendor.begin(), iter_end,
+        [](auto&& c0, auto&& c1) { return std::isspace(c0) && std::isspace(c1); });
+    ret.mVendor.erase(iter_end, ret.mVendor.end());
+    if(!ret.mVendor.empty() && std::isspace(ret.mVendor.back()))
+        ret.mVendor.pop_back();
+    if(!ret.mVendor.empty() && std::isspace(ret.mVendor.front()))
+        ret.mVendor.erase(ret.mVendor.begin());
+
+    if(maxextfunc >= 0x80000004)
+    {
+        cpuregs = get_cpuid(0x80000002);
+        ret.mName.append(reinterpret_cast<char*>(cpuregs.data()), 16);
+        cpuregs = get_cpuid(0x80000003);
+        ret.mName.append(reinterpret_cast<char*>(cpuregs.data()), 16);
+        cpuregs = get_cpuid(0x80000004);
+        ret.mName.append(reinterpret_cast<char*>(cpuregs.data()), 16);
+        iter_end = std::remove(ret.mName.begin(), ret.mName.end(), '\0');
+        iter_end = std::unique(ret.mName.begin(), iter_end,
+            [](auto&& c0, auto&& c1) { return std::isspace(c0) && std::isspace(c1); });
+        ret.mName.erase(iter_end, ret.mName.end());
+        if(!ret.mName.empty() && std::isspace(ret.mName.back()))
+            ret.mName.pop_back();
+        if(!ret.mName.empty() && std::isspace(ret.mName.front()))
+            ret.mName.erase(ret.mName.begin());
+    }
+
+    if(maxfunc >= 1)
+    {
+        cpuregs = get_cpuid(1);
+        if((cpuregs[3]&(1<<25)))
+            ret.mCaps |= CPU_CAP_SSE;
+        if((ret.mCaps&CPU_CAP_SSE) && (cpuregs[3]&(1<<26)))
+            ret.mCaps |= CPU_CAP_SSE2;
+        if((ret.mCaps&CPU_CAP_SSE2) && (cpuregs[2]&(1<<0)))
+            ret.mCaps |= CPU_CAP_SSE3;
+        if((ret.mCaps&CPU_CAP_SSE3) && (cpuregs[2]&(1<<19)))
+            ret.mCaps |= CPU_CAP_SSE4_1;
+    }
+
+#else
+
+    /* Assume support for whatever's supported if we can't check for it */
+#if defined(HAVE_SSE4_1)
+#warning "Assuming SSE 4.1 run-time support!"
+    ret.mCaps |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3 | CPU_CAP_SSE4_1;
+#elif defined(HAVE_SSE3)
+#warning "Assuming SSE 3 run-time support!"
+    ret.mCaps |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3;
+#elif defined(HAVE_SSE2)
+#warning "Assuming SSE 2 run-time support!"
+    ret.mCaps |= CPU_CAP_SSE | CPU_CAP_SSE2;
+#elif defined(HAVE_SSE)
+#warning "Assuming SSE run-time support!"
+    ret.mCaps |= CPU_CAP_SSE;
+#endif
+#endif /* CAN_GET_CPUID */
+
+#ifdef HAVE_NEON
+#ifdef __ARM_NEON
+    ret.mCaps |= CPU_CAP_NEON;
+#elif defined(_WIN32) && (defined(_M_ARM) || defined(_M_ARM64))
+    if(IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE))
+        ret.mCaps |= CPU_CAP_NEON;
+#else
+#warning "Assuming NEON run-time support!"
+    ret.mCaps |= CPU_CAP_NEON;
+#endif
+#endif
+
+    return ret;
+}
diff --git a/core/cpu_caps.h b/core/cpu_caps.h
new file mode 100644
index 00000000..ffd671d0
--- /dev/null
+++ b/core/cpu_caps.h
@@ -0,0 +1,26 @@
+#ifndef CORE_CPU_CAPS_H
+#define CORE_CPU_CAPS_H
+
+#include <string>
+
+#include "aloptional.h"
+
+
+extern int CPUCapFlags;
+enum {
+    CPU_CAP_SSE    = 1<<0,
+    CPU_CAP_SSE2   = 1<<1,
+    CPU_CAP_SSE3   = 1<<2,
+    CPU_CAP_SSE4_1 = 1<<3,
+    CPU_CAP_NEON   = 1<<4,
+};
+
+struct CPUInfo {
+    std::string mVendor;
+    std::string mName;
+    int mCaps{0};
+};
+
+al::optional<CPUInfo> GetCPUInfo();
+
+#endif /* CORE_CPU_CAPS_H */
diff --git a/core/cubic_defs.h b/core/cubic_defs.h
new file mode 100644
index 00000000..33751c97
--- /dev/null
+++ b/core/cubic_defs.h
@@ -0,0 +1,13 @@
+#ifndef CORE_CUBIC_DEFS_H
+#define CORE_CUBIC_DEFS_H
+
+/* The number of distinct phase intervals within the cubic filter tables. */
+constexpr unsigned int CubicPhaseBits{5};
+constexpr unsigned int CubicPhaseCount{1 << CubicPhaseBits};
+
+struct CubicCoefficients {
+    float mCoeffs[4];
+    float mDeltas[4];
+};
+
+#endif /* CORE_CUBIC_DEFS_H */
diff --git a/core/cubic_tables.cpp b/core/cubic_tables.cpp
new file mode 100644
index 00000000..73ec6b3f
--- /dev/null
+++ b/core/cubic_tables.cpp
@@ -0,0 +1,59 @@
+
+#include "cubic_tables.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+
+#include "alnumbers.h"
+#include "core/mixer/defs.h"
+
+
+namespace {
+
+using uint = unsigned int;
+
+struct SplineFilterArray {
+    alignas(16) CubicCoefficients mTable[CubicPhaseCount]{};
+
+    constexpr SplineFilterArray()
+    {
+        /* Fill in the main coefficients. */
+        for(size_t pi{0};pi < CubicPhaseCount;++pi)
+        {
+            const double mu{static_cast<double>(pi) / CubicPhaseCount};
+            const double mu2{mu*mu}, mu3{mu2*mu};
+            mTable[pi].mCoeffs[0] = static_cast<float>(-0.5*mu3 +      mu2 + -0.5*mu);
+            mTable[pi].mCoeffs[1] = static_cast<float>( 1.5*mu3 + -2.5*mu2           + 1.0);
+            mTable[pi].mCoeffs[2] = static_cast<float>(-1.5*mu3 +  2.0*mu2 +  0.5*mu);
+            mTable[pi].mCoeffs[3] = static_cast<float>( 0.5*mu3 + -0.5*mu2);
+        }
+
+        /* Fill in the coefficient deltas. */
+        for(size_t pi{0};pi < CubicPhaseCount-1;++pi)
+        {
+            mTable[pi].mDeltas[0] = mTable[pi+1].mCoeffs[0] - mTable[pi].mCoeffs[0];
+            mTable[pi].mDeltas[1] = mTable[pi+1].mCoeffs[1] - mTable[pi].mCoeffs[1];
+            mTable[pi].mDeltas[2] = mTable[pi+1].mCoeffs[2] - mTable[pi].mCoeffs[2];
+            mTable[pi].mDeltas[3] = mTable[pi+1].mCoeffs[3] - mTable[pi].mCoeffs[3];
+        }
+
+        const size_t pi{CubicPhaseCount - 1};
+        mTable[pi].mDeltas[0] = -mTable[pi].mCoeffs[0];
+        mTable[pi].mDeltas[1] = -mTable[pi].mCoeffs[1];
+        mTable[pi].mDeltas[2] = 1.0f - mTable[pi].mCoeffs[2];
+        mTable[pi].mDeltas[3] = -mTable[pi].mCoeffs[3];
+    }
+
+    constexpr auto getTable() const noexcept { return al::as_span(mTable); }
+};
+
+constexpr SplineFilterArray SplineFilter{};
+
+} // namespace
+
+const CubicTable gCubicSpline{SplineFilter.getTable()};
diff --git a/core/cubic_tables.h b/core/cubic_tables.h
new file mode 100644
index 00000000..88097ae2
--- /dev/null
+++ b/core/cubic_tables.h
@@ -0,0 +1,17 @@
+#ifndef CORE_CUBIC_TABLES_H
+#define CORE_CUBIC_TABLES_H
+
+#include "alspan.h"
+#include "cubic_defs.h"
+
+
+struct CubicTable {
+    al::span<const CubicCoefficients,CubicPhaseCount> Tab;
+};
+
+/* A Catmull-Rom spline. The spline passes through the center two samples,
+ * ensuring no discontinuity while moving through a series of samples.
+ */
+extern const CubicTable gCubicSpline;
+
+#endif /* CORE_CUBIC_TABLES_H */
diff --git a/core/dbus_wrap.cpp b/core/dbus_wrap.cpp
new file mode 100644
index 00000000..7f221706
--- /dev/null
+++ b/core/dbus_wrap.cpp
@@ -0,0 +1,46 @@
+
+#include "config.h"
+
+#include "dbus_wrap.h"
+
+#ifdef HAVE_DYNLOAD
+
+#include <mutex>
+#include <type_traits>
+
+#include "logging.h"
+
+
+void *dbus_handle{nullptr};
+#define DECL_FUNC(x) decltype(p##x) p##x{};
+DBUS_FUNCTIONS(DECL_FUNC)
+#undef DECL_FUNC
+
+void PrepareDBus()
+{
+    static constexpr char libname[] = "libdbus-1.so.3";
+
+    auto load_func = [](auto &f, const char *name) -> void
+    { f = reinterpret_cast<std::remove_reference_t<decltype(f)>>(GetSymbol(dbus_handle, name)); };
+#define LOAD_FUNC(x) do {                         \
+    load_func(p##x, #x);                          \
+    if(!p##x)                                     \
+    {                                             \
+        WARN("Failed to load function %s\n", #x); \
+        CloseLib(dbus_handle);                    \
+        dbus_handle = nullptr;                    \
+        return;                                   \
+    }                                             \
+} while(0);
+
+    dbus_handle = LoadLib(libname);
+    if(!dbus_handle)
+    {
+        WARN("Failed to load %s\n", libname);
+        return;
+    }
+
+DBUS_FUNCTIONS(LOAD_FUNC)
+#undef LOAD_FUNC
+}
+#endif
diff --git a/core/dbus_wrap.h b/core/dbus_wrap.h
new file mode 100644
index 00000000..09eaacf9
--- /dev/null
+++ b/core/dbus_wrap.h
@@ -0,0 +1,87 @@
+#ifndef CORE_DBUS_WRAP_H
+#define CORE_DBUS_WRAP_H
+
+#include <memory>
+
+#include <dbus/dbus.h>
+
+#include "dynload.h"
+
+#ifdef HAVE_DYNLOAD
+
+#include <mutex>
+
+#define DBUS_FUNCTIONS(MAGIC) \
+MAGIC(dbus_error_init) \
+MAGIC(dbus_error_free) \
+MAGIC(dbus_bus_get) \
+MAGIC(dbus_connection_set_exit_on_disconnect) \
+MAGIC(dbus_connection_unref) \
+MAGIC(dbus_connection_send_with_reply_and_block) \
+MAGIC(dbus_message_unref) \
+MAGIC(dbus_message_new_method_call) \
+MAGIC(dbus_message_append_args) \
+MAGIC(dbus_message_iter_init) \
+MAGIC(dbus_message_iter_next) \
+MAGIC(dbus_message_iter_recurse) \
+MAGIC(dbus_message_iter_get_arg_type) \
+MAGIC(dbus_message_iter_get_basic) \
+MAGIC(dbus_set_error_from_message)
+
+extern void *dbus_handle;
+#define DECL_FUNC(x) extern decltype(x) *p##x;
+DBUS_FUNCTIONS(DECL_FUNC)
+#undef DECL_FUNC
+
+#ifndef IN_IDE_PARSER
+#define dbus_error_init (*pdbus_error_init)
+#define dbus_error_free (*pdbus_error_free)
+#define dbus_bus_get (*pdbus_bus_get)
+#define dbus_connection_set_exit_on_disconnect (*pdbus_connection_set_exit_on_disconnect)
+#define dbus_connection_unref (*pdbus_connection_unref)
+#define dbus_connection_send_with_reply_and_block (*pdbus_connection_send_with_reply_and_block)
+#define dbus_message_unref (*pdbus_message_unref)
+#define dbus_message_new_method_call (*pdbus_message_new_method_call)
+#define dbus_message_append_args (*pdbus_message_append_args)
+#define dbus_message_iter_init (*pdbus_message_iter_init)
+#define dbus_message_iter_next (*pdbus_message_iter_next)
+#define dbus_message_iter_recurse (*pdbus_message_iter_recurse)
+#define dbus_message_iter_get_arg_type (*pdbus_message_iter_get_arg_type)
+#define dbus_message_iter_get_basic (*pdbus_message_iter_get_basic)
+#define dbus_set_error_from_message (*pdbus_set_error_from_message)
+#endif
+
+void PrepareDBus();
+
+inline auto HasDBus()
+{
+    static std::once_flag init_dbus{};
+    std::call_once(init_dbus, []{ PrepareDBus(); });
+    return dbus_handle;
+}
+
+#else
+
+constexpr bool HasDBus() noexcept { return true; }
+#endif /* HAVE_DYNLOAD */
+
+
+namespace dbus {
+
+struct Error {
+    Error() { dbus_error_init(&mError); }
+    ~Error() { dbus_error_free(&mError); }
+    DBusError* operator->() { return &mError; }
+    DBusError &get() { return mError; }
+private:
+    DBusError mError{};
+};
+
+struct ConnectionDeleter {
+    void operator()(DBusConnection *c) { dbus_connection_unref(c); }
+};
+using ConnectionPtr = std::unique_ptr<DBusConnection,ConnectionDeleter>;
+
+} // namespace dbus
+
+#endif /* CORE_DBUS_WRAP_H */
diff --git a/core/devformat.cpp b/core/devformat.cpp
new file mode 100644
index 00000000..acdabc4f
--- /dev/null
+++ b/core/devformat.cpp
@@ -0,0 +1,67 @@
+
+#include "config.h"
+
+#include "devformat.h"
+
+
+uint BytesFromDevFmt(DevFmtType type) noexcept
+{
+    switch(type)
+    {
+    case DevFmtByte: return sizeof(int8_t);
+    case DevFmtUByte: return sizeof(uint8_t);
+    case DevFmtShort: return sizeof(int16_t);
+    case DevFmtUShort: return sizeof(uint16_t);
+    case DevFmtInt: return sizeof(int32_t);
+    case DevFmtUInt: return sizeof(uint32_t);
+    case DevFmtFloat: return sizeof(float);
+    }
+    return 0;
+}
+uint ChannelsFromDevFmt(DevFmtChannels chans, uint ambiorder) noexcept
+{
+    switch(chans)
+    {
+    case DevFmtMono: return 1;
+    case DevFmtStereo: return 2;
+    case DevFmtQuad: return 4;
+    case DevFmtX51: return 6;
+    case DevFmtX61: return 7;
+    case DevFmtX71: return 8;
+    case DevFmtX714: return 12;
+    case DevFmtX3D71: return 8;
+    case DevFmtAmbi3D: return (ambiorder+1) * (ambiorder+1);
+    }
+    return 0;
+}
+
+const char *DevFmtTypeString(DevFmtType type) noexcept
+{
+    switch(type)
+    {
+    case DevFmtByte: return "Int8";
+    case DevFmtUByte: return "UInt8";
+    case DevFmtShort: return "Int16";
+    case DevFmtUShort: return "UInt16";
+    case DevFmtInt: return "Int32";
+    case DevFmtUInt: return "UInt32";
+    case DevFmtFloat: return "Float32";
+    }
+    return "(unknown type)";
+}
+const char *DevFmtChannelsString(DevFmtChannels chans) noexcept
+{
+    switch(chans)
+    {
+    case DevFmtMono: return "Mono";
+    case DevFmtStereo: return "Stereo";
+    case DevFmtQuad: return "Quadraphonic";
+    case DevFmtX51: return "5.1 Surround";
+    case DevFmtX61: return "6.1 Surround";
+    case DevFmtX71: return "7.1 Surround";
+    case DevFmtX714: return "7.1.4 Surround";
+    case DevFmtX3D71: return "3D7.1 Surround";
+    case DevFmtAmbi3D: return "Ambisonic 3D";
+    }
+    return "(unknown channels)";
+}
diff --git a/core/devformat.h b/core/devformat.h
new file mode 100644
index 00000000..485826a3
--- /dev/null
+++ b/core/devformat.h
@@ -0,0 +1,122 @@
+#ifndef CORE_DEVFORMAT_H
+#define CORE_DEVFORMAT_H
+
+#include <cstdint>
+
+
+using uint = unsigned int;
+
+enum Channel : unsigned char {
+    FrontLeft = 0,
+    FrontRight,
+    FrontCenter,
+    LFE,
+    BackLeft,
+    BackRight,
+    BackCenter,
+    SideLeft,
+    SideRight,
+
+    TopCenter,
+    TopFrontLeft,
+    TopFrontCenter,
+    TopFrontRight,
+    TopBackLeft,
+    TopBackCenter,
+    TopBackRight,
+
+    Aux0,
+    Aux1,
+    Aux2,
+    Aux3,
+    Aux4,
+    Aux5,
+    Aux6,
+    Aux7,
+    Aux8,
+    Aux9,
+    Aux10,
+    Aux11,
+    Aux12,
+    Aux13,
+    Aux14,
+    Aux15,
+
+    MaxChannels
+};
+
+
+/* Device formats */
+enum DevFmtType : unsigned char {
+    DevFmtByte,
+    DevFmtUByte,
+    DevFmtShort,
+    DevFmtUShort,
+    DevFmtInt,
+    DevFmtUInt,
+    DevFmtFloat,
+
+    DevFmtTypeDefault = DevFmtFloat
+};
+enum DevFmtChannels : unsigned char {
+    DevFmtMono,
+    DevFmtStereo,
+    DevFmtQuad,
+    DevFmtX51,
+    DevFmtX61,
+    DevFmtX71,
+    DevFmtX714,
+    DevFmtX3D71,
+    DevFmtAmbi3D,
+
+    DevFmtChannelsDefault = DevFmtStereo
+};
+#define MAX_OUTPUT_CHANNELS  16
+
+/* DevFmtType traits, providing the type, etc given a DevFmtType. */
+template<DevFmtType T>
+struct DevFmtTypeTraits { };
+
+template<>
+struct DevFmtTypeTraits<DevFmtByte> { using Type = int8_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtUByte> { using Type = uint8_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtShort> { using Type = int16_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtUShort> { using Type = uint16_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtInt> { using Type = int32_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtUInt> { using Type = uint32_t; };
+template<>
+struct DevFmtTypeTraits<DevFmtFloat> { using Type = float; };
+
+template<DevFmtType T>
+using DevFmtType_t = typename DevFmtTypeTraits<T>::Type;
+
+
+uint BytesFromDevFmt(DevFmtType type) noexcept;
+uint ChannelsFromDevFmt(DevFmtChannels chans, uint ambiorder) noexcept;
+inline uint FrameSizeFromDevFmt(DevFmtChannels chans, DevFmtType type, uint ambiorder) noexcept
+{ return ChannelsFromDevFmt(chans, ambiorder) * BytesFromDevFmt(type); }
+
+const char *DevFmtTypeString(DevFmtType type) noexcept;
+const char *DevFmtChannelsString(DevFmtChannels chans) noexcept;
+
+enum class DevAmbiLayout : bool {
+    FuMa,
+    ACN,
+
+    Default = ACN
+};
+
+enum class DevAmbiScaling : unsigned char {
+    FuMa,
+    SN3D,
+    N3D,
+
+    Default = SN3D
+};
+
+#endif /* CORE_DEVFORMAT_H */
diff --git a/core/device.cpp b/core/device.cpp
new file mode 100644
index 00000000..2766c5e4
--- /dev/null
+++ b/core/device.cpp
@@ -0,0 +1,23 @@
+
+#include "config.h"
+
+#include "bformatdec.h"
+#include "bs2b.h"
+#include "device.h"
+#include "front_stablizer.h"
+#include "hrtf.h"
+#include "mastering.h"
+
+
+al::FlexArray<ContextBase*> DeviceBase::sEmptyContextArray{0u};
+
+
+DeviceBase::DeviceBase(DeviceType type) : Type{type}, mContexts{&sEmptyContextArray}
+{
+}
+
+DeviceBase::~DeviceBase()
+{
+    auto *oldarray = mContexts.exchange(nullptr, std::memory_order_relaxed);
+    if(oldarray != &sEmptyContextArray) delete oldarray;
+}
diff --git a/core/device.h b/core/device.h
new file mode 100644
index 00000000..9aaf7adb
--- /dev/null
+++ b/core/device.h
@@ -0,0 +1,345 @@
+#ifndef CORE_DEVICE_H
+#define CORE_DEVICE_H
+
+#include <stddef.h>
+
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <string>
+
+#include "almalloc.h"
+#include "alspan.h"
+#include "ambidefs.h"
+#include "atomic.h"
+#include "bufferline.h"
+#include "devformat.h"
+#include "filters/nfc.h"
+#include "intrusive_ptr.h"
+#include "mixer/hrtfdefs.h"
+#include "opthelpers.h"
+#include "resampler_limits.h"
+#include "uhjfilter.h"
+#include "vector.h"
+
+class BFormatDec;
+struct bs2b;
+struct Compressor;
+struct ContextBase;
+struct DirectHrtfState;
+struct HrtfStore;
+
+using uint = unsigned int;
+
+
+#define MIN_OUTPUT_RATE      8000
+#define MAX_OUTPUT_RATE      192000
+#define DEFAULT_OUTPUT_RATE  48000
+
+#define DEFAULT_UPDATE_SIZE  960 /* 20ms */
+#define DEFAULT_NUM_UPDATES  3
+
+
+enum class DeviceType : unsigned char {
+    Playback,
+    Capture,
+    Loopback
+};
+
+
+enum class RenderMode : unsigned char {
+    Normal,
+    Pairwise,
+    Hrtf
+};
+
+enum class StereoEncoding : unsigned char {
+    Basic,
+    Uhj,
+    Hrtf,
+
+    Default = Basic
+};
+
+
+struct InputRemixMap {
+    struct TargetMix { Channel channel; float mix; };
+
+    Channel channel;
+    al::span<const TargetMix> targets;
+};
+
+
+struct DistanceComp {
+    /* Maximum delay in samples for speaker distance compensation. */
+    static constexpr uint MaxDelay{1024};
+
+    struct ChanData {
+        float Gain{1.0f};
+        uint Length{0u}; /* Valid range is [0...MaxDelay). */
+        float *Buffer{nullptr};
+    };
+
+    std::array<ChanData,MAX_OUTPUT_CHANNELS> mChannels;
+    al::FlexArray<float,16> mSamples;
+
+    DistanceComp(size_t count) : mSamples{count} { }
+
+    static std::unique_ptr<DistanceComp> Create(size_t numsamples)
+    { return std::unique_ptr<DistanceComp>{new(FamCount(numsamples)) DistanceComp{numsamples}}; }
+
+    DEF_FAM_NEWDEL(DistanceComp, mSamples)
+};
+
+
+constexpr uint InvalidChannelIndex{~0u};
+
+struct BFChannelConfig {
+    float Scale;
+    uint Index;
+};
+
+struct MixParams {
+    /* Coefficient channel mapping for mixing to the buffer. */
+    std::array<BFChannelConfig,MaxAmbiChannels> AmbiMap{};
+
+    al::span<FloatBufferLine> Buffer;
+
+    /**
+     * Helper to set an identity/pass-through panning for ambisonic mixing. The
+     * source is expected to be a 3D ACN/N3D ambisonic buffer, and for each
+     * channel [0...count), the given functor is called with the source channel
+     * index, destination channel index, and the gain for that channel. If the
+     * destination channel is INVALID_CHANNEL_INDEX, the given source channel
+     * is not used for output.
+     */
+    template<typename F>
+    void setAmbiMixParams(const MixParams &inmix, const float gainbase, F func) const
+    {
+        const size_t numIn{inmix.Buffer.size()};
+        const size_t numOut{Buffer.size()};
+        for(size_t i{0};i < numIn;++i)
+        {
+            auto idx = InvalidChannelIndex;
+            auto gain = 0.0f;
+
+            for(size_t j{0};j < numOut;++j)
+            {
+                if(AmbiMap[j].Index == inmix.AmbiMap[i].Index)
+                {
+                    idx = static_cast<uint>(j);
+                    gain = AmbiMap[j].Scale * gainbase;
+                    break;
+                }
+            }
+            func(i, idx, gain);
+        }
+    }
+};
+
+struct RealMixParams {
+    al::span<const InputRemixMap> RemixMap;
+    std::array<uint,MaxChannels> ChannelIndex{};
+
+    al::span<FloatBufferLine> Buffer;
+};
+
+using AmbiRotateMatrix = std::array<std::array<float,MaxAmbiChannels>,MaxAmbiChannels>;
+
+enum {
+    // Frequency was requested by the app or config file
+    FrequencyRequest,
+    // Channel configuration was requested by the app or config file
+    ChannelsRequest,
+    // Sample type was requested by the config file
+    SampleTypeRequest,
+
+    // Specifies if the DSP is paused at user request
+    DevicePaused,
+    // Specifies if the device is currently running
+    DeviceRunning,
+
+    // Specifies if the output plays directly on/in ears (headphones, headset,
+    // ear buds, etc).
+    DirectEar,
+
+    DeviceFlagsCount
+};
+
+struct DeviceBase {
+    /* To avoid extraneous allocations, a 0-sized FlexArray<ContextBase*> is
+     * defined globally as a sharable object.
+     */
+    static al::FlexArray<ContextBase*> sEmptyContextArray;
+
+    std::atomic<bool> Connected{true};
+    const DeviceType Type{};
+
+    uint Frequency{};
+    uint UpdateSize{};
+    uint BufferSize{};
+
+    DevFmtChannels FmtChans{};
+    DevFmtType FmtType{};
+    uint mAmbiOrder{0};
+    float mXOverFreq{400.0f};
+    /* If the main device mix is horizontal/2D only. */
+    bool m2DMixing{false};
+    /* For DevFmtAmbi* output only, specifies the channel order and
+     * normalization.
+     */
+    DevAmbiLayout mAmbiLayout{DevAmbiLayout::Default};
+    DevAmbiScaling mAmbiScale{DevAmbiScaling::Default};
+
+    std::string DeviceName;
+
+    // Device flags
+    std::bitset<DeviceFlagsCount> Flags{};
+
+    uint NumAuxSends{};
+
+    /* Rendering mode. */
+    RenderMode mRenderMode{RenderMode::Normal};
+
+    /* The average speaker distance as determined by the ambdec configuration,
+     * HRTF data set, or the NFC-HOA reference delay. Only used for NFC.
+     */
+    float AvgSpeakerDist{0.0f};
+
+    /* The default NFC filter. Not used directly, but is pre-initialized with
+     * the control distance from AvgSpeakerDist.
+     */
+    NfcFilter mNFCtrlFilter{};
+
+    uint SamplesDone{0u};
+    std::chrono::nanoseconds ClockBase{0};
+    std::chrono::nanoseconds FixedLatency{0};
+
+    AmbiRotateMatrix mAmbiRotateMatrix{};
+    AmbiRotateMatrix mAmbiRotateMatrix2{};
+
+    /* Temp storage used for mixer processing. */
+    static constexpr size_t MixerLineSize{BufferLineSize + DecoderBase::sMaxPadding};
+    static constexpr size_t MixerChannelsMax{16};
+    using MixerBufferLine = std::array<float,MixerLineSize>;
+    alignas(16) std::array<MixerBufferLine,MixerChannelsMax> mSampleData;
+    alignas(16) std::array<float,MixerLineSize+MaxResamplerPadding> mResampleData;
+
+    alignas(16) float FilteredData[BufferLineSize];
+    union {
+        alignas(16) float HrtfSourceData[BufferLineSize + HrtfHistoryLength];
+        alignas(16) float NfcSampleData[BufferLineSize];
+    };
+
+    /* Persistent storage for HRTF mixing. */
+    alignas(16) float2 HrtfAccumData[BufferLineSize + HrirLength];
+
+    /* Mixing buffer used by the Dry mix and Real output. */
+    al::vector<FloatBufferLine, 16> MixBuffer;
+
+    /* The "dry" path corresponds to the main output. */
+    MixParams Dry;
+    uint NumChannelsPerOrder[MaxAmbiOrder+1]{};
+
+    /* "Real" output, which will be written to the device buffer. May alias the
+     * dry buffer.
+     */
+    RealMixParams RealOut;
+
+    /* HRTF state and info */
+    std::unique_ptr<DirectHrtfState> mHrtfState;
+    al::intrusive_ptr<HrtfStore> mHrtf;
+    uint mIrSize{0};
+
+    /* Ambisonic-to-UHJ encoder */
+    std::unique_ptr<UhjEncoderBase> mUhjEncoder;
+
+    /* Ambisonic decoder for speakers */
+    std::unique_ptr<BFormatDec> AmbiDecoder;
+
+    /* Stereo-to-binaural filter */
+    std::unique_ptr<bs2b> Bs2b;
+
+    using PostProc = void(DeviceBase::*)(const size_t SamplesToDo);
+    PostProc PostProcess{nullptr};
+
+    std::unique_ptr<Compressor> Limiter;
+
+    /* Delay buffers used to compensate for speaker distances. */
+    std::unique_ptr<DistanceComp> ChannelDelays;
+
+    /* Dithering control. */
+    float DitherDepth{0.0f};
+    uint DitherSeed{0u};
+
+    /* Running count of the mixer invocations, in 31.1 fixed point. This
+     * actually increments *twice* when mixing, first at the start and then at
+     * the end, so the bottom bit indicates if the device is currently mixing
+     * and the upper bits indicates how many mixes have been done.
+     */
+    RefCount MixCount{0u};
+
+    // Contexts created on this device
+    std::atomic<al::FlexArray<ContextBase*>*> mContexts{nullptr};
+
+
+    DeviceBase(DeviceType type);
+    DeviceBase(const DeviceBase&) = delete;
+    DeviceBase& operator=(const DeviceBase&) = delete;
+    ~DeviceBase();
+
+    uint bytesFromFmt() const noexcept { return BytesFromDevFmt(FmtType); }
+    uint channelsFromFmt() const noexcept { return ChannelsFromDevFmt(FmtChans, mAmbiOrder); }
+    uint frameSizeFromFmt() const noexcept { return bytesFromFmt() * channelsFromFmt(); }
+
+    uint waitForMix() const noexcept
+    {
+        uint refcount;
+        while((refcount=MixCount.load(std::memory_order_acquire))&1) {
+        }
+        return refcount;
+    }
+
+    void ProcessHrtf(const size_t SamplesToDo);
+    void ProcessAmbiDec(const size_t SamplesToDo);
+    void ProcessAmbiDecStablized(const size_t SamplesToDo);
+    void ProcessUhj(const size_t SamplesToDo);
+    void ProcessBs2b(const size_t SamplesToDo);
+
+    inline void postProcess(const size_t SamplesToDo)
+    { if(PostProcess) LIKELY (this->*PostProcess)(SamplesToDo); }
+
+    void renderSamples(const al::span<float*> outBuffers, const uint numSamples);
+    void renderSamples(void *outBuffer, const uint numSamples, const size_t frameStep);
+
+    /* Caller must lock the device state, and the mixer must not be running. */
+#ifdef __USE_MINGW_ANSI_STDIO
+    [[gnu::format(gnu_printf,2,3)]]
+#else
+    [[gnu::format(printf,2,3)]]
+#endif
+    void handleDisconnect(const char *msg, ...);
+
+    /**
+     * Returns the index for the given channel name (e.g. FrontCenter), or
+     * INVALID_CHANNEL_INDEX if it doesn't exist.
+     */
+    uint channelIdxByName(Channel chan) const noexcept
+    { return RealOut.ChannelIndex[chan]; }
+
+    DISABLE_ALLOC()
+
+private:
+    uint renderSamples(const uint numSamples);
+};
+
+/* Must be less than 15 characters (16 including terminating null) for
+ * compatibility with pthread_setname_np limitations. */
+#define MIXER_THREAD_NAME "alsoft-mixer"
+
+#define RECORD_THREAD_NAME "alsoft-record"
+
+#endif /* CORE_DEVICE_H */
diff --git a/core/effects/base.h b/core/effects/base.h
new file mode 100644
index 00000000..4ee19f37
--- /dev/null
+++ b/core/effects/base.h
@@ -0,0 +1,197 @@
+#ifndef CORE_EFFECTS_BASE_H
+#define CORE_EFFECTS_BASE_H
+
+#include <stddef.h>
+
+#include "albyte.h"
+#include "almalloc.h"
+#include "alspan.h"
+#include "atomic.h"
+#include "core/bufferline.h"
+#include "intrusive_ptr.h"
+
+struct BufferStorage;
+struct ContextBase;
+struct DeviceBase;
+struct EffectSlot;
+struct MixParams;
+struct RealMixParams;
+
+
+/** Target gain for the reverb decay feedback reaching the decay time. */
+constexpr float ReverbDecayGain{0.001f}; /* -60 dB */
+
+constexpr float ReverbMaxReflectionsDelay{0.3f};
+constexpr float ReverbMaxLateReverbDelay{0.1f};
+
+enum class ChorusWaveform {
+    Sinusoid,
+    Triangle
+};
+
+constexpr float ChorusMaxDelay{0.016f};
+constexpr float FlangerMaxDelay{0.004f};
+
+constexpr float EchoMaxDelay{0.207f};
+constexpr float EchoMaxLRDelay{0.404f};
+
+enum class FShifterDirection {
+    Down,
+    Up,
+    Off
+};
+
+enum class ModulatorWaveform {
+    Sinusoid,
+    Sawtooth,
+    Square
+};
+
+enum class VMorpherPhenome {
+    A, E, I, O, U,
+    AA, AE, AH, AO, EH, ER, IH, IY, UH, UW,
+    B, D, F, G, J, K, L, M, N, P, R, S, T, V, Z
+};
+
+enum class VMorpherWaveform {
+    Sinusoid,
+    Triangle,
+    Sawtooth
+};
+
+union EffectProps {
+    struct {
+        float Density;
+        float Diffusion;
+        float Gain;
+        float GainHF;
+        float GainLF;
+        float DecayTime;
+        float DecayHFRatio;
+        float DecayLFRatio;
+        float ReflectionsGain;
+        float ReflectionsDelay;
+        float ReflectionsPan[3];
+        float LateReverbGain;
+        float LateReverbDelay;
+        float LateReverbPan[3];
+        float EchoTime;
+        float EchoDepth;
+        float ModulationTime;
+        float ModulationDepth;
+        float AirAbsorptionGainHF;
+        float HFReference;
+        float LFReference;
+        float RoomRolloffFactor;
+        bool DecayHFLimit;
+    } Reverb;
+
+    struct {
+        float AttackTime;
+        float ReleaseTime;
+        float Resonance;
+        float PeakGain;
+    } Autowah;
+
+    struct {
+        ChorusWaveform Waveform;
+        int Phase;
+        float Rate;
+        float Depth;
+        float Feedback;
+        float Delay;
+    } Chorus; /* Also Flanger */
+
+    struct {
+        bool OnOff;
+    } Compressor;
+
+    struct {
+        float Edge;
+        float Gain;
+        float LowpassCutoff;
+        float EQCenter;
+        float EQBandwidth;
+    } Distortion;
+
+    struct {
+        float Delay;
+        float LRDelay;
+
+        float Damping;
+        float Feedback;
+
+        float Spread;
+    } Echo;
+
+    struct {
+        float LowCutoff;
+        float LowGain;
+        float Mid1Center;
+        float Mid1Gain;
+        float Mid1Width;
+        float Mid2Center;
+        float Mid2Gain;
+        float Mid2Width;
+        float HighCutoff;
+        float HighGain;
+    } Equalizer;
+
+    struct {
+        float Frequency;
+        FShifterDirection LeftDirection;
+        FShifterDirection RightDirection;
+    } Fshifter;
+
+    struct {
+        float Frequency;
+        float HighPassCutoff;
+        ModulatorWaveform Waveform;
+    } Modulator;
+
+    struct {
+        int CoarseTune;
+        int FineTune;
+    } Pshifter;
+
+    struct {
+        float Rate;
+        VMorpherPhenome PhonemeA;
+        VMorpherPhenome PhonemeB;
+        int PhonemeACoarseTuning;
+        int PhonemeBCoarseTuning;
+        VMorpherWaveform Waveform;
+    } Vmorpher;
+
+    struct {
+        float Gain;
+    } Dedicated;
+};
+
+
+struct EffectTarget {
+    MixParams *Main;
+    RealMixParams *RealOut;
+};
+
+struct EffectState : public al::intrusive_ref<EffectState> {
+    al::span<FloatBufferLine> mOutTarget;
+
+
+    virtual ~EffectState() = default;
+
+    virtual void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) = 0;
+    virtual void update(const ContextBase *context, const EffectSlot *slot,
+        const EffectProps *props, const EffectTarget target) = 0;
+    virtual void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
+        const al::span<FloatBufferLine> samplesOut) = 0;
+};
+
+
+struct EffectStateFactory {
+    virtual ~EffectStateFactory() = default;
+
+    virtual al::intrusive_ptr<EffectState> create() = 0;
+};
+
+#endif /* CORE_EFFECTS_BASE_H */
diff --git a/core/effectslot.cpp b/core/effectslot.cpp
new file mode 100644
index 00000000..db8aa078
--- /dev/null
+++ b/core/effectslot.cpp
@@ -0,0 +1,19 @@
+
+#include "config.h"
+
+#include "effectslot.h"
+
+#include <stddef.h>
+
+#include "almalloc.h"
+#include "context.h"
+
+
+EffectSlotArray *EffectSlot::CreatePtrArray(size_t count) noexcept
+{
+    /* Allocate space for twice as many pointers, so the mixer has scratch
+     * space to store a sorted list during mixing.
+     */
+    void *ptr{al_calloc(alignof(EffectSlotArray), EffectSlotArray::Sizeof(count*2))};
+    return al::construct_at(static_cast<EffectSlotArray*>(ptr), count);
+}
diff --git a/core/effectslot.h b/core/effectslot.h
new file mode 100644
index 00000000..2624ae5f
--- /dev/null
+++ b/core/effectslot.h
@@ -0,0 +1,89 @@
+#ifndef CORE_EFFECTSLOT_H
+#define CORE_EFFECTSLOT_H
+
+#include <atomic>
+
+#include "almalloc.h"
+#include "device.h"
+#include "effects/base.h"
+#include "intrusive_ptr.h"
+
+struct EffectSlot;
+struct WetBuffer;
+
+using EffectSlotArray = al::FlexArray<EffectSlot*>;
+
+
+enum class EffectSlotType : unsigned char {
+    None,
+    Reverb,
+    Chorus,
+    Distortion,
+    Echo,
+    Flanger,
+    FrequencyShifter,
+    VocalMorpher,
+    PitchShifter,
+    RingModulator,
+    Autowah,
+    Compressor,
+    Equalizer,
+    EAXReverb,
+    DedicatedLFE,
+    DedicatedDialog,
+    Convolution
+};
+
+struct EffectSlotProps {
+    float Gain;
+    bool  AuxSendAuto;
+    EffectSlot *Target;
+
+    EffectSlotType Type;
+    EffectProps Props;
+
+    al::intrusive_ptr<EffectState> State;
+
+    std::atomic<EffectSlotProps*> next;
+
+    DEF_NEWDEL(EffectSlotProps)
+};
+
+
+struct EffectSlot {
+    bool InUse{false};
+
+    std::atomic<EffectSlotProps*> Update{nullptr};
+
+    /* Wet buffer configuration is ACN channel order with N3D scaling.
+     * Consequently, effects that only want to work with mono input can use
+     * channel 0 by itself. Effects that want multichannel can process the
+     * ambisonics signal and make a B-Format source pan.
+     */
+    MixParams Wet;
+
+    float Gain{1.0f};
+    bool  AuxSendAuto{true};
+    EffectSlot *Target{nullptr};
+
+    EffectSlotType EffectType{EffectSlotType::None};
+    EffectProps mEffectProps{};
+    al::intrusive_ptr<EffectState> mEffectState;
+
+    float RoomRolloff{0.0f}; /* Added to the source's room rolloff, not multiplied. */
+    float DecayTime{0.0f};
+    float DecayLFRatio{0.0f};
+    float DecayHFRatio{0.0f};
+    bool DecayHFLimit{false};
+    float AirAbsorptionGainHF{1.0f};
+
+    /* Mixing buffer used by the Wet mix. */
+    al::vector<FloatBufferLine,16> mWetBuffer;
+
+
+    static EffectSlotArray *CreatePtrArray(size_t count) noexcept;
+
+    DEF_NEWDEL(EffectSlot)
+};
+
+#endif /* CORE_EFFECTSLOT_H */
diff --git a/common/alexcpt.cpp b/core/except.cpp
index 5055e34f..45fd4eb5 100644
--- a/common/alexcpt.cpp
+++ b/core/except.cpp
@@ -1,7 +1,7 @@
 
 #include "config.h"
 
-#include "alexcpt.h"
+#include "except.h"
 
 #include <cstdio>
 #include <cstdarg>
@@ -11,20 +11,20 @@
 
 namespace al {
 
-backend_exception::backend_exception(ALCenum code, const char *msg, ...) : mErrorCode{code}
+base_exception::~base_exception() = default;
+
+void base_exception::setMessage(const char* msg, std::va_list args)
 {
-    va_list args, args2;
-    va_start(args, msg);
+    std::va_list args2;
     va_copy(args2, args);
     int msglen{std::vsnprintf(nullptr, 0, msg, args)};
-    if LIKELY(msglen > 0)
+    if(msglen > 0) LIKELY
     {
         mMessage.resize(static_cast<size_t>(msglen)+1);
-        std::vsnprintf(&mMessage[0], mMessage.length(), msg, args2);
+        std::vsnprintf(const_cast<char*>(mMessage.data()), mMessage.length(), msg, args2);
         mMessage.pop_back();
     }
     va_end(args2);
-    va_end(args);
 }
 
 } // namespace al
diff --git a/core/except.h b/core/except.h
new file mode 100644
index 00000000..0e28e9df
--- /dev/null
+++ b/core/except.h
@@ -0,0 +1,31 @@
+#ifndef CORE_EXCEPT_H
+#define CORE_EXCEPT_H
+
+#include <cstdarg>
+#include <exception>
+#include <string>
+#include <utility>
+
+
+namespace al {
+
+class base_exception : public std::exception {
+    std::string mMessage;
+
+protected:
+    base_exception() = default;
+    virtual ~base_exception();
+
+    void setMessage(const char *msg, std::va_list args);
+
+public:
+    const char *what() const noexcept override { return mMessage.c_str(); }
+};
+
+} // namespace al
+
+#define START_API_FUNC try
+
+#define END_API_FUNC catch(...) { std::terminate(); }
+
+#endif /* CORE_EXCEPT_H */
diff --git a/alc/filters/biquad.cpp b/core/filters/biquad.cpp
index 8a8810e2..a0a62eb8 100644
--- a/alc/filters/biquad.cpp
+++ b/core/filters/biquad.cpp
@@ -7,16 +7,21 @@
 #include <cassert>
 #include <cmath>
 
+#include "alnumbers.h"
 #include "opthelpers.h"
 
 
 template<typename Real>
-void BiquadFilterR<Real>::setParams(BiquadType type, Real gain, Real f0norm, Real rcpQ)
+void BiquadFilterR<Real>::setParams(BiquadType type, Real f0norm, Real gain, Real rcpQ)
 {
-    // Limit gain to -100dB
-    assert(gain > 0.00001f);
+    /* HACK: Limit gain to -100dB. This shouldn't ever happen, all callers
+     * already clamp to minimum of 0.001, or have a limited range of values
+     * that don't go below 0.126. But it seems to with some callers. This needs
+     * to be investigated.
+     */
+    gain = std::max(gain, Real(0.00001));
 
-    const Real w0{al::MathDefs<Real>::Tau() * f0norm};
+    const Real w0{al::numbers::pi_v<Real>*2.0f * f0norm};
     const Real sin_w0{std::sin(w0)};
     const Real cos_w0{std::cos(w0)};
     const Real alpha{sin_w0/2.0f * rcpQ};
@@ -89,10 +94,8 @@ void BiquadFilterR<Real>::setParams(BiquadType type, Real gain, Real f0norm, Rea
 }
 
 template<typename Real>
-void BiquadFilterR<Real>::process(Real *dst, const Real *src, const size_t numsamples)
+void BiquadFilterR<Real>::process(const al::span<const Real> src, Real *dst)
 {
-    ASSUME(numsamples > 0);
-
     const Real b0{mB0};
     const Real b1{mB1};
     const Real b2{mB2};
@@ -111,16 +114,55 @@ void BiquadFilterR<Real>::process(Real *dst, const Real *src, const size_t numsa
      */
     auto proc_sample = [b0,b1,b2,a1,a2,&z1,&z2](Real input) noexcept -> Real
     {
-        Real output = input*b0 + z1;
+        const Real output{input*b0 + z1};
         z1 = input*b1 - output*a1 + z2;
         z2 = input*b2 - output*a2;
         return output;
     };
-    std::transform(src, src+numsamples, dst, proc_sample);
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
 
     mZ1 = z1;
     mZ2 = z2;
 }
 
+template<typename Real>
+void BiquadFilterR<Real>::dualProcess(BiquadFilterR &other, const al::span<const Real> src,
+    Real *dst)
+{
+    const Real b00{mB0};
+    const Real b01{mB1};
+    const Real b02{mB2};
+    const Real a01{mA1};
+    const Real a02{mA2};
+    const Real b10{other.mB0};
+    const Real b11{other.mB1};
+    const Real b12{other.mB2};
+    const Real a11{other.mA1};
+    const Real a12{other.mA2};
+    Real z01{mZ1};
+    Real z02{mZ2};
+    Real z11{other.mZ1};
+    Real z12{other.mZ2};
+
+    auto proc_sample = [b00,b01,b02,a01,a02,b10,b11,b12,a11,a12,&z01,&z02,&z11,&z12](Real input) noexcept -> Real
+    {
+        const Real tmpout{input*b00 + z01};
+        z01 = input*b01 - tmpout*a01 + z02;
+        z02 = input*b02 - tmpout*a02;
+        input = tmpout;
+
+        const Real output{input*b10 + z11};
+        z11 = input*b11 - output*a11 + z12;
+        z12 = input*b12 - output*a12;
+        return output;
+    };
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
+
+    mZ1 = z01;
+    mZ2 = z02;
+    other.mZ1 = z11;
+    other.mZ2 = z12;
+}
+
 template class BiquadFilterR<float>;
 template class BiquadFilterR<double>;
diff --git a/alc/filters/biquad.h b/core/filters/biquad.h
index 9af954ae..75a4009b 100644
--- a/alc/filters/biquad.h
+++ b/core/filters/biquad.h
@@ -1,11 +1,13 @@
-#ifndef FILTERS_BIQUAD_H
-#define FILTERS_BIQUAD_H
+#ifndef CORE_FILTERS_BIQUAD_H
+#define CORE_FILTERS_BIQUAD_H
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <utility>
 
-#include "math_defs.h"
+#include "alnumbers.h"
+#include "alspan.h"
 
 
 /* Filters implementation is based on the "Cookbook formulae for audio
@@ -38,30 +40,70 @@ enum class BiquadType {
 template<typename Real>
 class BiquadFilterR {
     /* Last two delayed components for direct form II. */
-    Real mZ1{0.0f}, mZ2{0.0f};
+    Real mZ1{0}, mZ2{0};
     /* Transfer function coefficients "b" (numerator) */
-    Real mB0{1.0f}, mB1{0.0f}, mB2{0.0f};
+    Real mB0{1}, mB1{0}, mB2{0};
     /* Transfer function coefficients "a" (denominator; a0 is pre-applied). */
-    Real mA1{0.0f}, mA2{0.0f};
+    Real mA1{0}, mA2{0};
+
+    void setParams(BiquadType type, Real f0norm, Real gain, Real rcpQ);
+
+    /**
+     * Calculates the rcpQ (i.e. 1/Q) coefficient for shelving filters, using
+     * the reference gain and shelf slope parameter.
+     * \param gain 0 < gain
+     * \param slope 0 < slope <= 1
+     */
+    static Real rcpQFromSlope(Real gain, Real slope)
+    { return std::sqrt((gain + Real{1}/gain)*(Real{1}/slope - Real{1}) + Real{2}); }
+
+    /**
+     * Calculates the rcpQ (i.e. 1/Q) coefficient for filters, using the
+     * normalized reference frequency and bandwidth.
+     * \param f0norm 0 < f0norm < 0.5.
+     * \param bandwidth 0 < bandwidth
+     */
+    static Real rcpQFromBandwidth(Real f0norm, Real bandwidth)
+    {
+        const Real w0{al::numbers::pi_v<Real>*Real{2} * f0norm};
+        return 2.0f*std::sinh(std::log(Real{2})/Real{2}*bandwidth*w0/std::sin(w0));
+    }
 
 public:
-    void clear() noexcept { mZ1 = mZ2 = 0.0f; }
+    void clear() noexcept { mZ1 = mZ2 = Real{0}; }
 
     /**
      * Sets the filter state for the specified filter type and its parameters.
      *
      * \param type The type of filter to apply.
+     * \param f0norm The normalized reference frequency (ref / sample_rate).
+     * This is the center point for the Shelf, Peaking, and BandPass filter
+     * types, or the cutoff frequency for the LowPass and HighPass filter
+     * types.
      * \param gain The gain for the reference frequency response. Only used by
-     *             the Shelf and Peaking filter types.
-     * \param f0norm The reference frequency normal (ref_freq / sample_rate).
-     *               This is the center point for the Shelf, Peaking, and
-     *               BandPass filter types, or the cutoff frequency for the
-     *               LowPass and HighPass filter types.
-     * \param rcpQ The reciprocal of the Q coefficient for the filter's
-     *             transition band. Can be generated from rcpQFromSlope or
-     *             rcpQFromBandwidth as needed.
+     * the Shelf and Peaking filter types.
+     * \param slope Slope steepness of the transition band.
      */
-    void setParams(BiquadType type, Real gain, Real f0norm, Real rcpQ);
+    void setParamsFromSlope(BiquadType type, Real f0norm, Real gain, Real slope)
+    {
+        gain = std::max<Real>(gain, 0.001f); /* Limit -60dB */
+        setParams(type, f0norm, gain, rcpQFromSlope(gain, slope));
+    }
+
+    /**
+     * Sets the filter state for the specified filter type and its parameters.
+     *
+     * \param type The type of filter to apply.
+     * \param f0norm The normalized reference frequency (ref / sample_rate).
+     * This is the center point for the Shelf, Peaking, and BandPass filter
+     * types, or the cutoff frequency for the LowPass and HighPass filter
+     * types.
+     * \param gain The gain for the reference frequency response. Only used by
+     * the Shelf and Peaking filter types.
+     * \param bandwidth Normalized bandwidth of the transition band.
+     */
+    void setParamsFromBandwidth(BiquadType type, Real f0norm, Real gain, Real bandwidth)
+    { setParams(type, f0norm, gain, rcpQFromBandwidth(f0norm, bandwidth)); }
 
     void copyParamsFrom(const BiquadFilterR &other)
     {
@@ -72,42 +114,31 @@ public:
         mA2 = other.mA2;
     }
 
-
-    void process(Real *dst, const Real *src, const size_t numsamples);
+    void process(const al::span<const Real> src, Real *dst);
+    /** Processes this filter and the other at the same time. */
+    void dualProcess(BiquadFilterR &other, const al::span<const Real> src, Real *dst);
 
     /* Rather hacky. It's just here to support "manual" processing. */
     std::pair<Real,Real> getComponents() const noexcept { return {mZ1, mZ2}; }
     void setComponents(Real z1, Real z2) noexcept { mZ1 = z1; mZ2 = z2; }
     Real processOne(const Real in, Real &z1, Real &z2) const noexcept
     {
-        Real out{in*mB0 + z1};
+        const Real out{in*mB0 + z1};
         z1 = in*mB1 - out*mA1 + z2;
         z2 = in*mB2 - out*mA2;
         return out;
     }
+};
 
-    /**
-     * Calculates the rcpQ (i.e. 1/Q) coefficient for shelving filters, using
-     * the reference gain and shelf slope parameter.
-     * \param gain 0 < gain
-     * \param slope 0 < slope <= 1
-     */
-    static Real rcpQFromSlope(Real gain, Real slope)
-    { return std::sqrt((gain + 1.0f/gain)*(1.0f/slope - 1.0f) + 2.0f); }
+template<typename Real>
+struct DualBiquadR {
+    BiquadFilterR<Real> &f0, &f1;
 
-    /**
-     * Calculates the rcpQ (i.e. 1/Q) coefficient for filters, using the
-     * normalized reference frequency and bandwidth.
-     * \param f0norm 0 < f0norm < 0.5.
-     * \param bandwidth 0 < bandwidth
-     */
-    static Real rcpQFromBandwidth(Real f0norm, Real bandwidth)
-    {
-        const Real w0{al::MathDefs<Real>::Tau() * f0norm};
-        return 2.0f*std::sinh(std::log(Real{2.0f})/2.0f*bandwidth*w0/std::sin(w0));
-    }
+    void process(const al::span<const Real> src, Real *dst)
+    { f0.dualProcess(f1, src, dst); }
 };
 
 using BiquadFilter = BiquadFilterR<float>;
+using DualBiquad = DualBiquadR<float>;
 
-#endif /* FILTERS_BIQUAD_H */
+#endif /* CORE_FILTERS_BIQUAD_H */
diff --git a/alc/filters/nfc.cpp b/core/filters/nfc.cpp
index e4436b27..aa64c613 100644
--- a/alc/filters/nfc.cpp
+++ b/core/filters/nfc.cpp
@@ -62,25 +62,21 @@ NfcFilter1 NfcFilterCreate1(const float w0, const float w1) noexcept
     float b_00, g_0;
     float r;
 
-    nfc.base_gain = 1.0f;
-    nfc.gain = 1.0f;
-
-    /* Calculate bass-boost coefficients. */
-    r = 0.5f * w0;
+    /* Calculate bass-cut coefficients. */
+    r = 0.5f * w1;
     b_00 = B[1][0] * r;
     g_0 = 1.0f + b_00;
 
-    nfc.gain *= g_0;
-    nfc.b1 = 2.0f * b_00 / g_0;
+    nfc.base_gain = 1.0f / g_0;
+    nfc.a1 = 2.0f * b_00 / g_0;
 
-    /* Calculate bass-cut coefficients. */
-    r = 0.5f * w1;
+    /* Calculate bass-boost coefficients. */
+    r = 0.5f * w0;
     b_00 = B[1][0] * r;
     g_0 = 1.0f + b_00;
 
-    nfc.base_gain /= g_0;
-    nfc.gain /= g_0;
-    nfc.a1 = 2.0f * b_00 / g_0;
+    nfc.gain = nfc.base_gain * g_0;
+    nfc.b1 = 2.0f * b_00 / g_0;
 
     return nfc;
 }
@@ -102,29 +98,25 @@ NfcFilter2 NfcFilterCreate2(const float w0, const float w1) noexcept
     float b_10, b_11, g_1;
     float r;
 
-    nfc.base_gain = 1.0f;
-    nfc.gain = 1.0f;
-
-    /* Calculate bass-boost coefficients. */
-    r = 0.5f * w0;
+    /* Calculate bass-cut coefficients. */
+    r = 0.5f * w1;
     b_10 = B[2][0] * r;
     b_11 = B[2][1] * r * r;
     g_1 = 1.0f + b_10 + b_11;
 
-    nfc.gain *= g_1;
-    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.b2 = 4.0f * b_11 / g_1;
+    nfc.base_gain = 1.0f / g_1;
+    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.a2 = 4.0f * b_11 / g_1;
 
-    /* Calculate bass-cut coefficients. */
-    r = 0.5f * w1;
+    /* Calculate bass-boost coefficients. */
+    r = 0.5f * w0;
     b_10 = B[2][0] * r;
     b_11 = B[2][1] * r * r;
     g_1 = 1.0f + b_10 + b_11;
 
-    nfc.base_gain /= g_1;
-    nfc.gain /= g_1;
-    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.a2 = 4.0f * b_11 / g_1;
+    nfc.gain = nfc.base_gain * g_1;
+    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.b2 = 4.0f * b_11 / g_1;
 
     return nfc;
 }
@@ -149,35 +141,31 @@ NfcFilter3 NfcFilterCreate3(const float w0, const float w1) noexcept
     float b_00, g_0;
     float r;
 
-    nfc.base_gain = 1.0f;
-    nfc.gain = 1.0f;
-
-    /* Calculate bass-boost coefficients. */
-    r = 0.5f * w0;
+    /* Calculate bass-cut coefficients. */
+    r = 0.5f * w1;
     b_10 = B[3][0] * r;
     b_11 = B[3][1] * r * r;
     b_00 = B[3][2] * r;
     g_1 = 1.0f + b_10 + b_11;
     g_0 = 1.0f + b_00;
 
-    nfc.gain *= g_1 * g_0;
-    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.b2 = 4.0f * b_11 / g_1;
-    nfc.b3 = 2.0f * b_00 / g_0;
+    nfc.base_gain = 1.0f / (g_1 * g_0);
+    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.a2 = 4.0f * b_11 / g_1;
+    nfc.a3 = 2.0f * b_00 / g_0;
 
-    /* Calculate bass-cut coefficients. */
-    r = 0.5f * w1;
+    /* Calculate bass-boost coefficients. */
+    r = 0.5f * w0;
     b_10 = B[3][0] * r;
     b_11 = B[3][1] * r * r;
     b_00 = B[3][2] * r;
     g_1 = 1.0f + b_10 + b_11;
     g_0 = 1.0f + b_00;
 
-    nfc.base_gain /= g_1 * g_0;
-    nfc.gain /= g_1 * g_0;
-    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.a2 = 4.0f * b_11 / g_1;
-    nfc.a3 = 2.0f * b_00 / g_0;
+    nfc.gain = nfc.base_gain * (g_1 * g_0);
+    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.b2 = 4.0f * b_11 / g_1;
+    nfc.b3 = 2.0f * b_00 / g_0;
 
     return nfc;
 }
@@ -191,7 +179,7 @@ void NfcFilterAdjust3(NfcFilter3 *nfc, const float w0) noexcept
     const float g_1{1.0f + b_10 + b_11};
     const float g_0{1.0f + b_00};
 
-    nfc->gain = nfc->base_gain * g_1 * g_0;
+    nfc->gain = nfc->base_gain * (g_1 * g_0);
     nfc->b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
     nfc->b2 = 4.0f * b_11 / g_1;
     nfc->b3 = 2.0f * b_00 / g_0;
@@ -205,11 +193,8 @@ NfcFilter4 NfcFilterCreate4(const float w0, const float w1) noexcept
     float b_00, b_01, g_0;
     float r;
 
-    nfc.base_gain = 1.0f;
-    nfc.gain = 1.0f;
-
-    /* Calculate bass-boost coefficients. */
-    r = 0.5f * w0;
+    /* Calculate bass-cut coefficients. */
+    r = 0.5f * w1;
     b_10 = B[4][0] * r;
     b_11 = B[4][1] * r * r;
     b_00 = B[4][2] * r;
@@ -217,14 +202,14 @@ NfcFilter4 NfcFilterCreate4(const float w0, const float w1) noexcept
     g_1 = 1.0f + b_10 + b_11;
     g_0 = 1.0f + b_00 + b_01;
 
-    nfc.gain *= g_1 * g_0;
-    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.b2 = 4.0f * b_11 / g_1;
-    nfc.b3 = (2.0f*b_00 + 4.0f*b_01) / g_0;
-    nfc.b4 = 4.0f * b_01 / g_0;
+    nfc.base_gain = 1.0f / (g_1 * g_0);
+    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.a2 = 4.0f * b_11 / g_1;
+    nfc.a3 = (2.0f*b_00 + 4.0f*b_01) / g_0;
+    nfc.a4 = 4.0f * b_01 / g_0;
 
-    /* Calculate bass-cut coefficients. */
-    r = 0.5f * w1;
+    /* Calculate bass-boost coefficients. */
+    r = 0.5f * w0;
     b_10 = B[4][0] * r;
     b_11 = B[4][1] * r * r;
     b_00 = B[4][2] * r;
@@ -232,12 +217,11 @@ NfcFilter4 NfcFilterCreate4(const float w0, const float w1) noexcept
     g_1 = 1.0f + b_10 + b_11;
     g_0 = 1.0f + b_00 + b_01;
 
-    nfc.base_gain /= g_1 * g_0;
-    nfc.gain /= g_1 * g_0;
-    nfc.a1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
-    nfc.a2 = 4.0f * b_11 / g_1;
-    nfc.a3 = (2.0f*b_00 + 4.0f*b_01) / g_0;
-    nfc.a4 = 4.0f * b_01 / g_0;
+    nfc.gain = nfc.base_gain * (g_1 * g_0);
+    nfc.b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
+    nfc.b2 = 4.0f * b_11 / g_1;
+    nfc.b3 = (2.0f*b_00 + 4.0f*b_01) / g_0;
+    nfc.b4 = 4.0f * b_01 / g_0;
 
     return nfc;
 }
@@ -252,7 +236,7 @@ void NfcFilterAdjust4(NfcFilter4 *nfc, const float w0) noexcept
     const float g_1{1.0f + b_10 + b_11};
     const float g_0{1.0f + b_00 + b_01};
 
-    nfc->gain = nfc->base_gain * g_1 * g_0;
+    nfc->gain = nfc->base_gain * (g_1 * g_0);
     nfc->b1 = (2.0f*b_10 + 4.0f*b_11) / g_1;
     nfc->b2 = 4.0f * b_11 / g_1;
     nfc->b3 = (2.0f*b_00 + 4.0f*b_01) / g_0;
@@ -278,10 +262,8 @@ void NfcFilter::adjust(const float w0) noexcept
 }
 
 
-void NfcFilter::process1(float *RESTRICT dst, const float *RESTRICT src, const size_t count)
+void NfcFilter::process1(const al::span<const float> src, float *RESTRICT dst)
 {
-    ASSUME(count > 0);
-
     const float gain{first.gain};
     const float b1{first.b1};
     const float a1{first.a1};
@@ -293,14 +275,12 @@ void NfcFilter::process1(float *RESTRICT dst, const float *RESTRICT src, const s
         z1 += y;
         return out;
     };
-    std::transform(src, src+count, dst, proc_sample);
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
     first.z[0] = z1;
 }
 
-void NfcFilter::process2(float *RESTRICT dst, const float *RESTRICT src, const size_t count)
+void NfcFilter::process2(const al::span<const float> src, float *RESTRICT dst)
 {
-    ASSUME(count > 0);
-
     const float gain{second.gain};
     const float b1{second.b1};
     const float b2{second.b2};
@@ -316,15 +296,13 @@ void NfcFilter::process2(float *RESTRICT dst, const float *RESTRICT src, const s
         z1 += y;
         return out;
     };
-    std::transform(src, src+count, dst, proc_sample);
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
     second.z[0] = z1;
     second.z[1] = z2;
 }
 
-void NfcFilter::process3(float *RESTRICT dst, const float *RESTRICT src, const size_t count)
+void NfcFilter::process3(const al::span<const float> src, float *RESTRICT dst)
 {
-    ASSUME(count > 0);
-
     const float gain{third.gain};
     const float b1{third.b1};
     const float b2{third.b2};
@@ -347,16 +325,14 @@ void NfcFilter::process3(float *RESTRICT dst, const float *RESTRICT src, const s
         z3 += y;
         return out;
     };
-    std::transform(src, src+count, dst, proc_sample);
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
     third.z[0] = z1;
     third.z[1] = z2;
     third.z[2] = z3;
 }
 
-void NfcFilter::process4(float *RESTRICT dst, const float *RESTRICT src, const size_t count)
+void NfcFilter::process4(const al::span<const float> src, float *RESTRICT dst)
 {
-    ASSUME(count > 0);
-
     const float gain{fourth.gain};
     const float b1{fourth.b1};
     const float b2{fourth.b2};
@@ -383,7 +359,7 @@ void NfcFilter::process4(float *RESTRICT dst, const float *RESTRICT src, const s
         z3 += y;
         return out;
     };
-    std::transform(src, src+count, dst, proc_sample);
+    std::transform(src.cbegin(), src.cend(), dst, proc_sample);
     fourth.z[0] = z1;
     fourth.z[1] = z2;
     fourth.z[2] = z3;
diff --git a/alc/filters/nfc.h b/core/filters/nfc.h
index d2bf3339..33f67a5f 100644
--- a/alc/filters/nfc.h
+++ b/core/filters/nfc.h
@@ -1,8 +1,10 @@
-#ifndef FILTER_NFC_H
-#define FILTER_NFC_H
+#ifndef CORE_FILTERS_NFC_H
+#define CORE_FILTERS_NFC_H
 
 #include <cstddef>
 
+#include "alspan.h"
+
 
 struct NfcFilter1 {
     float base_gain, gain;
@@ -46,16 +48,16 @@ public:
     void adjust(const float w0) noexcept;
 
     /* Near-field control filter for first-order ambisonic channels (1-3). */
-    void process1(float *RESTRICT dst, const float *RESTRICT src, const size_t count);
+    void process1(const al::span<const float> src, float *RESTRICT dst);
 
     /* Near-field control filter for second-order ambisonic channels (4-8). */
-    void process2(float *RESTRICT dst, const float *RESTRICT src, const size_t count);
+    void process2(const al::span<const float> src, float *RESTRICT dst);
 
     /* Near-field control filter for third-order ambisonic channels (9-15). */
-    void process3(float *RESTRICT dst, const float *RESTRICT src, const size_t count);
+    void process3(const al::span<const float> src, float *RESTRICT dst);
 
     /* Near-field control filter for fourth-order ambisonic channels (16-24). */
-    void process4(float *RESTRICT dst, const float *RESTRICT src, const size_t count);
+    void process4(const al::span<const float> src, float *RESTRICT dst);
 };
 
-#endif /* FILTER_NFC_H */
+#endif /* CORE_FILTERS_NFC_H */
diff --git a/core/filters/splitter.cpp b/core/filters/splitter.cpp
new file mode 100644
index 00000000..983ba36f
--- /dev/null
+++ b/core/filters/splitter.cpp
@@ -0,0 +1,179 @@
+
+#include "config.h"
+
+#include "splitter.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "alnumbers.h"
+#include "opthelpers.h"
+
+
+template<typename Real>
+void BandSplitterR<Real>::init(Real f0norm)
+{
+    const Real w{f0norm * (al::numbers::pi_v<Real>*2)};
+    const Real cw{std::cos(w)};
+    if(cw > std::numeric_limits<float>::epsilon())
+        mCoeff = (std::sin(w) - 1.0f) / cw;
+    else
+        mCoeff = cw * -0.5f;
+
+    mLpZ1 = 0.0f;
+    mLpZ2 = 0.0f;
+    mApZ1 = 0.0f;
+}
+
+template<typename Real>
+void BandSplitterR<Real>::process(const al::span<const Real> input, Real *hpout, Real *lpout)
+{
+    const Real ap_coeff{mCoeff};
+    const Real lp_coeff{mCoeff*0.5f + 0.5f};
+    Real lp_z1{mLpZ1};
+    Real lp_z2{mLpZ2};
+    Real ap_z1{mApZ1};
+    auto proc_sample = [ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1,&lpout](const Real in) noexcept -> Real
+    {
+        /* Low-pass sample processing. */
+        Real d{(in - lp_z1) * lp_coeff};
+        Real lp_y{lp_z1 + d};
+        lp_z1 = lp_y + d;
+
+        d = (lp_y - lp_z2) * lp_coeff;
+        lp_y = lp_z2 + d;
+        lp_z2 = lp_y + d;
+
+        *(lpout++) = lp_y;
+
+        /* All-pass sample processing. */
+        Real ap_y{in*ap_coeff + ap_z1};
+        ap_z1 = in - ap_y*ap_coeff;
+
+        /* High-pass generated from removing low-passed output. */
+        return ap_y - lp_y;
+    };
+    std::transform(input.cbegin(), input.cend(), hpout, proc_sample);
+    mLpZ1 = lp_z1;
+    mLpZ2 = lp_z2;
+    mApZ1 = ap_z1;
+}
+
+template<typename Real>
+void BandSplitterR<Real>::processHfScale(const al::span<const Real> input, Real *RESTRICT output,
+    const Real hfscale)
+{
+    const Real ap_coeff{mCoeff};
+    const Real lp_coeff{mCoeff*0.5f + 0.5f};
+    Real lp_z1{mLpZ1};
+    Real lp_z2{mLpZ2};
+    Real ap_z1{mApZ1};
+    auto proc_sample = [hfscale,ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1](const Real in) noexcept -> Real
+    {
+        /* Low-pass sample processing. */
+        Real d{(in - lp_z1) * lp_coeff};
+        Real lp_y{lp_z1 + d};
+        lp_z1 = lp_y + d;
+
+        d = (lp_y - lp_z2) * lp_coeff;
+        lp_y = lp_z2 + d;
+        lp_z2 = lp_y + d;
+
+        /* All-pass sample processing. */
+        Real ap_y{in*ap_coeff + ap_z1};
+        ap_z1 = in - ap_y*ap_coeff;
+
+        /* High-pass generated by removing the low-passed signal, which is then
+         * scaled and added back to the low-passed signal.
+         */
+        return (ap_y-lp_y)*hfscale + lp_y;
+    };
+    std::transform(input.begin(), input.end(), output, proc_sample);
+    mLpZ1 = lp_z1;
+    mLpZ2 = lp_z2;
+    mApZ1 = ap_z1;
+}
+
+template<typename Real>
+void BandSplitterR<Real>::processHfScale(const al::span<Real> samples, const Real hfscale)
+{
+    const Real ap_coeff{mCoeff};
+    const Real lp_coeff{mCoeff*0.5f + 0.5f};
+    Real lp_z1{mLpZ1};
+    Real lp_z2{mLpZ2};
+    Real ap_z1{mApZ1};
+    auto proc_sample = [hfscale,ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1](const Real in) noexcept -> Real
+    {
+        /* Low-pass sample processing. */
+        Real d{(in - lp_z1) * lp_coeff};
+        Real lp_y{lp_z1 + d};
+        lp_z1 = lp_y + d;
+
+        d = (lp_y - lp_z2) * lp_coeff;
+        lp_y = lp_z2 + d;
+        lp_z2 = lp_y + d;
+
+        /* All-pass sample processing. */
+        Real ap_y{in*ap_coeff + ap_z1};
+        ap_z1 = in - ap_y*ap_coeff;
+
+        /* High-pass generated by removing the low-passed signal, which is then
+         * scaled and added back to the low-passed signal.
+         */
+        return (ap_y-lp_y)*hfscale + lp_y;
+    };
+    std::transform(samples.begin(), samples.end(), samples.begin(), proc_sample);
+    mLpZ1 = lp_z1;
+    mLpZ2 = lp_z2;
+    mApZ1 = ap_z1;
+}
+
+template<typename Real>
+void BandSplitterR<Real>::processScale(const al::span<Real> samples, const Real hfscale, const Real lfscale)
+{
+    const Real ap_coeff{mCoeff};
+    const Real lp_coeff{mCoeff*0.5f + 0.5f};
+    Real lp_z1{mLpZ1};
+    Real lp_z2{mLpZ2};
+    Real ap_z1{mApZ1};
+    auto proc_sample = [hfscale,lfscale,ap_coeff,lp_coeff,&lp_z1,&lp_z2,&ap_z1](const Real in) noexcept -> Real
+    {
+        Real d{(in - lp_z1) * lp_coeff};
+        Real lp_y{lp_z1 + d};
+        lp_z1 = lp_y + d;
+
+        d = (lp_y - lp_z2) * lp_coeff;
+        lp_y = lp_z2 + d;
+        lp_z2 = lp_y + d;
+
+        Real ap_y{in*ap_coeff + ap_z1};
+        ap_z1 = in - ap_y*ap_coeff;
+
+        /* Apply separate factors to the high and low frequencies. */
+        return (ap_y-lp_y)*hfscale + lp_y*lfscale;
+    };
+    std::transform(samples.begin(), samples.end(), samples.begin(), proc_sample);
+    mLpZ1 = lp_z1;
+    mLpZ2 = lp_z2;
+    mApZ1 = ap_z1;
+}
+
+template<typename Real>
+void BandSplitterR<Real>::processAllPass(const al::span<Real> samples)
+{
+    const Real coeff{mCoeff};
+    Real z1{mApZ1};
+    auto proc_sample = [coeff,&z1](const Real in) noexcept -> Real
+    {
+        const Real out{in*coeff + z1};
+        z1 = in - out*coeff;
+        return out;
+    };
+    std::transform(samples.cbegin(), samples.cend(), samples.begin(), proc_sample);
+    mApZ1 = z1;
+}
+
+
+template class BandSplitterR<float>;
+template class BandSplitterR<double>;
diff --git a/core/filters/splitter.h b/core/filters/splitter.h
new file mode 100644
index 00000000..e853eb38
--- /dev/null
+++ b/core/filters/splitter.h
@@ -0,0 +1,40 @@
+#ifndef CORE_FILTERS_SPLITTER_H
+#define CORE_FILTERS_SPLITTER_H
+
+#include <cstddef>
+
+#include "alspan.h"
+
+
+/* Band splitter. Splits a signal into two phase-matching frequency bands. */
+template<typename Real>
+class BandSplitterR {
+    Real mCoeff{0.0f};
+    Real mLpZ1{0.0f};
+    Real mLpZ2{0.0f};
+    Real mApZ1{0.0f};
+
+public:
+    BandSplitterR() = default;
+    BandSplitterR(const BandSplitterR&) = default;
+    BandSplitterR(Real f0norm) { init(f0norm); }
+    BandSplitterR& operator=(const BandSplitterR&) = default;
+
+    void init(Real f0norm);
+    void clear() noexcept { mLpZ1 = mLpZ2 = mApZ1 = 0.0f; }
+    void process(const al::span<const Real> input, Real *hpout, Real *lpout);
+
+    void processHfScale(const al::span<const Real> input, Real *output, const Real hfscale);
+
+    void processHfScale(const al::span<Real> samples, const Real hfscale);
+    void processScale(const al::span<Real> samples, const Real hfscale, const Real lfscale);
+
+    /**
+     * The all-pass portion of the band splitter. Applies the same phase shift
+     * without splitting or scaling the signal.
+     */
+    void processAllPass(const al::span<Real> samples);
+};
+using BandSplitter = BandSplitterR<float>;
+
+#endif /* CORE_FILTERS_SPLITTER_H */
diff --git a/core/fmt_traits.cpp b/core/fmt_traits.cpp
new file mode 100644
index 00000000..054d8766
--- /dev/null
+++ b/core/fmt_traits.cpp
@@ -0,0 +1,79 @@
+
+#include "config.h"
+
+#include "fmt_traits.h"
+
+
+namespace al {
+
+const int16_t muLawDecompressionTable[256] = {
+    -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
+    -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
+    -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
+    -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
+     -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
+     -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
+     -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
+     -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
+     -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
+     -1372, -1308, -1244, -1180, -1116, -1052,  -988,  -924,
+      -876,  -844,  -812,  -780,  -748,  -716,  -684,  -652,
+      -620,  -588,  -556,  -524,  -492,  -460,  -428,  -396,
+      -372,  -356,  -340,  -324,  -308,  -292,  -276,  -260,
+      -244,  -228,  -212,  -196,  -180,  -164,  -148,  -132,
+      -120,  -112,  -104,   -96,   -88,   -80,   -72,   -64,
+       -56,   -48,   -40,   -32,   -24,   -16,    -8,     0,
+     32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
+     23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
+     15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
+     11900, 11388, 10876, 10364,  9852,  9340,  8828,  8316,
+      7932,  7676,  7420,  7164,  6908,  6652,  6396,  6140,
+      5884,  5628,  5372,  5116,  4860,  4604,  4348,  4092,
+      3900,  3772,  3644,  3516,  3388,  3260,  3132,  3004,
+      2876,  2748,  2620,  2492,  2364,  2236,  2108,  1980,
+      1884,  1820,  1756,  1692,  1628,  1564,  1500,  1436,
+      1372,  1308,  1244,  1180,  1116,  1052,   988,   924,
+       876,   844,   812,   780,   748,   716,   684,   652,
+       620,   588,   556,   524,   492,   460,   428,   396,
+       372,   356,   340,   324,   308,   292,   276,   260,
+       244,   228,   212,   196,   180,   164,   148,   132,
+       120,   112,   104,    96,    88,    80,    72,    64,
+        56,    48,    40,    32,    24,    16,     8,     0
+};
+
+const int16_t aLawDecompressionTable[256] = {
+     -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
+     -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
+     -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
+     -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
+    -22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
+    -30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
+    -11008,-10496,-12032,-11520, -8960, -8448, -9984, -9472,
+    -15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
+      -344,  -328,  -376,  -360,  -280,  -264,  -312,  -296,
+      -472,  -456,  -504,  -488,  -408,  -392,  -440,  -424,
+       -88,   -72,  -120,  -104,   -24,    -8,   -56,   -40,
+      -216,  -200,  -248,  -232,  -152,  -136,  -184,  -168,
+     -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
+     -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
+      -688,  -656,  -752,  -720,  -560,  -528,  -624,  -592,
+      -944,  -912, -1008,  -976,  -816,  -784,  -880,  -848,
+      5504,  5248,  6016,  5760,  4480,  4224,  4992,  4736,
+      7552,  7296,  8064,  7808,  6528,  6272,  7040,  6784,
+      2752,  2624,  3008,  2880,  2240,  2112,  2496,  2368,
+      3776,  3648,  4032,  3904,  3264,  3136,  3520,  3392,
+     22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
+     30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
+     11008, 10496, 12032, 11520,  8960,  8448,  9984,  9472,
+     15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
+       344,   328,   376,   360,   280,   264,   312,   296,
+       472,   456,   504,   488,   408,   392,   440,   424,
+        88,    72,   120,   104,    24,     8,    56,    40,
+       216,   200,   248,   232,   152,   136,   184,   168,
+      1376,  1312,  1504,  1440,  1120,  1056,  1248,  1184,
+      1888,  1824,  2016,  1952,  1632,  1568,  1760,  1696,
+       688,   656,   752,   720,   560,   528,   624,   592,
+       944,   912,  1008,   976,   816,   784,   880,   848
+};
+
+} // namespace al
diff --git a/core/fmt_traits.h b/core/fmt_traits.h
new file mode 100644
index 00000000..f797f836
--- /dev/null
+++ b/core/fmt_traits.h
@@ -0,0 +1,81 @@
+#ifndef CORE_FMT_TRAITS_H
+#define CORE_FMT_TRAITS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "albyte.h"
+#include "buffer_storage.h"
+
+
+namespace al {
+
+extern const int16_t muLawDecompressionTable[256];
+extern const int16_t aLawDecompressionTable[256];
+
+
+template<FmtType T>
+struct FmtTypeTraits { };
+
+template<>
+struct FmtTypeTraits<FmtUByte> {
+    using Type = uint8_t;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept
+    { return val*OutT{1.0/128.0} - OutT{1.0}; }
+};
+template<>
+struct FmtTypeTraits<FmtShort> {
+    using Type = int16_t;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept { return val*OutT{1.0/32768.0}; }
+};
+template<>
+struct FmtTypeTraits<FmtFloat> {
+    using Type = float;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept { return val; }
+};
+template<>
+struct FmtTypeTraits<FmtDouble> {
+    using Type = double;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept { return static_cast<OutT>(val); }
+};
+template<>
+struct FmtTypeTraits<FmtMulaw> {
+    using Type = uint8_t;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept
+    { return muLawDecompressionTable[val] * OutT{1.0/32768.0}; }
+};
+template<>
+struct FmtTypeTraits<FmtAlaw> {
+    using Type = uint8_t;
+
+    template<typename OutT>
+    static constexpr inline OutT to(const Type val) noexcept
+    { return aLawDecompressionTable[val] * OutT{1.0/32768.0}; }
+};
+
+
+template<FmtType SrcType, typename DstT>
+inline void LoadSampleArray(DstT *RESTRICT dst, const al::byte *src, const size_t srcstep,
+    const size_t samples) noexcept
+{
+    using TypeTraits = FmtTypeTraits<SrcType>;
+    using SampleType = typename TypeTraits::Type;
+
+    const SampleType *RESTRICT ssrc{reinterpret_cast<const SampleType*>(src)};
+    for(size_t i{0u};i < samples;i++)
+        dst[i] = TypeTraits::template to<DstT>(ssrc[i*srcstep]);
+}
+
+} // namespace al
+
+#endif /* CORE_FMT_TRAITS_H */
diff --git a/core/fpu_ctrl.cpp b/core/fpu_ctrl.cpp
new file mode 100644
index 00000000..0cf0d6e7
--- /dev/null
+++ b/core/fpu_ctrl.cpp
@@ -0,0 +1,61 @@
+
+#include "config.h"
+
+#include "fpu_ctrl.h"
+
+#ifdef HAVE_INTRIN_H
+#include <intrin.h>
+#endif
+#ifdef HAVE_SSE_INTRINSICS
+#include <emmintrin.h>
+#ifndef _MM_DENORMALS_ZERO_MASK
+/* Some headers seem to be missing these? */
+#define _MM_DENORMALS_ZERO_MASK 0x0040u
+#define _MM_DENORMALS_ZERO_ON 0x0040u
+#endif
+#endif
+
+#include "cpu_caps.h"
+
+
+void FPUCtl::enter() noexcept
+{
+    if(this->in_mode) return;
+
+#if defined(HAVE_SSE_INTRINSICS)
+    this->sse_state = _mm_getcsr();
+    unsigned int sseState{this->sse_state};
+    sseState &= ~(_MM_FLUSH_ZERO_MASK | _MM_DENORMALS_ZERO_MASK);
+    sseState |= _MM_FLUSH_ZERO_ON | _MM_DENORMALS_ZERO_ON;
+    _mm_setcsr(sseState);
+
+#elif defined(__GNUC__) && defined(HAVE_SSE)
+
+    if((CPUCapFlags&CPU_CAP_SSE))
+    {
+        __asm__ __volatile__("stmxcsr %0" : "=m" (*&this->sse_state));
+        unsigned int sseState{this->sse_state};
+        sseState |= 0x8000; /* set flush-to-zero */
+        if((CPUCapFlags&CPU_CAP_SSE2))
+            sseState |= 0x0040; /* set denormals-are-zero */
+        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&sseState));
+    }
+#endif
+
+    this->in_mode = true;
+}
+
+void FPUCtl::leave() noexcept
+{
+    if(!this->in_mode) return;
+
+#if defined(HAVE_SSE_INTRINSICS)
+    _mm_setcsr(this->sse_state);
+
+#elif defined(__GNUC__) && defined(HAVE_SSE)
+
+    if((CPUCapFlags&CPU_CAP_SSE))
+        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&this->sse_state));
+#endif
+    this->in_mode = false;
+}
diff --git a/core/fpu_ctrl.h b/core/fpu_ctrl.h
new file mode 100644
index 00000000..9554313a
--- /dev/null
+++ b/core/fpu_ctrl.h
@@ -0,0 +1,21 @@
+#ifndef CORE_FPU_CTRL_H
+#define CORE_FPU_CTRL_H
+
+class FPUCtl {
+#if defined(HAVE_SSE_INTRINSICS) || (defined(__GNUC__) && defined(HAVE_SSE))
+    unsigned int sse_state{};
+#endif
+    bool in_mode{};
+
+public:
+    FPUCtl() noexcept { enter(); in_mode = true; }
+    ~FPUCtl() { if(in_mode) leave(); }
+
+    FPUCtl(const FPUCtl&) = delete;
+    FPUCtl& operator=(const FPUCtl&) = delete;
+
+    void enter() noexcept;
+    void leave() noexcept;
+};
+
+#endif /* CORE_FPU_CTRL_H */
diff --git a/core/front_stablizer.h b/core/front_stablizer.h
new file mode 100644
index 00000000..6825111a
--- /dev/null
+++ b/core/front_stablizer.h
@@ -0,0 +1,31 @@
+#ifndef CORE_FRONT_STABLIZER_H
+#define CORE_FRONT_STABLIZER_H
+
+#include <array>
+#include <memory>
+
+#include "almalloc.h"
+#include "bufferline.h"
+#include "filters/splitter.h"
+
+
+struct FrontStablizer {
+    FrontStablizer(size_t numchans) : ChannelFilters{numchans} { }
+
+    alignas(16) std::array<float,BufferLineSize> MidDirect{};
+    alignas(16) std::array<float,BufferLineSize> Side{};
+    alignas(16) std::array<float,BufferLineSize> Temp{};
+
+    BandSplitter MidFilter;
+    alignas(16) FloatBufferLine MidLF{};
+    alignas(16) FloatBufferLine MidHF{};
+
+    al::FlexArray<BandSplitter,16> ChannelFilters;
+
+    static std::unique_ptr<FrontStablizer> Create(size_t numchans)
+    { return std::unique_ptr<FrontStablizer>{new(FamCount(numchans)) FrontStablizer{numchans}}; }
+
+    DEF_FAM_NEWDEL(FrontStablizer, ChannelFilters)
+};
+
+#endif /* CORE_FRONT_STABLIZER_H */
diff --git a/core/helpers.cpp b/core/helpers.cpp
new file mode 100644
index 00000000..99cf009c
--- /dev/null
+++ b/core/helpers.cpp
@@ -0,0 +1,569 @@
+
+#include "config.h"
+
+#include "helpers.h"
+
+#include <algorithm>
+#include <cerrno>
+#include <cstdarg>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <mutex>
+#include <limits>
+#include <string>
+#include <tuple>
+
+#include "almalloc.h"
+#include "alfstream.h"
+#include "alnumeric.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "alstring.h"
+#include "logging.h"
+#include "strutils.h"
+#include "vector.h"
+
+
+/* Mixing thread piority level */
+int RTPrioLevel{1};
+
+/* Allow reducing the process's RTTime limit for RTKit. */
+bool AllowRTTimeLimit{true};
+
+
+#ifdef _WIN32
+
+#include <shlobj.h>
+
+const PathNamePair &GetProcBinary()
+{
+    static al::optional<PathNamePair> procbin;
+    if(procbin) return *procbin;
+
+    auto fullpath = al::vector<WCHAR>(256);
+    DWORD len{GetModuleFileNameW(nullptr, fullpath.data(), static_cast<DWORD>(fullpath.size()))};
+    while(len == fullpath.size())
+    {
+        fullpath.resize(fullpath.size() << 1);
+        len = GetModuleFileNameW(nullptr, fullpath.data(), static_cast<DWORD>(fullpath.size()));
+    }
+    if(len == 0)
+    {
+        ERR("Failed to get process name: error %lu\n", GetLastError());
+        procbin.emplace();
+        return *procbin;
+    }
+
+    fullpath.resize(len);
+    if(fullpath.back() != 0)
+        fullpath.push_back(0);
+
+    std::replace(fullpath.begin(), fullpath.end(), '/', '\\');
+    auto sep = std::find(fullpath.rbegin()+1, fullpath.rend(), '\\');
+    if(sep != fullpath.rend())
+    {
+        *sep = 0;
+        procbin.emplace(wstr_to_utf8(fullpath.data()), wstr_to_utf8(al::to_address(sep.base())));
+    }
+    else
+        procbin.emplace(std::string{}, wstr_to_utf8(fullpath.data()));
+
+    TRACE("Got binary: %s, %s\n", procbin->path.c_str(), procbin->fname.c_str());
+    return *procbin;
+}
+
+namespace {
+
+void DirectorySearch(const char *path, const char *ext, al::vector<std::string> *const results)
+{
+    std::string pathstr{path};
+    pathstr += "\\*";
+    pathstr += ext;
+    TRACE("Searching %s\n", pathstr.c_str());
+
+    std::wstring wpath{utf8_to_wstr(pathstr.c_str())};
+    WIN32_FIND_DATAW fdata;
+    HANDLE hdl{FindFirstFileW(wpath.c_str(), &fdata)};
+    if(hdl == INVALID_HANDLE_VALUE) return;
+
+    const auto base = results->size();
+
+    do {
+        results->emplace_back();
+        std::string &str = results->back();
+        str = path;
+        str += '\\';
+        str += wstr_to_utf8(fdata.cFileName);
+    } while(FindNextFileW(hdl, &fdata));
+    FindClose(hdl);
+
+    const al::span<std::string> newlist{results->data()+base, results->size()-base};
+    std::sort(newlist.begin(), newlist.end());
+    for(const auto &name : newlist)
+        TRACE(" got %s\n", name.c_str());
+}
+
+} // namespace
+
+al::vector<std::string> SearchDataFiles(const char *ext, const char *subdir)
+{
+    auto is_slash = [](int c) noexcept -> int { return (c == '\\' || c == '/'); };
+
+    static std::mutex search_lock;
+    std::lock_guard<std::mutex> _{search_lock};
+
+    /* If the path is absolute, use it directly. */
+    al::vector<std::string> results;
+    if(isalpha(subdir[0]) && subdir[1] == ':' && is_slash(subdir[2]))
+    {
+        std::string path{subdir};
+        std::replace(path.begin(), path.end(), '/', '\\');
+        DirectorySearch(path.c_str(), ext, &results);
+        return results;
+    }
+    if(subdir[0] == '\\' && subdir[1] == '\\' && subdir[2] == '?' && subdir[3] == '\\')
+    {
+        DirectorySearch(subdir, ext, &results);
+        return results;
+    }
+
+    std::string path;
+
+    /* Search the app-local directory. */
+    if(auto localpath = al::getenv(L"ALSOFT_LOCAL_PATH"))
+    {
+        path = wstr_to_utf8(localpath->c_str());
+        if(is_slash(path.back()))
+            path.pop_back();
+    }
+    else if(WCHAR *cwdbuf{_wgetcwd(nullptr, 0)})
+    {
+        path = wstr_to_utf8(cwdbuf);
+        if(is_slash(path.back()))
+            path.pop_back();
+        free(cwdbuf);
+    }
+    else
+        path = ".";
+    std::replace(path.begin(), path.end(), '/', '\\');
+    DirectorySearch(path.c_str(), ext, &results);
+
+    /* Search the local and global data dirs. */
+    static const int ids[2]{ CSIDL_APPDATA, CSIDL_COMMON_APPDATA };
+    for(int id : ids)
+    {
+        WCHAR buffer[MAX_PATH];
+        if(SHGetSpecialFolderPathW(nullptr, buffer, id, FALSE) == FALSE)
+            continue;
+
+        path = wstr_to_utf8(buffer);
+        if(!is_slash(path.back()))
+            path += '\\';
+        path += subdir;
+        std::replace(path.begin(), path.end(), '/', '\\');
+
+        DirectorySearch(path.c_str(), ext, &results);
+    }
+
+    return results;
+}
+
+void SetRTPriority(void)
+{
+    if(RTPrioLevel > 0)
+    {
+        if(!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
+            ERR("Failed to set priority level for thread\n");
+    }
+}
+
+#else
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <dirent.h>
+#ifdef __FreeBSD__
+#include <sys/sysctl.h>
+#endif
+#ifdef __HAIKU__
+#include <FindDirectory.h>
+#endif
+#ifdef HAVE_PROC_PIDPATH
+#include <libproc.h>
+#endif
+#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
+#include <pthread.h>
+#include <sched.h>
+#endif
+#ifdef HAVE_RTKIT
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "dbus_wrap.h"
+#include "rtkit.h"
+#ifndef RLIMIT_RTTIME
+#define RLIMIT_RTTIME 15
+#endif
+#endif
+
+const PathNamePair &GetProcBinary()
+{
+    static al::optional<PathNamePair> procbin;
+    if(procbin) return *procbin;
+
+    al::vector<char> pathname;
+#ifdef __FreeBSD__
+    size_t pathlen;
+    int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+    if(sysctl(mib, 4, nullptr, &pathlen, nullptr, 0) == -1)
+        WARN("Failed to sysctl kern.proc.pathname: %s\n", strerror(errno));
+    else
+    {
+        pathname.resize(pathlen + 1);
+        sysctl(mib, 4, pathname.data(), &pathlen, nullptr, 0);
+        pathname.resize(pathlen);
+    }
+#endif
+#ifdef HAVE_PROC_PIDPATH
+    if(pathname.empty())
+    {
+        char procpath[PROC_PIDPATHINFO_MAXSIZE]{};
+        const pid_t pid{getpid()};
+        if(proc_pidpath(pid, procpath, sizeof(procpath)) < 1)
+            ERR("proc_pidpath(%d, ...) failed: %s\n", pid, strerror(errno));
+        else
+            pathname.insert(pathname.end(), procpath, procpath+strlen(procpath));
+    }
+#endif
+#ifdef __HAIKU__
+    if(pathname.empty())
+    {
+        char procpath[PATH_MAX];
+        if(find_path(B_APP_IMAGE_SYMBOL, B_FIND_PATH_IMAGE_PATH, NULL, procpath, sizeof(procpath)) == B_OK)
+            pathname.insert(pathname.end(), procpath, procpath+strlen(procpath));
+    }
+#endif
+#ifndef __SWITCH__
+    if(pathname.empty())
+    {
+        static const char SelfLinkNames[][32]{
+            "/proc/self/exe",
+            "/proc/self/file",
+            "/proc/curproc/exe",
+            "/proc/curproc/file"
+        };
+
+        pathname.resize(256);
+
+        const char *selfname{};
+        ssize_t len{};
+        for(const char *name : SelfLinkNames)
+        {
+            selfname = name;
+            len = readlink(selfname, pathname.data(), pathname.size());
+            if(len >= 0 || errno != ENOENT) break;
+        }
+
+        while(len > 0 && static_cast<size_t>(len) == pathname.size())
+        {
+            pathname.resize(pathname.size() << 1);
+            len = readlink(selfname, pathname.data(), pathname.size());
+        }
+        if(len <= 0)
+        {
+            WARN("Failed to readlink %s: %s\n", selfname, strerror(errno));
+            len = 0;
+        }
+
+        pathname.resize(static_cast<size_t>(len));
+    }
+#endif
+    while(!pathname.empty() && pathname.back() == 0)
+        pathname.pop_back();
+
+    auto sep = std::find(pathname.crbegin(), pathname.crend(), '/');
+    if(sep != pathname.crend())
+        procbin.emplace(std::string(pathname.cbegin(), sep.base()-1),
+            std::string(sep.base(), pathname.cend()));
+    else
+        procbin.emplace(std::string{}, std::string(pathname.cbegin(), pathname.cend()));
+
+    TRACE("Got binary: \"%s\", \"%s\"\n", procbin->path.c_str(), procbin->fname.c_str());
+    return *procbin;
+}
+
+namespace {
+
+void DirectorySearch(const char *path, const char *ext, al::vector<std::string> *const results)
+{
+    TRACE("Searching %s for *%s\n", path, ext);
+    DIR *dir{opendir(path)};
+    if(!dir) return;
+
+    const auto base = results->size();
+    const size_t extlen{strlen(ext)};
+
+    while(struct dirent *dirent{readdir(dir)})
+    {
+        if(strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0)
+            continue;
+
+        const size_t len{strlen(dirent->d_name)};
+        if(len <= extlen) continue;
+        if(al::strcasecmp(dirent->d_name+len-extlen, ext) != 0)
+            continue;
+
+        results->emplace_back();
+        std::string &str = results->back();
+        str = path;
+        if(str.back() != '/')
+            str.push_back('/');
+        str += dirent->d_name;
+    }
+    closedir(dir);
+
+    const al::span<std::string> newlist{results->data()+base, results->size()-base};
+    std::sort(newlist.begin(), newlist.end());
+    for(const auto &name : newlist)
+        TRACE(" got %s\n", name.c_str());
+}
+
+} // namespace
+
+al::vector<std::string> SearchDataFiles(const char *ext, const char *subdir)
+{
+    static std::mutex search_lock;
+    std::lock_guard<std::mutex> _{search_lock};
+
+    al::vector<std::string> results;
+    if(subdir[0] == '/')
+    {
+        DirectorySearch(subdir, ext, &results);
+        return results;
+    }
+
+    /* Search the app-local directory. */
+    if(auto localpath = al::getenv("ALSOFT_LOCAL_PATH"))
+        DirectorySearch(localpath->c_str(), ext, &results);
+    else
+    {
+        al::vector<char> cwdbuf(256);
+        while(!getcwd(cwdbuf.data(), cwdbuf.size()))
+        {
+            if(errno != ERANGE)
+            {
+                cwdbuf.clear();
+                break;
+            }
+            cwdbuf.resize(cwdbuf.size() << 1);
+        }
+        if(cwdbuf.empty())
+            DirectorySearch(".", ext, &results);
+        else
+        {
+            DirectorySearch(cwdbuf.data(), ext, &results);
+            cwdbuf.clear();
+        }
+    }
+
+    // Search local data dir
+    if(auto datapath = al::getenv("XDG_DATA_HOME"))
+    {
+        std::string &path = *datapath;
+        if(path.back() != '/')
+            path += '/';
+        path += subdir;
+        DirectorySearch(path.c_str(), ext, &results);
+    }
+    else if(auto homepath = al::getenv("HOME"))
+    {
+        std::string &path = *homepath;
+        if(path.back() == '/')
+            path.pop_back();
+        path += "/.local/share/";
+        path += subdir;
+        DirectorySearch(path.c_str(), ext, &results);
+    }
+
+    // Search global data dirs
+    std::string datadirs{al::getenv("XDG_DATA_DIRS").value_or("/usr/local/share/:/usr/share/")};
+
+    size_t curpos{0u};
+    while(curpos < datadirs.size())
+    {
+        size_t nextpos{datadirs.find(':', curpos)};
+
+        std::string path{(nextpos != std::string::npos) ?
+            datadirs.substr(curpos, nextpos++ - curpos) : datadirs.substr(curpos)};
+        curpos = nextpos;
+
+        if(path.empty()) continue;
+        if(path.back() != '/')
+            path += '/';
+        path += subdir;
+
+        DirectorySearch(path.c_str(), ext, &results);
+    }
+
+#ifdef ALSOFT_INSTALL_DATADIR
+    // Search the installation data directory
+    {
+        std::string path{ALSOFT_INSTALL_DATADIR};
+        if(!path.empty())
+        {
+            if(path.back() != '/')
+                path += '/';
+            path += subdir;
+            DirectorySearch(path.c_str(), ext, &results);
+        }
+    }
+#endif
+
+    return results;
+}
+
+namespace {
+
+bool SetRTPriorityPthread(int prio)
+{
+    int err{ENOTSUP};
+#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
+    /* Get the min and max priority for SCHED_RR. Limit the max priority to
+     * half, for now, to ensure the thread can't take the highest priority and
+     * go rogue.
+     */
+    int rtmin{sched_get_priority_min(SCHED_RR)};
+    int rtmax{sched_get_priority_max(SCHED_RR)};
+    rtmax = (rtmax-rtmin)/2 + rtmin;
+
+    struct sched_param param{};
+    param.sched_priority = clampi(prio, rtmin, rtmax);
+#ifdef SCHED_RESET_ON_FORK
+    err = pthread_setschedparam(pthread_self(), SCHED_RR|SCHED_RESET_ON_FORK, &param);
+    if(err == EINVAL)
+#endif
+        err = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
+    if(err == 0) return true;
+
+#else
+
+    std::ignore = prio;
+#endif
+    WARN("pthread_setschedparam failed: %s (%d)\n", std::strerror(err), err);
+    return false;
+}
+
+bool SetRTPriorityRTKit(int prio)
+{
+#ifdef HAVE_RTKIT
+    if(!HasDBus())
+    {
+        WARN("D-Bus not available\n");
+        return false;
+    }
+    dbus::Error error;
+    dbus::ConnectionPtr conn{dbus_bus_get(DBUS_BUS_SYSTEM, &error.get())};
+    if(!conn)
+    {
+        WARN("D-Bus connection failed with %s: %s\n", error->name, error->message);
+        return false;
+    }
+
+    /* Don't stupidly exit if the connection dies while doing this. */
+    dbus_connection_set_exit_on_disconnect(conn.get(), false);
+
+    int nicemin{};
+    int err{rtkit_get_min_nice_level(conn.get(), &nicemin)};
+    if(err == -ENOENT)
+    {
+        err = std::abs(err);
+        ERR("Could not query RTKit: %s (%d)\n", std::strerror(err), err);
+        return false;
+    }
+    int rtmax{rtkit_get_max_realtime_priority(conn.get())};
+    TRACE("Maximum real-time priority: %d, minimum niceness: %d\n", rtmax, nicemin);
+
+    auto limit_rttime = [](DBusConnection *c) -> int
+    {
+        using ulonglong = unsigned long long;
+        long long maxrttime{rtkit_get_rttime_usec_max(c)};
+        if(maxrttime <= 0) return static_cast<int>(std::abs(maxrttime));
+        const ulonglong umaxtime{static_cast<ulonglong>(maxrttime)};
+
+        struct rlimit rlim{};
+        if(getrlimit(RLIMIT_RTTIME, &rlim) != 0)
+            return errno;
+
+        TRACE("RTTime max: %llu (hard: %llu, soft: %llu)\n", umaxtime,
+            static_cast<ulonglong>(rlim.rlim_max), static_cast<ulonglong>(rlim.rlim_cur));
+        if(rlim.rlim_max > umaxtime)
+        {
+            rlim.rlim_max = static_cast<rlim_t>(std::min<ulonglong>(umaxtime,
+                std::numeric_limits<rlim_t>::max()));
+            rlim.rlim_cur = std::min(rlim.rlim_cur, rlim.rlim_max);
+            if(setrlimit(RLIMIT_RTTIME, &rlim) != 0)
+                return errno;
+        }
+        return 0;
+    };
+    if(rtmax > 0)
+    {
+        if(AllowRTTimeLimit)
+        {
+            err = limit_rttime(conn.get());
+            if(err != 0)
+                WARN("Failed to set RLIMIT_RTTIME for RTKit: %s (%d)\n",
+                    std::strerror(err), err);
+        }
+
+        /* Limit the maximum real-time priority to half. */
+        rtmax = (rtmax+1)/2;
+        prio = clampi(prio, 1, rtmax);
+
+        TRACE("Making real-time with priority %d (max: %d)\n", prio, rtmax);
+        err = rtkit_make_realtime(conn.get(), 0, prio);
+        if(err == 0) return true;
+
+        err = std::abs(err);
+        WARN("Failed to set real-time priority: %s (%d)\n", std::strerror(err), err);
+    }
+    /* Don't try to set the niceness for non-Linux systems. Standard POSIX has
+     * niceness as a per-process attribute, while the intent here is for the
+     * audio processing thread only to get a priority boost. Currently only
+     * Linux is known to have per-thread niceness.
+     */
+#ifdef __linux__
+    if(nicemin < 0)
+    {
+        TRACE("Making high priority with niceness %d\n", nicemin);
+        err = rtkit_make_high_priority(conn.get(), 0, nicemin);
+        if(err == 0) return true;
+
+        err = std::abs(err);
+        WARN("Failed to set high priority: %s (%d)\n", std::strerror(err), err);
+    }
+#endif /* __linux__ */
+
+#else
+
+    std::ignore = prio;
+    WARN("D-Bus not supported\n");
+#endif
+    return false;
+}
+
+} // namespace
+
+void SetRTPriority()
+{
+    if(RTPrioLevel <= 0)
+        return;
+
+    if(SetRTPriorityPthread(RTPrioLevel))
+        return;
+    if(SetRTPriorityRTKit(RTPrioLevel))
+        return;
+}
+
+#endif
diff --git a/core/helpers.h b/core/helpers.h
new file mode 100644
index 00000000..f0bfcf1b
--- /dev/null
+++ b/core/helpers.h
@@ -0,0 +1,18 @@
+#ifndef CORE_HELPERS_H
+#define CORE_HELPERS_H
+
+#include <string>
+
+#include "vector.h"
+
+
+struct PathNamePair { std::string path, fname; };
+const PathNamePair &GetProcBinary(void);
+
+extern int RTPrioLevel;
+extern bool AllowRTTimeLimit;
+void SetRTPriority(void);
+
+al::vector<std::string> SearchDataFiles(const char *match, const char *subdir);
+
+#endif /* CORE_HELPERS_H */
diff --git a/core/hrtf.cpp b/core/hrtf.cpp
new file mode 100644
index 00000000..d5c7573a
--- /dev/null
+++ b/core/hrtf.cpp
@@ -0,0 +1,1473 @@
+
+#include "config.h"
+
+#include "hrtf.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cctype>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <numeric>
+#include <type_traits>
+#include <utility>
+
+#include "albit.h"
+#include "albyte.h"
+#include "alfstream.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alnumeric.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "ambidefs.h"
+#include "filters/splitter.h"
+#include "helpers.h"
+#include "logging.h"
+#include "mixer/hrtfdefs.h"
+#include "opthelpers.h"
+#include "polyphase_resampler.h"
+#include "vector.h"
+
+
+namespace {
+
+struct HrtfEntry {
+    std::string mDispName;
+    std::string mFilename;
+
+    /* GCC warns when it tries to inline this. */
+    ~HrtfEntry();
+};
+HrtfEntry::~HrtfEntry() = default;
+
+struct LoadedHrtf {
+    std::string mFilename;
+    std::unique_ptr<HrtfStore> mEntry;
+
+    template<typename T, typename U>
+    LoadedHrtf(T&& name, U&& entry)
+        : mFilename{std::forward<T>(name)}, mEntry{std::forward<U>(entry)}
+    { }
+    LoadedHrtf(LoadedHrtf&&) = default;
+    /* GCC warns when it tries to inline this. */
+    ~LoadedHrtf();
+
+    LoadedHrtf& operator=(LoadedHrtf&&) = default;
+};
+LoadedHrtf::~LoadedHrtf() = default;
+
+
+/* Data set limits must be the same as or more flexible than those defined in
+ * the makemhr utility.
+ */
+constexpr uint MinFdCount{1};
+constexpr uint MaxFdCount{16};
+
+constexpr uint MinFdDistance{50};
+constexpr uint MaxFdDistance{2500};
+
+constexpr uint MinEvCount{5};
+constexpr uint MaxEvCount{181};
+
+constexpr uint MinAzCount{1};
+constexpr uint MaxAzCount{255};
+
+constexpr uint MaxHrirDelay{HrtfHistoryLength - 1};
+
+constexpr uint HrirDelayFracBits{2};
+constexpr uint HrirDelayFracOne{1 << HrirDelayFracBits};
+constexpr uint HrirDelayFracHalf{HrirDelayFracOne >> 1};
+
+static_assert(MaxHrirDelay*HrirDelayFracOne < 256, "MAX_HRIR_DELAY or DELAY_FRAC too large");
+
+constexpr char magicMarker00[8]{'M','i','n','P','H','R','0','0'};
+constexpr char magicMarker01[8]{'M','i','n','P','H','R','0','1'};
+constexpr char magicMarker02[8]{'M','i','n','P','H','R','0','2'};
+constexpr char magicMarker03[8]{'M','i','n','P','H','R','0','3'};
+
+/* First value for pass-through coefficients (remaining are 0), used for omni-
+ * directional sounds. */
+constexpr auto PassthruCoeff = static_cast<float>(1.0/al::numbers::sqrt2);
+
+std::mutex LoadedHrtfLock;
+al::vector<LoadedHrtf> LoadedHrtfs;
+
+std::mutex EnumeratedHrtfLock;
+al::vector<HrtfEntry> EnumeratedHrtfs;
+
+
+class databuf final : public std::streambuf {
+    int_type underflow() override
+    { return traits_type::eof(); }
+
+    pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode) override
+    {
+        if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
+            return traits_type::eof();
+
+        char_type *cur;
+        switch(whence)
+        {
+            case std::ios_base::beg:
+                if(offset < 0 || offset > egptr()-eback())
+                    return traits_type::eof();
+                cur = eback() + offset;
+                break;
+
+            case std::ios_base::cur:
+                if((offset >= 0 && offset > egptr()-gptr()) ||
+                   (offset < 0 && -offset > gptr()-eback()))
+                    return traits_type::eof();
+                cur = gptr() + offset;
+                break;
+
+            case std::ios_base::end:
+                if(offset > 0 || -offset > egptr()-eback())
+                    return traits_type::eof();
+                cur = egptr() + offset;
+                break;
+
+            default:
+                return traits_type::eof();
+        }
+
+        setg(eback(), cur, egptr());
+        return cur - eback();
+    }
+
+    pos_type seekpos(pos_type pos, std::ios_base::openmode mode) override
+    {
+        // Simplified version of seekoff
+        if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
+            return traits_type::eof();
+
+        if(pos < 0 || pos > egptr()-eback())
+            return traits_type::eof();
+
+        setg(eback(), eback() + static_cast<size_t>(pos), egptr());
+        return pos;
+    }
+
+public:
+    databuf(const char_type *start_, const char_type *end_) noexcept
+    {
+        setg(const_cast<char_type*>(start_), const_cast<char_type*>(start_),
+             const_cast<char_type*>(end_));
+    }
+};
+
+class idstream final : public std::istream {
+    databuf mStreamBuf;
+
+public:
+    idstream(const char *start_, const char *end_)
+      : std::istream{nullptr}, mStreamBuf{start_, end_}
+    { init(&mStreamBuf); }
+};
+
+
+struct IdxBlend { uint idx; float blend; };
+/* Calculate the elevation index given the polar elevation in radians. This
+ * will return an index between 0 and (evcount - 1).
+ */
+IdxBlend CalcEvIndex(uint evcount, float ev)
+{
+    ev = (al::numbers::pi_v<float>*0.5f + ev) * static_cast<float>(evcount-1) *
+        al::numbers::inv_pi_v<float>;
+    uint idx{float2uint(ev)};
+
+    return IdxBlend{minu(idx, evcount-1), ev-static_cast<float>(idx)};
+}
+
+/* Calculate the azimuth index given the polar azimuth in radians. This will
+ * return an index between 0 and (azcount - 1).
+ */
+IdxBlend CalcAzIndex(uint azcount, float az)
+{
+    az = (al::numbers::pi_v<float>*2.0f + az) * static_cast<float>(azcount) *
+        (al::numbers::inv_pi_v<float>*0.5f);
+    uint idx{float2uint(az)};
+
+    return IdxBlend{idx%azcount, az-static_cast<float>(idx)};
+}
+
+} // namespace
+
+
+/* Calculates static HRIR coefficients and delays for the given polar elevation
+ * and azimuth in radians. The coefficients are normalized.
+ */
+void HrtfStore::getCoeffs(float elevation, float azimuth, float distance, float spread,
+    HrirArray &coeffs, const al::span<uint,2> delays)
+{
+    const float dirfact{1.0f - (al::numbers::inv_pi_v<float>/2.0f * spread)};
+
+    size_t ebase{0};
+    auto match_field = [&ebase,distance](const Field &field) noexcept -> bool
+    {
+        if(distance >= field.distance)
+            return true;
+        ebase += field.evCount;
+        return false;
+    };
+    auto field = std::find_if(mFields.begin(), mFields.end()-1, match_field);
+
+    /* Calculate the elevation indices. */
+    const auto elev0 = CalcEvIndex(field->evCount, elevation);
+    const size_t elev1_idx{minu(elev0.idx+1, field->evCount-1)};
+    const size_t ir0offset{mElev[ebase + elev0.idx].irOffset};
+    const size_t ir1offset{mElev[ebase + elev1_idx].irOffset};
+
+    /* Calculate azimuth indices. */
+    const auto az0 = CalcAzIndex(mElev[ebase + elev0.idx].azCount, azimuth);
+    const auto az1 = CalcAzIndex(mElev[ebase + elev1_idx].azCount, azimuth);
+
+    /* Calculate the HRIR indices to blend. */
+    const size_t idx[4]{
+        ir0offset + az0.idx,
+        ir0offset + ((az0.idx+1) % mElev[ebase + elev0.idx].azCount),
+        ir1offset + az1.idx,
+        ir1offset + ((az1.idx+1) % mElev[ebase + elev1_idx].azCount)
+    };
+
+    /* Calculate bilinear blending weights, attenuated according to the
+     * directional panning factor.
+     */
+    const float blend[4]{
+        (1.0f-elev0.blend) * (1.0f-az0.blend) * dirfact,
+        (1.0f-elev0.blend) * (     az0.blend) * dirfact,
+        (     elev0.blend) * (1.0f-az1.blend) * dirfact,
+        (     elev0.blend) * (     az1.blend) * dirfact
+    };
+
+    /* Calculate the blended HRIR delays. */
+    float d{mDelays[idx[0]][0]*blend[0] + mDelays[idx[1]][0]*blend[1] + mDelays[idx[2]][0]*blend[2]
+        + mDelays[idx[3]][0]*blend[3]};
+    delays[0] = fastf2u(d * float{1.0f/HrirDelayFracOne});
+    d = mDelays[idx[0]][1]*blend[0] + mDelays[idx[1]][1]*blend[1] + mDelays[idx[2]][1]*blend[2]
+        + mDelays[idx[3]][1]*blend[3];
+    delays[1] = fastf2u(d * float{1.0f/HrirDelayFracOne});
+
+    /* Calculate the blended HRIR coefficients. */
+    float *coeffout{al::assume_aligned<16>(coeffs[0].data())};
+    coeffout[0] = PassthruCoeff * (1.0f-dirfact);
+    coeffout[1] = PassthruCoeff * (1.0f-dirfact);
+    std::fill_n(coeffout+2, size_t{HrirLength-1}*2, 0.0f);
+    for(size_t c{0};c < 4;c++)
+    {
+        const float *srccoeffs{al::assume_aligned<16>(mCoeffs[idx[c]][0].data())};
+        const float mult{blend[c]};
+        auto blend_coeffs = [mult](const float src, const float coeff) noexcept -> float
+        { return src*mult + coeff; };
+        std::transform(srccoeffs, srccoeffs + HrirLength*2, coeffout, coeffout, blend_coeffs);
+    }
+}
+
+
+std::unique_ptr<DirectHrtfState> DirectHrtfState::Create(size_t num_chans)
+{ return std::unique_ptr<DirectHrtfState>{new(FamCount(num_chans)) DirectHrtfState{num_chans}}; }
+
+void DirectHrtfState::build(const HrtfStore *Hrtf, const uint irSize, const bool perHrirMin,
+    const al::span<const AngularPoint> AmbiPoints, const float (*AmbiMatrix)[MaxAmbiChannels],
+    const float XOverFreq, const al::span<const float,MaxAmbiOrder+1> AmbiOrderHFGain)
+{
+    using double2 = std::array<double,2>;
+    struct ImpulseResponse {
+        const ConstHrirSpan hrir;
+        uint ldelay, rdelay;
+    };
+
+    const double xover_norm{double{XOverFreq} / Hrtf->mSampleRate};
+    mChannels[0].mSplitter.init(static_cast<float>(xover_norm));
+    for(size_t i{0};i < mChannels.size();++i)
+    {
+        const size_t order{AmbiIndex::OrderFromChannel()[i]};
+        mChannels[i].mSplitter = mChannels[0].mSplitter;
+        mChannels[i].mHfScale = AmbiOrderHFGain[order];
+    }
+
+    uint min_delay{HrtfHistoryLength*HrirDelayFracOne}, max_delay{0};
+    al::vector<ImpulseResponse> impres; impres.reserve(AmbiPoints.size());
+    auto calc_res = [Hrtf,&max_delay,&min_delay](const AngularPoint &pt) -> ImpulseResponse
+    {
+        auto &field = Hrtf->mFields[0];
+        const auto elev0 = CalcEvIndex(field.evCount, pt.Elev.value);
+        const size_t elev1_idx{minu(elev0.idx+1, field.evCount-1)};
+        const size_t ir0offset{Hrtf->mElev[elev0.idx].irOffset};
+        const size_t ir1offset{Hrtf->mElev[elev1_idx].irOffset};
+
+        const auto az0 = CalcAzIndex(Hrtf->mElev[elev0.idx].azCount, pt.Azim.value);
+        const auto az1 = CalcAzIndex(Hrtf->mElev[elev1_idx].azCount, pt.Azim.value);
+
+        const size_t idx[4]{
+            ir0offset + az0.idx,
+            ir0offset + ((az0.idx+1) % Hrtf->mElev[elev0.idx].azCount),
+            ir1offset + az1.idx,
+            ir1offset + ((az1.idx+1) % Hrtf->mElev[elev1_idx].azCount)
+        };
+
+        /* The largest blend factor serves as the closest HRIR. */
+        const size_t irOffset{idx[(elev0.blend >= 0.5f)*2 + (az1.blend >= 0.5f)]};
+        ImpulseResponse res{Hrtf->mCoeffs[irOffset],
+            Hrtf->mDelays[irOffset][0], Hrtf->mDelays[irOffset][1]};
+
+        min_delay = minu(min_delay, minu(res.ldelay, res.rdelay));
+        max_delay = maxu(max_delay, maxu(res.ldelay, res.rdelay));
+
+        return res;
+    };
+    std::transform(AmbiPoints.begin(), AmbiPoints.end(), std::back_inserter(impres), calc_res);
+    auto hrir_delay_round = [](const uint d) noexcept -> uint
+    { return (d+HrirDelayFracHalf) >> HrirDelayFracBits; };
+
+    TRACE("Min delay: %.2f, max delay: %.2f, FIR length: %u\n",
+        min_delay/double{HrirDelayFracOne}, max_delay/double{HrirDelayFracOne}, irSize);
+
+    auto tmpres = al::vector<std::array<double2,HrirLength>>(mChannels.size());
+    max_delay = 0;
+    for(size_t c{0u};c < AmbiPoints.size();++c)
+    {
+        const ConstHrirSpan hrir{impres[c].hrir};
+        const uint base_delay{perHrirMin ? minu(impres[c].ldelay, impres[c].rdelay) : min_delay};
+        const uint ldelay{hrir_delay_round(impres[c].ldelay - base_delay)};
+        const uint rdelay{hrir_delay_round(impres[c].rdelay - base_delay)};
+        max_delay = maxu(max_delay, maxu(impres[c].ldelay, impres[c].rdelay) - base_delay);
+
+        for(size_t i{0u};i < mChannels.size();++i)
+        {
+            const double mult{AmbiMatrix[c][i]};
+            const size_t numirs{HrirLength - maxz(ldelay, rdelay)};
+            size_t lidx{ldelay}, ridx{rdelay};
+            for(size_t j{0};j < numirs;++j)
+            {
+                tmpres[i][lidx++][0] += hrir[j][0] * mult;
+                tmpres[i][ridx++][1] += hrir[j][1] * mult;
+            }
+        }
+    }
+    impres.clear();
+
+    for(size_t i{0u};i < mChannels.size();++i)
+    {
+        auto copy_arr = [](const double2 &in) noexcept -> float2
+        { return float2{{static_cast<float>(in[0]), static_cast<float>(in[1])}}; };
+        std::transform(tmpres[i].cbegin(), tmpres[i].cend(), mChannels[i].mCoeffs.begin(),
+            copy_arr);
+    }
+    tmpres.clear();
+
+    const uint max_length{minu(hrir_delay_round(max_delay) + irSize, HrirLength)};
+    TRACE("New max delay: %.2f, FIR length: %u\n", max_delay/double{HrirDelayFracOne},
+        max_length);
+    mIrSize = max_length;
+}
+
+
+namespace {
+
+std::unique_ptr<HrtfStore> CreateHrtfStore(uint rate, uint8_t irSize,
+    const al::span<const HrtfStore::Field> fields,
+    const al::span<const HrtfStore::Elevation> elevs, const HrirArray *coeffs,
+    const ubyte2 *delays, const char *filename)
+{
+    const size_t irCount{size_t{elevs.back().azCount} + elevs.back().irOffset};
+    size_t total{sizeof(HrtfStore)};
+    total  = RoundUp(total, alignof(HrtfStore::Field)); /* Align for field infos */
+    total += sizeof(std::declval<HrtfStore&>().mFields[0])*fields.size();
+    total  = RoundUp(total, alignof(HrtfStore::Elevation)); /* Align for elevation infos */
+    total += sizeof(std::declval<HrtfStore&>().mElev[0])*elevs.size();
+    total  = RoundUp(total, 16); /* Align for coefficients using SIMD */
+    total += sizeof(std::declval<HrtfStore&>().mCoeffs[0])*irCount;
+    total += sizeof(std::declval<HrtfStore&>().mDelays[0])*irCount;
+
+    std::unique_ptr<HrtfStore> Hrtf{};
+    if(void *ptr{al_calloc(16, total)})
+    {
+        Hrtf.reset(al::construct_at(static_cast<HrtfStore*>(ptr)));
+        InitRef(Hrtf->mRef, 1u);
+        Hrtf->mSampleRate = rate;
+        Hrtf->mIrSize = irSize;
+
+        /* Set up pointers to storage following the main HRTF struct. */
+        char *base = reinterpret_cast<char*>(Hrtf.get());
+        size_t offset{sizeof(HrtfStore)};
+
+        offset = RoundUp(offset, alignof(HrtfStore::Field)); /* Align for field infos */
+        auto field_ = reinterpret_cast<HrtfStore::Field*>(base + offset);
+        offset += sizeof(field_[0])*fields.size();
+
+        offset = RoundUp(offset, alignof(HrtfStore::Elevation)); /* Align for elevation infos */
+        auto elev_ = reinterpret_cast<HrtfStore::Elevation*>(base + offset);
+        offset += sizeof(elev_[0])*elevs.size();
+
+        offset = RoundUp(offset, 16); /* Align for coefficients using SIMD */
+        auto coeffs_ = reinterpret_cast<HrirArray*>(base + offset);
+        offset += sizeof(coeffs_[0])*irCount;
+
+        auto delays_ = reinterpret_cast<ubyte2*>(base + offset);
+        offset += sizeof(delays_[0])*irCount;
+
+        if(offset != total)
+            throw std::runtime_error{"HrtfStore allocation size mismatch"};
+
+        /* Copy input data to storage. */
+        std::uninitialized_copy(fields.cbegin(), fields.cend(), field_);
+        std::uninitialized_copy(elevs.cbegin(), elevs.cend(), elev_);
+        std::uninitialized_copy_n(coeffs, irCount, coeffs_);
+        std::uninitialized_copy_n(delays, irCount, delays_);
+
+        /* Finally, assign the storage pointers. */
+        Hrtf->mFields = al::as_span(field_, fields.size());
+        Hrtf->mElev = elev_;
+        Hrtf->mCoeffs = coeffs_;
+        Hrtf->mDelays = delays_;
+    }
+    else
+        ERR("Out of memory allocating storage for %s.\n", filename);
+
+    return Hrtf;
+}
+
+void MirrorLeftHrirs(const al::span<const HrtfStore::Elevation> elevs, HrirArray *coeffs,
+    ubyte2 *delays)
+{
+    for(const auto &elev : elevs)
+    {
+        const ushort evoffset{elev.irOffset};
+        const ushort azcount{elev.azCount};
+        for(size_t j{0};j < azcount;j++)
+        {
+            const size_t lidx{evoffset + j};
+            const size_t ridx{evoffset + ((azcount-j) % azcount)};
+
+            const size_t irSize{coeffs[ridx].size()};
+            for(size_t k{0};k < irSize;k++)
+                coeffs[ridx][k][1] = coeffs[lidx][k][0];
+            delays[ridx][1] = delays[lidx][0];
+        }
+    }
+}
+
+
+template<size_t num_bits, typename T>
+constexpr std::enable_if_t<std::is_signed<T>::value && num_bits < sizeof(T)*8,
+T> fixsign(T value) noexcept
+{
+    constexpr auto signbit = static_cast<T>(1u << (num_bits-1));
+    return static_cast<T>((value^signbit) - signbit);
+}
+
+template<size_t num_bits, typename T>
+constexpr std::enable_if_t<!std::is_signed<T>::value || num_bits == sizeof(T)*8,
+T> fixsign(T value) noexcept
+{ return value; }
+
+template<typename T, size_t num_bits=sizeof(T)*8>
+inline std::enable_if_t<al::endian::native == al::endian::little,
+T> readle(std::istream &data)
+{
+    static_assert((num_bits&7) == 0, "num_bits must be a multiple of 8");
+    static_assert(num_bits <= sizeof(T)*8, "num_bits is too large for the type");
+
+    T ret{};
+    if(!data.read(reinterpret_cast<char*>(&ret), num_bits/8))
+        return static_cast<T>(EOF);
+
+    return fixsign<num_bits>(ret);
+}
+
+template<typename T, size_t num_bits=sizeof(T)*8>
+inline std::enable_if_t<al::endian::native == al::endian::big,
+T> readle(std::istream &data)
+{
+    static_assert((num_bits&7) == 0, "num_bits must be a multiple of 8");
+    static_assert(num_bits <= sizeof(T)*8, "num_bits is too large for the type");
+
+    T ret{};
+    al::byte b[sizeof(T)]{};
+    if(!data.read(reinterpret_cast<char*>(b), num_bits/8))
+        return static_cast<T>(EOF);
+    std::reverse_copy(std::begin(b), std::end(b), reinterpret_cast<al::byte*>(&ret));
+
+    return fixsign<num_bits>(ret);
+}
+
+template<>
+inline uint8_t readle<uint8_t,8>(std::istream &data)
+{ return static_cast<uint8_t>(data.get()); }
+
+
+std::unique_ptr<HrtfStore> LoadHrtf00(std::istream &data, const char *filename)
+{
+    uint rate{readle<uint32_t>(data)};
+    ushort irCount{readle<uint16_t>(data)};
+    ushort irSize{readle<uint16_t>(data)};
+    ubyte evCount{readle<uint8_t>(data)};
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+
+    if(irSize < MinIrLength || irSize > HrirLength)
+    {
+        ERR("Unsupported HRIR size, irSize=%d (%d to %d)\n", irSize, MinIrLength, HrirLength);
+        return nullptr;
+    }
+    if(evCount < MinEvCount || evCount > MaxEvCount)
+    {
+        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
+            evCount, MinEvCount, MaxEvCount);
+        return nullptr;
+    }
+
+    auto elevs = al::vector<HrtfStore::Elevation>(evCount);
+    for(auto &elev : elevs)
+        elev.irOffset = readle<uint16_t>(data);
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+    for(size_t i{1};i < evCount;i++)
+    {
+        if(elevs[i].irOffset <= elevs[i-1].irOffset)
+        {
+            ERR("Invalid evOffset: evOffset[%zu]=%d (last=%d)\n", i, elevs[i].irOffset,
+                elevs[i-1].irOffset);
+            return nullptr;
+        }
+    }
+    if(irCount <= elevs.back().irOffset)
+    {
+        ERR("Invalid evOffset: evOffset[%zu]=%d (irCount=%d)\n",
+            elevs.size()-1, elevs.back().irOffset, irCount);
+        return nullptr;
+    }
+
+    for(size_t i{1};i < evCount;i++)
+    {
+        elevs[i-1].azCount = static_cast<ushort>(elevs[i].irOffset - elevs[i-1].irOffset);
+        if(elevs[i-1].azCount < MinAzCount || elevs[i-1].azCount > MaxAzCount)
+        {
+            ERR("Unsupported azimuth count: azCount[%zd]=%d (%d to %d)\n",
+                i-1, elevs[i-1].azCount, MinAzCount, MaxAzCount);
+            return nullptr;
+        }
+    }
+    elevs.back().azCount = static_cast<ushort>(irCount - elevs.back().irOffset);
+    if(elevs.back().azCount < MinAzCount || elevs.back().azCount > MaxAzCount)
+    {
+        ERR("Unsupported azimuth count: azCount[%zu]=%d (%d to %d)\n",
+            elevs.size()-1, elevs.back().azCount, MinAzCount, MaxAzCount);
+        return nullptr;
+    }
+
+    auto coeffs = al::vector<HrirArray>(irCount, HrirArray{});
+    auto delays = al::vector<ubyte2>(irCount);
+    for(auto &hrir : coeffs)
+    {
+        for(auto &val : al::span<float2>{hrir.data(), irSize})
+            val[0] = readle<int16_t>(data) / 32768.0f;
+    }
+    for(auto &val : delays)
+        val[0] = readle<uint8_t>(data);
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+    for(size_t i{0};i < irCount;i++)
+    {
+        if(delays[i][0] > MaxHrirDelay)
+        {
+            ERR("Invalid delays[%zd]: %d (%d)\n", i, delays[i][0], MaxHrirDelay);
+            return nullptr;
+        }
+        delays[i][0] <<= HrirDelayFracBits;
+    }
+
+    /* Mirror the left ear responses to the right ear. */
+    MirrorLeftHrirs({elevs.data(), elevs.size()}, coeffs.data(), delays.data());
+
+    const HrtfStore::Field field[1]{{0.0f, evCount}};
+    return CreateHrtfStore(rate, static_cast<uint8_t>(irSize), field, {elevs.data(), elevs.size()},
+        coeffs.data(), delays.data(), filename);
+}
+
+std::unique_ptr<HrtfStore> LoadHrtf01(std::istream &data, const char *filename)
+{
+    uint rate{readle<uint32_t>(data)};
+    uint8_t irSize{readle<uint8_t>(data)};
+    ubyte evCount{readle<uint8_t>(data)};
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+
+    if(irSize < MinIrLength || irSize > HrirLength)
+    {
+        ERR("Unsupported HRIR size, irSize=%d (%d to %d)\n", irSize, MinIrLength, HrirLength);
+        return nullptr;
+    }
+    if(evCount < MinEvCount || evCount > MaxEvCount)
+    {
+        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
+            evCount, MinEvCount, MaxEvCount);
+        return nullptr;
+    }
+
+    auto elevs = al::vector<HrtfStore::Elevation>(evCount);
+    for(auto &elev : elevs)
+        elev.azCount = readle<uint8_t>(data);
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+    for(size_t i{0};i < evCount;++i)
+    {
+        if(elevs[i].azCount < MinAzCount || elevs[i].azCount > MaxAzCount)
+        {
+            ERR("Unsupported azimuth count: azCount[%zd]=%d (%d to %d)\n", i, elevs[i].azCount,
+                MinAzCount, MaxAzCount);
+            return nullptr;
+        }
+    }
+
+    elevs[0].irOffset = 0;
+    for(size_t i{1};i < evCount;i++)
+        elevs[i].irOffset = static_cast<ushort>(elevs[i-1].irOffset + elevs[i-1].azCount);
+    const ushort irCount{static_cast<ushort>(elevs.back().irOffset + elevs.back().azCount)};
+
+    auto coeffs = al::vector<HrirArray>(irCount, HrirArray{});
+    auto delays = al::vector<ubyte2>(irCount);
+    for(auto &hrir : coeffs)
+    {
+        for(auto &val : al::span<float2>{hrir.data(), irSize})
+            val[0] = readle<int16_t>(data) / 32768.0f;
+    }
+    for(auto &val : delays)
+        val[0] = readle<uint8_t>(data);
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+    for(size_t i{0};i < irCount;i++)
+    {
+        if(delays[i][0] > MaxHrirDelay)
+        {
+            ERR("Invalid delays[%zd]: %d (%d)\n", i, delays[i][0], MaxHrirDelay);
+            return nullptr;
+        }
+        delays[i][0] <<= HrirDelayFracBits;
+    }
+
+    /* Mirror the left ear responses to the right ear. */
+    MirrorLeftHrirs({elevs.data(), elevs.size()}, coeffs.data(), delays.data());
+
+    const HrtfStore::Field field[1]{{0.0f, evCount}};
+    return CreateHrtfStore(rate, irSize, field, {elevs.data(), elevs.size()}, coeffs.data(),
+        delays.data(), filename);
+}
+
+std::unique_ptr<HrtfStore> LoadHrtf02(std::istream &data, const char *filename)
+{
+    constexpr ubyte SampleType_S16{0};
+    constexpr ubyte SampleType_S24{1};
+    constexpr ubyte ChanType_LeftOnly{0};
+    constexpr ubyte ChanType_LeftRight{1};
+
+    uint rate{readle<uint32_t>(data)};
+    ubyte sampleType{readle<uint8_t>(data)};
+    ubyte channelType{readle<uint8_t>(data)};
+    uint8_t irSize{readle<uint8_t>(data)};
+    ubyte fdCount{readle<uint8_t>(data)};
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+
+    if(sampleType > SampleType_S24)
+    {
+        ERR("Unsupported sample type: %d\n", sampleType);
+        return nullptr;
+    }
+    if(channelType > ChanType_LeftRight)
+    {
+        ERR("Unsupported channel type: %d\n", channelType);
+        return nullptr;
+    }
+
+    if(irSize < MinIrLength || irSize > HrirLength)
+    {
+        ERR("Unsupported HRIR size, irSize=%d (%d to %d)\n", irSize, MinIrLength, HrirLength);
+        return nullptr;
+    }
+    if(fdCount < 1 || fdCount > MaxFdCount)
+    {
+        ERR("Unsupported number of field-depths: fdCount=%d (%d to %d)\n", fdCount, MinFdCount,
+            MaxFdCount);
+        return nullptr;
+    }
+
+    auto fields = al::vector<HrtfStore::Field>(fdCount);
+    auto elevs = al::vector<HrtfStore::Elevation>{};
+    for(size_t f{0};f < fdCount;f++)
+    {
+        const ushort distance{readle<uint16_t>(data)};
+        const ubyte evCount{readle<uint8_t>(data)};
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        if(distance < MinFdDistance || distance > MaxFdDistance)
+        {
+            ERR("Unsupported field distance[%zu]=%d (%d to %d millimeters)\n", f, distance,
+                MinFdDistance, MaxFdDistance);
+            return nullptr;
+        }
+        if(evCount < MinEvCount || evCount > MaxEvCount)
+        {
+            ERR("Unsupported elevation count: evCount[%zu]=%d (%d to %d)\n", f, evCount,
+                MinEvCount, MaxEvCount);
+            return nullptr;
+        }
+
+        fields[f].distance = distance / 1000.0f;
+        fields[f].evCount = evCount;
+        if(f > 0 && fields[f].distance <= fields[f-1].distance)
+        {
+            ERR("Field distance[%zu] is not after previous (%f > %f)\n", f, fields[f].distance,
+                fields[f-1].distance);
+            return nullptr;
+        }
+
+        const size_t ebase{elevs.size()};
+        elevs.resize(ebase + evCount);
+        for(auto &elev : al::span<HrtfStore::Elevation>(elevs.data()+ebase, evCount))
+            elev.azCount = readle<uint8_t>(data);
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        for(size_t e{0};e < evCount;e++)
+        {
+            if(elevs[ebase+e].azCount < MinAzCount || elevs[ebase+e].azCount > MaxAzCount)
+            {
+                ERR("Unsupported azimuth count: azCount[%zu][%zu]=%d (%d to %d)\n", f, e,
+                    elevs[ebase+e].azCount, MinAzCount, MaxAzCount);
+                return nullptr;
+            }
+        }
+    }
+
+    elevs[0].irOffset = 0;
+    std::partial_sum(elevs.cbegin(), elevs.cend(), elevs.begin(),
+        [](const HrtfStore::Elevation &last, const HrtfStore::Elevation &cur)
+            -> HrtfStore::Elevation
+        {
+            return HrtfStore::Elevation{cur.azCount,
+                static_cast<ushort>(last.azCount + last.irOffset)};
+        });
+    const auto irTotal = static_cast<ushort>(elevs.back().azCount + elevs.back().irOffset);
+
+    auto coeffs = al::vector<HrirArray>(irTotal, HrirArray{});
+    auto delays = al::vector<ubyte2>(irTotal);
+    if(channelType == ChanType_LeftOnly)
+    {
+        if(sampleType == SampleType_S16)
+        {
+            for(auto &hrir : coeffs)
+            {
+                for(auto &val : al::span<float2>{hrir.data(), irSize})
+                    val[0] = readle<int16_t>(data) / 32768.0f;
+            }
+        }
+        else if(sampleType == SampleType_S24)
+        {
+            for(auto &hrir : coeffs)
+            {
+                for(auto &val : al::span<float2>{hrir.data(), irSize})
+                    val[0] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+            }
+        }
+        for(auto &val : delays)
+            val[0] = readle<uint8_t>(data);
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+        for(size_t i{0};i < irTotal;++i)
+        {
+            if(delays[i][0] > MaxHrirDelay)
+            {
+                ERR("Invalid delays[%zu][0]: %d (%d)\n", i, delays[i][0], MaxHrirDelay);
+                return nullptr;
+            }
+            delays[i][0] <<= HrirDelayFracBits;
+        }
+
+        /* Mirror the left ear responses to the right ear. */
+        MirrorLeftHrirs({elevs.data(), elevs.size()}, coeffs.data(), delays.data());
+    }
+    else if(channelType == ChanType_LeftRight)
+    {
+        if(sampleType == SampleType_S16)
+        {
+            for(auto &hrir : coeffs)
+            {
+                for(auto &val : al::span<float2>{hrir.data(), irSize})
+                {
+                    val[0] = readle<int16_t>(data) / 32768.0f;
+                    val[1] = readle<int16_t>(data) / 32768.0f;
+                }
+            }
+        }
+        else if(sampleType == SampleType_S24)
+        {
+            for(auto &hrir : coeffs)
+            {
+                for(auto &val : al::span<float2>{hrir.data(), irSize})
+                {
+                    val[0] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+                    val[1] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+                }
+            }
+        }
+        for(auto &val : delays)
+        {
+            val[0] = readle<uint8_t>(data);
+            val[1] = readle<uint8_t>(data);
+        }
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        for(size_t i{0};i < irTotal;++i)
+        {
+            if(delays[i][0] > MaxHrirDelay)
+            {
+                ERR("Invalid delays[%zu][0]: %d (%d)\n", i, delays[i][0], MaxHrirDelay);
+                return nullptr;
+            }
+            if(delays[i][1] > MaxHrirDelay)
+            {
+                ERR("Invalid delays[%zu][1]: %d (%d)\n", i, delays[i][1], MaxHrirDelay);
+                return nullptr;
+            }
+            delays[i][0] <<= HrirDelayFracBits;
+            delays[i][1] <<= HrirDelayFracBits;
+        }
+    }
+
+    if(fdCount > 1)
+    {
+        auto fields_ = al::vector<HrtfStore::Field>(fields.size());
+        auto elevs_ = al::vector<HrtfStore::Elevation>(elevs.size());
+        auto coeffs_ = al::vector<HrirArray>(coeffs.size());
+        auto delays_ = al::vector<ubyte2>(delays.size());
+
+        /* Simple reverse for the per-field elements. */
+        std::reverse_copy(fields.cbegin(), fields.cend(), fields_.begin());
+
+        /* Each field has a group of elevations, which each have an azimuth
+         * count. Reverse the order of the groups, keeping the relative order
+         * of per-group azimuth counts.
+         */
+        auto elevs__end = elevs_.end();
+        auto copy_azs = [&elevs,&elevs__end](const ptrdiff_t ebase, const HrtfStore::Field &field)
+            -> ptrdiff_t
+        {
+            auto elevs_src = elevs.begin()+ebase;
+            elevs__end = std::copy_backward(elevs_src, elevs_src+field.evCount, elevs__end);
+            return ebase + field.evCount;
+        };
+        (void)std::accumulate(fields.cbegin(), fields.cend(), ptrdiff_t{0}, copy_azs);
+        assert(elevs_.begin() == elevs__end);
+
+        /* Reestablish the IR offset for each elevation index, given the new
+         * ordering of elevations.
+         */
+        elevs_[0].irOffset = 0;
+        std::partial_sum(elevs_.cbegin(), elevs_.cend(), elevs_.begin(),
+            [](const HrtfStore::Elevation &last, const HrtfStore::Elevation &cur)
+                -> HrtfStore::Elevation
+            {
+                return HrtfStore::Elevation{cur.azCount,
+                    static_cast<ushort>(last.azCount + last.irOffset)};
+            });
+
+        /* Reverse the order of each field's group of IRs. */
+        auto coeffs_end = coeffs_.end();
+        auto delays_end = delays_.end();
+        auto copy_irs = [&elevs,&coeffs,&delays,&coeffs_end,&delays_end](
+            const ptrdiff_t ebase, const HrtfStore::Field &field) -> ptrdiff_t
+        {
+            auto accum_az = [](int count, const HrtfStore::Elevation &elev) noexcept -> int
+            { return count + elev.azCount; };
+            const auto elevs_mid = elevs.cbegin() + ebase;
+            const auto elevs_end = elevs_mid + field.evCount;
+            const int abase{std::accumulate(elevs.cbegin(), elevs_mid, 0, accum_az)};
+            const int num_azs{std::accumulate(elevs_mid, elevs_end, 0, accum_az)};
+
+            coeffs_end = std::copy_backward(coeffs.cbegin() + abase,
+                coeffs.cbegin() + (abase+num_azs), coeffs_end);
+            delays_end = std::copy_backward(delays.cbegin() + abase,
+                delays.cbegin() + (abase+num_azs), delays_end);
+
+            return ebase + field.evCount;
+        };
+        (void)std::accumulate(fields.cbegin(), fields.cend(), ptrdiff_t{0}, copy_irs);
+        assert(coeffs_.begin() == coeffs_end);
+        assert(delays_.begin() == delays_end);
+
+        fields = std::move(fields_);
+        elevs = std::move(elevs_);
+        coeffs = std::move(coeffs_);
+        delays = std::move(delays_);
+    }
+
+    return CreateHrtfStore(rate, irSize, {fields.data(), fields.size()},
+        {elevs.data(), elevs.size()}, coeffs.data(), delays.data(), filename);
+}
+
+std::unique_ptr<HrtfStore> LoadHrtf03(std::istream &data, const char *filename)
+{
+    constexpr ubyte ChanType_LeftOnly{0};
+    constexpr ubyte ChanType_LeftRight{1};
+
+    uint rate{readle<uint32_t>(data)};
+    ubyte channelType{readle<uint8_t>(data)};
+    uint8_t irSize{readle<uint8_t>(data)};
+    ubyte fdCount{readle<uint8_t>(data)};
+    if(!data || data.eof())
+    {
+        ERR("Failed reading %s\n", filename);
+        return nullptr;
+    }
+
+    if(channelType > ChanType_LeftRight)
+    {
+        ERR("Unsupported channel type: %d\n", channelType);
+        return nullptr;
+    }
+
+    if(irSize < MinIrLength || irSize > HrirLength)
+    {
+        ERR("Unsupported HRIR size, irSize=%d (%d to %d)\n", irSize, MinIrLength, HrirLength);
+        return nullptr;
+    }
+    if(fdCount < 1 || fdCount > MaxFdCount)
+    {
+        ERR("Unsupported number of field-depths: fdCount=%d (%d to %d)\n", fdCount, MinFdCount,
+            MaxFdCount);
+        return nullptr;
+    }
+
+    auto fields = al::vector<HrtfStore::Field>(fdCount);
+    auto elevs = al::vector<HrtfStore::Elevation>{};
+    for(size_t f{0};f < fdCount;f++)
+    {
+        const ushort distance{readle<uint16_t>(data)};
+        const ubyte evCount{readle<uint8_t>(data)};
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        if(distance < MinFdDistance || distance > MaxFdDistance)
+        {
+            ERR("Unsupported field distance[%zu]=%d (%d to %d millimeters)\n", f, distance,
+                MinFdDistance, MaxFdDistance);
+            return nullptr;
+        }
+        if(evCount < MinEvCount || evCount > MaxEvCount)
+        {
+            ERR("Unsupported elevation count: evCount[%zu]=%d (%d to %d)\n", f, evCount,
+                MinEvCount, MaxEvCount);
+            return nullptr;
+        }
+
+        fields[f].distance = distance / 1000.0f;
+        fields[f].evCount = evCount;
+        if(f > 0 && fields[f].distance > fields[f-1].distance)
+        {
+            ERR("Field distance[%zu] is not before previous (%f <= %f)\n", f, fields[f].distance,
+                fields[f-1].distance);
+            return nullptr;
+        }
+
+        const size_t ebase{elevs.size()};
+        elevs.resize(ebase + evCount);
+        for(auto &elev : al::span<HrtfStore::Elevation>(elevs.data()+ebase, evCount))
+            elev.azCount = readle<uint8_t>(data);
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        for(size_t e{0};e < evCount;e++)
+        {
+            if(elevs[ebase+e].azCount < MinAzCount || elevs[ebase+e].azCount > MaxAzCount)
+            {
+                ERR("Unsupported azimuth count: azCount[%zu][%zu]=%d (%d to %d)\n", f, e,
+                    elevs[ebase+e].azCount, MinAzCount, MaxAzCount);
+                return nullptr;
+            }
+        }
+    }
+
+    elevs[0].irOffset = 0;
+    std::partial_sum(elevs.cbegin(), elevs.cend(), elevs.begin(),
+        [](const HrtfStore::Elevation &last, const HrtfStore::Elevation &cur)
+            -> HrtfStore::Elevation
+        {
+            return HrtfStore::Elevation{cur.azCount,
+                static_cast<ushort>(last.azCount + last.irOffset)};
+        });
+    const auto irTotal = static_cast<ushort>(elevs.back().azCount + elevs.back().irOffset);
+
+    auto coeffs = al::vector<HrirArray>(irTotal, HrirArray{});
+    auto delays = al::vector<ubyte2>(irTotal);
+    if(channelType == ChanType_LeftOnly)
+    {
+        for(auto &hrir : coeffs)
+        {
+            for(auto &val : al::span<float2>{hrir.data(), irSize})
+                val[0] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+        }
+        for(auto &val : delays)
+            val[0] = readle<uint8_t>(data);
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+        for(size_t i{0};i < irTotal;++i)
+        {
+            if(delays[i][0] > MaxHrirDelay<<HrirDelayFracBits)
+            {
+                ERR("Invalid delays[%zu][0]: %f (%d)\n", i,
+                    delays[i][0] / float{HrirDelayFracOne}, MaxHrirDelay);
+                return nullptr;
+            }
+        }
+
+        /* Mirror the left ear responses to the right ear. */
+        MirrorLeftHrirs({elevs.data(), elevs.size()}, coeffs.data(), delays.data());
+    }
+    else if(channelType == ChanType_LeftRight)
+    {
+        for(auto &hrir : coeffs)
+        {
+            for(auto &val : al::span<float2>{hrir.data(), irSize})
+            {
+                val[0] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+                val[1] = static_cast<float>(readle<int,24>(data)) / 8388608.0f;
+            }
+        }
+        for(auto &val : delays)
+        {
+            val[0] = readle<uint8_t>(data);
+            val[1] = readle<uint8_t>(data);
+        }
+        if(!data || data.eof())
+        {
+            ERR("Failed reading %s\n", filename);
+            return nullptr;
+        }
+
+        for(size_t i{0};i < irTotal;++i)
+        {
+            if(delays[i][0] > MaxHrirDelay<<HrirDelayFracBits)
+            {
+                ERR("Invalid delays[%zu][0]: %f (%d)\n", i,
+                    delays[i][0] / float{HrirDelayFracOne}, MaxHrirDelay);
+                return nullptr;
+            }
+            if(delays[i][1] > MaxHrirDelay<<HrirDelayFracBits)
+            {
+                ERR("Invalid delays[%zu][1]: %f (%d)\n", i,
+                    delays[i][1] / float{HrirDelayFracOne}, MaxHrirDelay);
+                return nullptr;
+            }
+        }
+    }
+
+    return CreateHrtfStore(rate, irSize, {fields.data(), fields.size()},
+        {elevs.data(), elevs.size()}, coeffs.data(), delays.data(), filename);
+}
+
+
+bool checkName(const std::string &name)
+{
+    auto match_name = [&name](const HrtfEntry &entry) -> bool { return name == entry.mDispName; };
+    auto &enum_names = EnumeratedHrtfs;
+    return std::find_if(enum_names.cbegin(), enum_names.cend(), match_name) != enum_names.cend();
+}
+
+void AddFileEntry(const std::string &filename)
+{
+    /* Check if this file has already been enumerated. */
+    auto enum_iter = std::find_if(EnumeratedHrtfs.cbegin(), EnumeratedHrtfs.cend(),
+        [&filename](const HrtfEntry &entry) -> bool
+        { return entry.mFilename == filename; });
+    if(enum_iter != EnumeratedHrtfs.cend())
+    {
+        TRACE("Skipping duplicate file entry %s\n", filename.c_str());
+        return;
+    }
+
+    /* TODO: Get a human-readable name from the HRTF data (possibly coming in a
+     * format update). */
+    size_t namepos{filename.find_last_of('/')+1};
+    if(!namepos) namepos = filename.find_last_of('\\')+1;
+
+    size_t extpos{filename.find_last_of('.')};
+    if(extpos <= namepos) extpos = std::string::npos;
+
+    const std::string basename{(extpos == std::string::npos) ?
+        filename.substr(namepos) : filename.substr(namepos, extpos-namepos)};
+    std::string newname{basename};
+    int count{1};
+    while(checkName(newname))
+    {
+        newname = basename;
+        newname += " #";
+        newname += std::to_string(++count);
+    }
+    EnumeratedHrtfs.emplace_back(HrtfEntry{newname, filename});
+    const HrtfEntry &entry = EnumeratedHrtfs.back();
+
+    TRACE("Adding file entry \"%s\"\n", entry.mFilename.c_str());
+}
+
+/* Unfortunate that we have to duplicate AddFileEntry to take a memory buffer
+ * for input instead of opening the given filename.
+ */
+void AddBuiltInEntry(const std::string &dispname, uint residx)
+{
+    const std::string filename{'!'+std::to_string(residx)+'_'+dispname};
+
+    auto enum_iter = std::find_if(EnumeratedHrtfs.cbegin(), EnumeratedHrtfs.cend(),
+        [&filename](const HrtfEntry &entry) -> bool
+        { return entry.mFilename == filename; });
+    if(enum_iter != EnumeratedHrtfs.cend())
+    {
+        TRACE("Skipping duplicate file entry %s\n", filename.c_str());
+        return;
+    }
+
+    /* TODO: Get a human-readable name from the HRTF data (possibly coming in a
+     * format update). */
+
+    std::string newname{dispname};
+    int count{1};
+    while(checkName(newname))
+    {
+        newname = dispname;
+        newname += " #";
+        newname += std::to_string(++count);
+    }
+    EnumeratedHrtfs.emplace_back(HrtfEntry{newname, filename});
+    const HrtfEntry &entry = EnumeratedHrtfs.back();
+
+    TRACE("Adding built-in entry \"%s\"\n", entry.mFilename.c_str());
+}
+
+
+#define IDR_DEFAULT_HRTF_MHR 1
+
+#ifndef ALSOFT_EMBED_HRTF_DATA
+
+al::span<const char> GetResource(int /*name*/)
+{ return {}; }
+
+#else
+
+constexpr unsigned char hrtf_default[]{
+#include "default_hrtf.txt"
+};
+
+al::span<const char> GetResource(int name)
+{
+    if(name == IDR_DEFAULT_HRTF_MHR)
+        return {reinterpret_cast<const char*>(hrtf_default), sizeof(hrtf_default)};
+    return {};
+}
+#endif
+
+} // namespace
+
+
+al::vector<std::string> EnumerateHrtf(al::optional<std::string> pathopt)
+{
+    std::lock_guard<std::mutex> _{EnumeratedHrtfLock};
+    EnumeratedHrtfs.clear();
+
+    bool usedefaults{true};
+    if(pathopt)
+    {
+        const char *pathlist{pathopt->c_str()};
+        while(pathlist && *pathlist)
+        {
+            const char *next, *end;
+
+            while(isspace(*pathlist) || *pathlist == ',')
+                pathlist++;
+            if(*pathlist == '\0')
+                continue;
+
+            next = strchr(pathlist, ',');
+            if(next)
+                end = next++;
+            else
+            {
+                end = pathlist + strlen(pathlist);
+                usedefaults = false;
+            }
+
+            while(end != pathlist && isspace(*(end-1)))
+                --end;
+            if(end != pathlist)
+            {
+                const std::string pname{pathlist, end};
+                for(const auto &fname : SearchDataFiles(".mhr", pname.c_str()))
+                    AddFileEntry(fname);
+            }
+
+            pathlist = next;
+        }
+    }
+
+    if(usedefaults)
+    {
+        for(const auto &fname : SearchDataFiles(".mhr", "openal/hrtf"))
+            AddFileEntry(fname);
+
+        if(!GetResource(IDR_DEFAULT_HRTF_MHR).empty())
+            AddBuiltInEntry("Built-In HRTF", IDR_DEFAULT_HRTF_MHR);
+    }
+
+    al::vector<std::string> list;
+    list.reserve(EnumeratedHrtfs.size());
+    for(auto &entry : EnumeratedHrtfs)
+        list.emplace_back(entry.mDispName);
+
+    return list;
+}
+
+HrtfStorePtr GetLoadedHrtf(const std::string &name, const uint devrate)
+{
+    std::lock_guard<std::mutex> _{EnumeratedHrtfLock};
+    auto entry_iter = std::find_if(EnumeratedHrtfs.cbegin(), EnumeratedHrtfs.cend(),
+        [&name](const HrtfEntry &entry) -> bool { return entry.mDispName == name; });
+    if(entry_iter == EnumeratedHrtfs.cend())
+        return nullptr;
+    const std::string &fname = entry_iter->mFilename;
+
+    std::lock_guard<std::mutex> __{LoadedHrtfLock};
+    auto hrtf_lt_fname = [](LoadedHrtf &hrtf, const std::string &filename) -> bool
+    { return hrtf.mFilename < filename; };
+    auto handle = std::lower_bound(LoadedHrtfs.begin(), LoadedHrtfs.end(), fname, hrtf_lt_fname);
+    while(handle != LoadedHrtfs.end() && handle->mFilename == fname)
+    {
+        HrtfStore *hrtf{handle->mEntry.get()};
+        if(hrtf && hrtf->mSampleRate == devrate)
+        {
+            hrtf->add_ref();
+            return HrtfStorePtr{hrtf};
+        }
+        ++handle;
+    }
+
+    std::unique_ptr<std::istream> stream;
+    int residx{};
+    char ch{};
+    if(sscanf(fname.c_str(), "!%d%c", &residx, &ch) == 2 && ch == '_')
+    {
+        TRACE("Loading %s...\n", fname.c_str());
+        al::span<const char> res{GetResource(residx)};
+        if(res.empty())
+        {
+            ERR("Could not get resource %u, %s\n", residx, name.c_str());
+            return nullptr;
+        }
+        stream = std::make_unique<idstream>(res.begin(), res.end());
+    }
+    else
+    {
+        TRACE("Loading %s...\n", fname.c_str());
+        auto fstr = std::make_unique<al::ifstream>(fname.c_str(), std::ios::binary);
+        if(!fstr->is_open())
+        {
+            ERR("Could not open %s\n", fname.c_str());
+            return nullptr;
+        }
+        stream = std::move(fstr);
+    }
+
+    std::unique_ptr<HrtfStore> hrtf;
+    char magic[sizeof(magicMarker03)];
+    stream->read(magic, sizeof(magic));
+    if(stream->gcount() < static_cast<std::streamsize>(sizeof(magicMarker03)))
+        ERR("%s data is too short (%zu bytes)\n", name.c_str(), stream->gcount());
+    else if(memcmp(magic, magicMarker03, sizeof(magicMarker03)) == 0)
+    {
+        TRACE("Detected data set format v3\n");
+        hrtf = LoadHrtf03(*stream, name.c_str());
+    }
+    else if(memcmp(magic, magicMarker02, sizeof(magicMarker02)) == 0)
+    {
+        TRACE("Detected data set format v2\n");
+        hrtf = LoadHrtf02(*stream, name.c_str());
+    }
+    else if(memcmp(magic, magicMarker01, sizeof(magicMarker01)) == 0)
+    {
+        TRACE("Detected data set format v1\n");
+        hrtf = LoadHrtf01(*stream, name.c_str());
+    }
+    else if(memcmp(magic, magicMarker00, sizeof(magicMarker00)) == 0)
+    {
+        TRACE("Detected data set format v0\n");
+        hrtf = LoadHrtf00(*stream, name.c_str());
+    }
+    else
+        ERR("Invalid header in %s: \"%.8s\"\n", name.c_str(), magic);
+    stream.reset();
+
+    if(!hrtf)
+    {
+        ERR("Failed to load %s\n", name.c_str());
+        return nullptr;
+    }
+
+    if(hrtf->mSampleRate != devrate)
+    {
+        TRACE("Resampling HRTF %s (%uhz -> %uhz)\n", name.c_str(), hrtf->mSampleRate, devrate);
+
+        /* Calculate the last elevation's index and get the total IR count. */
+        const size_t lastEv{std::accumulate(hrtf->mFields.begin(), hrtf->mFields.end(), size_t{0},
+            [](const size_t curval, const HrtfStore::Field &field) noexcept -> size_t
+            { return curval + field.evCount; }
+        ) - 1};
+        const size_t irCount{size_t{hrtf->mElev[lastEv].irOffset} + hrtf->mElev[lastEv].azCount};
+
+        /* Resample all the IRs. */
+        std::array<std::array<double,HrirLength>,2> inout;
+        PPhaseResampler rs;
+        rs.init(hrtf->mSampleRate, devrate);
+        for(size_t i{0};i < irCount;++i)
+        {
+            HrirArray &coeffs = const_cast<HrirArray&>(hrtf->mCoeffs[i]);
+            for(size_t j{0};j < 2;++j)
+            {
+                std::transform(coeffs.cbegin(), coeffs.cend(), inout[0].begin(),
+                    [j](const float2 &in) noexcept -> double { return in[j]; });
+                rs.process(HrirLength, inout[0].data(), HrirLength, inout[1].data());
+                for(size_t k{0};k < HrirLength;++k)
+                    coeffs[k][j] = static_cast<float>(inout[1][k]);
+            }
+        }
+        rs = {};
+
+        /* Scale the delays for the new sample rate. */
+        float max_delay{0.0f};
+        auto new_delays = al::vector<float2>(irCount);
+        const float rate_scale{static_cast<float>(devrate)/static_cast<float>(hrtf->mSampleRate)};
+        for(size_t i{0};i < irCount;++i)
+        {
+            for(size_t j{0};j < 2;++j)
+            {
+                const float new_delay{std::round(hrtf->mDelays[i][j] * rate_scale) /
+                    float{HrirDelayFracOne}};
+                max_delay = maxf(max_delay, new_delay);
+                new_delays[i][j] = new_delay;
+            }
+        }
+
+        /* If the new delays exceed the max, scale it down to fit (essentially
+         * shrinking the head radius; not ideal but better than a per-delay
+         * clamp).
+         */
+        float delay_scale{HrirDelayFracOne};
+        if(max_delay > MaxHrirDelay)
+        {
+            WARN("Resampled delay exceeds max (%.2f > %d)\n", max_delay, MaxHrirDelay);
+            delay_scale *= float{MaxHrirDelay} / max_delay;
+        }
+
+        for(size_t i{0};i < irCount;++i)
+        {
+            ubyte2 &delays = const_cast<ubyte2&>(hrtf->mDelays[i]);
+            for(size_t j{0};j < 2;++j)
+                delays[j] = static_cast<ubyte>(float2int(new_delays[i][j]*delay_scale + 0.5f));
+        }
+
+        /* Scale the IR size for the new sample rate and update the stored
+         * sample rate.
+         */
+        const float newIrSize{std::round(static_cast<float>(hrtf->mIrSize) * rate_scale)};
+        hrtf->mIrSize = static_cast<uint8_t>(minf(HrirLength, newIrSize));
+        hrtf->mSampleRate = devrate;
+    }
+
+    TRACE("Loaded HRTF %s for sample rate %uhz, %u-sample filter\n", name.c_str(),
+        hrtf->mSampleRate, hrtf->mIrSize);
+    handle = LoadedHrtfs.emplace(handle, fname, std::move(hrtf));
+
+    return HrtfStorePtr{handle->mEntry.get()};
+}
+
+
+void HrtfStore::add_ref()
+{
+    auto ref = IncrementRef(mRef);
+    TRACE("HrtfStore %p increasing refcount to %u\n", decltype(std::declval<void*>()){this}, ref);
+}
+
+void HrtfStore::dec_ref()
+{
+    auto ref = DecrementRef(mRef);
+    TRACE("HrtfStore %p decreasing refcount to %u\n", decltype(std::declval<void*>()){this}, ref);
+    if(ref == 0)
+    {
+        std::lock_guard<std::mutex> _{LoadedHrtfLock};
+
+        /* Go through and remove all unused HRTFs. */
+        auto remove_unused = [](LoadedHrtf &hrtf) -> bool
+        {
+            HrtfStore *entry{hrtf.mEntry.get()};
+            if(entry && ReadRef(entry->mRef) == 0)
+            {
+                TRACE("Unloading unused HRTF %s\n", hrtf.mFilename.data());
+                hrtf.mEntry = nullptr;
+                return true;
+            }
+            return false;
+        };
+        auto iter = std::remove_if(LoadedHrtfs.begin(), LoadedHrtfs.end(), remove_unused);
+        LoadedHrtfs.erase(iter, LoadedHrtfs.end());
+    }
+}
diff --git a/core/hrtf.h b/core/hrtf.h
new file mode 100644
index 00000000..eb18682a
--- /dev/null
+++ b/core/hrtf.h
@@ -0,0 +1,89 @@
+#ifndef CORE_HRTF_H
+#define CORE_HRTF_H
+
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <string>
+
+#include "almalloc.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "atomic.h"
+#include "ambidefs.h"
+#include "bufferline.h"
+#include "mixer/hrtfdefs.h"
+#include "intrusive_ptr.h"
+#include "vector.h"
+
+
+struct HrtfStore {
+    RefCount mRef;
+
+    uint mSampleRate : 24;
+    uint mIrSize : 8;
+
+    struct Field {
+        float distance;
+        ubyte evCount;
+    };
+    /* NOTE: Fields are stored *backwards*. field[0] is the farthest field, and
+     * field[fdCount-1] is the nearest.
+     */
+    al::span<const Field> mFields;
+
+    struct Elevation {
+        ushort azCount;
+        ushort irOffset;
+    };
+    Elevation *mElev;
+    const HrirArray *mCoeffs;
+    const ubyte2 *mDelays;
+
+    void getCoeffs(float elevation, float azimuth, float distance, float spread, HrirArray &coeffs,
+        const al::span<uint,2> delays);
+
+    void add_ref();
+    void dec_ref();
+
+    DEF_PLACE_NEWDEL()
+};
+using HrtfStorePtr = al::intrusive_ptr<HrtfStore>;
+
+
+struct EvRadians { float value; };
+struct AzRadians { float value; };
+struct AngularPoint {
+    EvRadians Elev;
+    AzRadians Azim;
+};
+
+
+struct DirectHrtfState {
+    std::array<float,BufferLineSize> mTemp;
+
+    /* HRTF filter state for dry buffer content */
+    uint mIrSize{0};
+    al::FlexArray<HrtfChannelState> mChannels;
+
+    DirectHrtfState(size_t numchans) : mChannels{numchans} { }
+    /**
+     * Produces HRTF filter coefficients for decoding B-Format, given a set of
+     * virtual speaker positions, a matching decoding matrix, and per-order
+     * high-frequency gains for the decoder. The calculated impulse responses
+     * are ordered and scaled according to the matrix input.
+     */
+    void build(const HrtfStore *Hrtf, const uint irSize, const bool perHrirMin,
+        const al::span<const AngularPoint> AmbiPoints, const float (*AmbiMatrix)[MaxAmbiChannels],
+        const float XOverFreq, const al::span<const float,MaxAmbiOrder+1> AmbiOrderHFGain);
+
+    static std::unique_ptr<DirectHrtfState> Create(size_t num_chans);
+
+    DEF_FAM_NEWDEL(DirectHrtfState, mChannels)
+};
+
+
+al::vector<std::string> EnumerateHrtf(al::optional<std::string> pathopt);
+HrtfStorePtr GetLoadedHrtf(const std::string &name, const uint devrate);
+
+#endif /* CORE_HRTF_H */
diff --git a/core/logging.cpp b/core/logging.cpp
new file mode 100644
index 00000000..34a95e5a
--- /dev/null
+++ b/core/logging.cpp
@@ -0,0 +1,89 @@
+
+#include "config.h"
+
+#include "logging.h"
+
+#include <cstdarg>
+#include <cstdio>
+#include <string>
+
+#include "alspan.h"
+#include "strutils.h"
+#include "vector.h"
+
+
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+void al_print(LogLevel level, FILE *logfile, const char *fmt, ...)
+{
+    /* Kind of ugly since string literals are const char arrays with a size
+     * that includes the null terminator, which we want to exclude from the
+     * span.
+     */
+    auto prefix = al::as_span("[ALSOFT] (--) ").first<14>();
+    switch(level)
+    {
+    case LogLevel::Disable: break;
+    case LogLevel::Error: prefix = al::as_span("[ALSOFT] (EE) ").first<14>(); break;
+    case LogLevel::Warning: prefix = al::as_span("[ALSOFT] (WW) ").first<14>(); break;
+    case LogLevel::Trace: prefix = al::as_span("[ALSOFT] (II) ").first<14>(); break;
+    }
+
+    al::vector<char> dynmsg;
+    std::array<char,256> stcmsg{};
+
+    char *str{stcmsg.data()};
+    auto prefend1 = std::copy_n(prefix.begin(), prefix.size(), stcmsg.begin());
+    al::span<char> msg{prefend1, stcmsg.end()};
+
+    std::va_list args, args2;
+    va_start(args, fmt);
+    va_copy(args2, args);
+    const int msglen{std::vsnprintf(msg.data(), msg.size(), fmt, args)};
+    if(msglen >= 0 && static_cast<size_t>(msglen) >= msg.size()) UNLIKELY
+    {
+        dynmsg.resize(static_cast<size_t>(msglen)+prefix.size() + 1u);
+
+        str = dynmsg.data();
+        auto prefend2 = std::copy_n(prefix.begin(), prefix.size(), dynmsg.begin());
+        msg = {prefend2, dynmsg.end()};
+
+        std::vsnprintf(msg.data(), msg.size(), fmt, args2);
+    }
+    va_end(args2);
+    va_end(args);
+
+    if(gLogLevel >= level)
+    {
+        fputs(str, logfile);
+        fflush(logfile);
+    }
+#if defined(_WIN32) && !defined(NDEBUG)
+    /* OutputDebugStringW has no 'level' property to distinguish between
+     * informational, warning, or error debug messages. So only print them for
+     * non-Release builds.
+     */
+    std::wstring wstr{utf8_to_wstr(str)};
+    OutputDebugStringW(wstr.c_str());
+#elif defined(__ANDROID__)
+    auto android_severity = [](LogLevel l) noexcept
+    {
+        switch(l)
+        {
+        case LogLevel::Trace: return ANDROID_LOG_DEBUG;
+        case LogLevel::Warning: return ANDROID_LOG_WARN;
+        case LogLevel::Error: return ANDROID_LOG_ERROR;
+        /* Should not happen. */
+        case LogLevel::Disable:
+            break;
+        }
+        return ANDROID_LOG_ERROR;
+    };
+    __android_log_print(android_severity(level), "openal", "%s", str);
+#endif
+}
diff --git a/core/logging.h b/core/logging.h
new file mode 100644
index 00000000..f4b6ab56
--- /dev/null
+++ b/core/logging.h
@@ -0,0 +1,51 @@
+#ifndef CORE_LOGGING_H
+#define CORE_LOGGING_H
+
+#include <stdio.h>
+
+#include "opthelpers.h"
+
+
+enum class LogLevel {
+    Disable,
+    Error,
+    Warning,
+    Trace
+};
+extern LogLevel gLogLevel;
+
+extern FILE *gLogFile;
+
+#ifdef __USE_MINGW_ANSI_STDIO
+[[gnu::format(gnu_printf,3,4)]]
+#else
+[[gnu::format(printf,3,4)]]
+#endif
+void al_print(LogLevel level, FILE *logfile, const char *fmt, ...);
+
+#if (!defined(_WIN32) || defined(NDEBUG)) && !defined(__ANDROID__)
+#define TRACE(...) do {                                                       \
+    if(gLogLevel >= LogLevel::Trace) UNLIKELY                                 \
+        al_print(LogLevel::Trace, gLogFile, __VA_ARGS__);                     \
+} while(0)
+
+#define WARN(...) do {                                                        \
+    if(gLogLevel >= LogLevel::Warning) UNLIKELY                               \
+        al_print(LogLevel::Warning, gLogFile, __VA_ARGS__);                   \
+} while(0)
+
+#define ERR(...) do {                                                         \
+    if(gLogLevel >= LogLevel::Error) UNLIKELY                                 \
+        al_print(LogLevel::Error, gLogFile, __VA_ARGS__);                     \
+} while(0)
+
+#else
+
+#define TRACE(...) al_print(LogLevel::Trace, gLogFile, __VA_ARGS__)
+
+#define WARN(...) al_print(LogLevel::Warning, gLogFile, __VA_ARGS__)
+
+#define ERR(...) al_print(LogLevel::Error, gLogFile, __VA_ARGS__)
+#endif
+
+#endif /* CORE_LOGGING_H */
diff --git a/alc/mastering.cpp b/core/mastering.cpp
index 46cc3134..97a4008e 100644
--- a/alc/mastering.cpp
+++ b/core/mastering.cpp
@@ -11,23 +11,21 @@
 #include <limits>
 #include <new>
 
-#include "AL/al.h"
-
 #include "almalloc.h"
 #include "alnumeric.h"
-#include "alu.h"
+#include "alspan.h"
 #include "opthelpers.h"
 
 
-/* These structures assume BUFFERSIZE is a power of 2. */
-static_assert((BUFFERSIZE & (BUFFERSIZE-1)) == 0, "BUFFERSIZE is not a power of 2");
+/* These structures assume BufferLineSize is a power of 2. */
+static_assert((BufferLineSize & (BufferLineSize-1)) == 0, "BufferLineSize is not a power of 2");
 
 struct SlidingHold {
-    alignas(16) ALfloat mValues[BUFFERSIZE];
-    ALuint mExpiries[BUFFERSIZE];
-    ALuint mLowerIndex;
-    ALuint mUpperIndex;
-    ALuint mLength;
+    alignas(16) float mValues[BufferLineSize];
+    uint mExpiries[BufferLineSize];
+    uint mLowerIndex;
+    uint mUpperIndex;
+    uint mLength;
 };
 
 
@@ -42,14 +40,14 @@ using namespace std::placeholders;
  *
  *   http://www.richardhartersworld.com/cri/2001/slidingmin.html
  */
-ALfloat UpdateSlidingHold(SlidingHold *Hold, const ALuint i, const ALfloat in)
+float UpdateSlidingHold(SlidingHold *Hold, const uint i, const float in)
 {
-    static constexpr ALuint mask{BUFFERSIZE - 1};
-    const ALuint length{Hold->mLength};
-    ALfloat (&values)[BUFFERSIZE] = Hold->mValues;
-    ALuint (&expiries)[BUFFERSIZE] = Hold->mExpiries;
-    ALuint lowerIndex{Hold->mLowerIndex};
-    ALuint upperIndex{Hold->mUpperIndex};
+    static constexpr uint mask{BufferLineSize - 1};
+    const uint length{Hold->mLength};
+    float (&values)[BufferLineSize] = Hold->mValues;
+    uint (&expiries)[BufferLineSize] = Hold->mExpiries;
+    uint lowerIndex{Hold->mLowerIndex};
+    uint upperIndex{Hold->mUpperIndex};
 
     if(i >= expiries[upperIndex])
         upperIndex = (upperIndex + 1) & mask;
@@ -68,7 +66,7 @@ ALfloat UpdateSlidingHold(SlidingHold *Hold, const ALuint i, const ALfloat in)
                     goto found_place;
             } while(lowerIndex--);
             lowerIndex = mask;
-        } while(1);
+        } while(true);
     found_place:
 
         lowerIndex = (lowerIndex + 1) & mask;
@@ -82,26 +80,26 @@ ALfloat UpdateSlidingHold(SlidingHold *Hold, const ALuint i, const ALfloat in)
     return values[upperIndex];
 }
 
-void ShiftSlidingHold(SlidingHold *Hold, const ALuint n)
+void ShiftSlidingHold(SlidingHold *Hold, const uint n)
 {
     auto exp_begin = std::begin(Hold->mExpiries) + Hold->mUpperIndex;
     auto exp_last = std::begin(Hold->mExpiries) + Hold->mLowerIndex;
     if(exp_last-exp_begin < 0)
     {
         std::transform(exp_begin, std::end(Hold->mExpiries), exp_begin,
-            std::bind(std::minus<ALuint>{}, _1, n));
+            [n](uint e){ return e - n; });
         exp_begin = std::begin(Hold->mExpiries);
     }
-    std::transform(exp_begin, exp_last+1, exp_begin, std::bind(std::minus<ALuint>{}, _1, n));
+    std::transform(exp_begin, exp_last+1, exp_begin, [n](uint e){ return e - n; });
 }
 
 
 /* Multichannel compression is linked via the absolute maximum of all
  * channels.
  */
-void LinkChannels(Compressor *Comp, const ALuint SamplesToDo, const FloatBufferLine *OutBuffer)
+void LinkChannels(Compressor *Comp, const uint SamplesToDo, const FloatBufferLine *OutBuffer)
 {
-    const ALuint numChans{Comp->mNumChans};
+    const size_t numChans{Comp->mNumChans};
 
     ASSUME(SamplesToDo > 0);
     ASSUME(numChans > 0);
@@ -111,7 +109,7 @@ void LinkChannels(Compressor *Comp, const ALuint SamplesToDo, const FloatBufferL
 
     auto fill_max = [SamplesToDo,side_begin](const FloatBufferLine &input) -> void
     {
-        const ALfloat *RESTRICT buffer{al::assume_aligned<16>(input.data())};
+        const float *RESTRICT buffer{al::assume_aligned<16>(input.data())};
         auto max_abs = std::bind(maxf, _1, std::bind(static_cast<float(&)(float)>(std::fabs), _2));
         std::transform(side_begin, side_begin+SamplesToDo, buffer, side_begin, max_abs);
     };
@@ -123,20 +121,20 @@ void LinkChannels(Compressor *Comp, const ALuint SamplesToDo, const FloatBufferL
  * it uses an instantaneous squared peak detector and a squared RMS detector
  * both with 200ms release times.
  */
-static void CrestDetector(Compressor *Comp, const ALuint SamplesToDo)
+void CrestDetector(Compressor *Comp, const uint SamplesToDo)
 {
-    const ALfloat a_crest{Comp->mCrestCoeff};
-    ALfloat y2_peak{Comp->mLastPeakSq};
-    ALfloat y2_rms{Comp->mLastRmsSq};
+    const float a_crest{Comp->mCrestCoeff};
+    float y2_peak{Comp->mLastPeakSq};
+    float y2_rms{Comp->mLastRmsSq};
 
     ASSUME(SamplesToDo > 0);
 
-    auto calc_crest = [&y2_rms,&y2_peak,a_crest](const ALfloat x_abs) noexcept -> ALfloat
+    auto calc_crest = [&y2_rms,&y2_peak,a_crest](const float x_abs) noexcept -> float
     {
-        const ALfloat x2{clampf(x_abs * x_abs, 0.000001f, 1000000.0f)};
+        const float x2{clampf(x_abs * x_abs, 0.000001f, 1000000.0f)};
 
-        y2_peak = maxf(x2, lerp(x2, y2_peak, a_crest));
-        y2_rms = lerp(x2, y2_rms, a_crest);
+        y2_peak = maxf(x2, lerpf(x2, y2_peak, a_crest));
+        y2_rms = lerpf(x2, y2_rms, a_crest);
         return y2_peak / y2_rms;
     };
     auto side_begin = std::begin(Comp->mSideChain) + Comp->mLookAhead;
@@ -150,29 +148,29 @@ static void CrestDetector(Compressor *Comp, const ALuint SamplesToDo)
  * value of the incoming signal) and performs most of its operations in the
  * log domain.
  */
-void PeakDetector(Compressor *Comp, const ALuint SamplesToDo)
+void PeakDetector(Compressor *Comp, const uint SamplesToDo)
 {
     ASSUME(SamplesToDo > 0);
 
     /* Clamp the minimum amplitude to near-zero and convert to logarithm. */
     auto side_begin = std::begin(Comp->mSideChain) + Comp->mLookAhead;
     std::transform(side_begin, side_begin+SamplesToDo, side_begin,
-        std::bind(static_cast<float(&)(float)>(std::log), std::bind(maxf, 0.000001f, _1)));
+        [](float s) { return std::log(maxf(0.000001f, s)); });
 }
 
 /* An optional hold can be used to extend the peak detector so it can more
  * solidly detect fast transients.  This is best used when operating as a
  * limiter.
  */
-void PeakHoldDetector(Compressor *Comp, const ALuint SamplesToDo)
+void PeakHoldDetector(Compressor *Comp, const uint SamplesToDo)
 {
     ASSUME(SamplesToDo > 0);
 
     SlidingHold *hold{Comp->mHold};
-    ALuint i{0};
-    auto detect_peak = [&i,hold](const ALfloat x_abs) -> ALfloat
+    uint i{0};
+    auto detect_peak = [&i,hold](const float x_abs) -> float
     {
-        const ALfloat x_G{std::log(maxf(0.000001f, x_abs))};
+        const float x_G{std::log(maxf(0.000001f, x_abs))};
         return UpdateSlidingHold(hold, i++, x_G);
     };
     auto side_begin = std::begin(Comp->mSideChain) + Comp->mLookAhead;
@@ -186,50 +184,49 @@ void PeakHoldDetector(Compressor *Comp, const ALuint SamplesToDo)
  * to knee width, attack/release times, make-up/post gain, and clipping
  * reduction.
  */
-void GainCompressor(Compressor *Comp, const ALuint SamplesToDo)
+void GainCompressor(Compressor *Comp, const uint SamplesToDo)
 {
     const bool autoKnee{Comp->mAuto.Knee};
     const bool autoAttack{Comp->mAuto.Attack};
     const bool autoRelease{Comp->mAuto.Release};
     const bool autoPostGain{Comp->mAuto.PostGain};
     const bool autoDeclip{Comp->mAuto.Declip};
-    const ALuint lookAhead{Comp->mLookAhead};
-    const ALfloat threshold{Comp->mThreshold};
-    const ALfloat slope{Comp->mSlope};
-    const ALfloat attack{Comp->mAttack};
-    const ALfloat release{Comp->mRelease};
-    const ALfloat c_est{Comp->mGainEstimate};
-    const ALfloat a_adp{Comp->mAdaptCoeff};
-    const ALfloat *crestFactor{Comp->mCrestFactor};
-    ALfloat postGain{Comp->mPostGain};
-    ALfloat knee{Comp->mKnee};
-    ALfloat t_att{attack};
-    ALfloat t_rel{release - attack};
-    ALfloat a_att{std::exp(-1.0f / t_att)};
-    ALfloat a_rel{std::exp(-1.0f / t_rel)};
-    ALfloat y_1{Comp->mLastRelease};
-    ALfloat y_L{Comp->mLastAttack};
-    ALfloat c_dev{Comp->mLastGainDev};
+    const uint lookAhead{Comp->mLookAhead};
+    const float threshold{Comp->mThreshold};
+    const float slope{Comp->mSlope};
+    const float attack{Comp->mAttack};
+    const float release{Comp->mRelease};
+    const float c_est{Comp->mGainEstimate};
+    const float a_adp{Comp->mAdaptCoeff};
+    const float *crestFactor{Comp->mCrestFactor};
+    float postGain{Comp->mPostGain};
+    float knee{Comp->mKnee};
+    float t_att{attack};
+    float t_rel{release - attack};
+    float a_att{std::exp(-1.0f / t_att)};
+    float a_rel{std::exp(-1.0f / t_rel)};
+    float y_1{Comp->mLastRelease};
+    float y_L{Comp->mLastAttack};
+    float c_dev{Comp->mLastGainDev};
 
     ASSUME(SamplesToDo > 0);
 
-    for(ALfloat &sideChain : al::span<float>{Comp->mSideChain, SamplesToDo})
+    for(float &sideChain : al::span<float>{Comp->mSideChain, SamplesToDo})
     {
         if(autoKnee)
             knee = maxf(0.0f, 2.5f * (c_dev + c_est));
-        const ALfloat knee_h{0.5f * knee};
+        const float knee_h{0.5f * knee};
 
         /* This is the gain computer.  It applies a static compression curve
          * to the control signal.
          */
-        const ALfloat x_over{std::addressof(sideChain)[lookAhead] - threshold};
-        const ALfloat y_G{
+        const float x_over{std::addressof(sideChain)[lookAhead] - threshold};
+        const float y_G{
             (x_over <= -knee_h) ? 0.0f :
             (std::fabs(x_over) < knee_h) ? (x_over + knee_h) * (x_over + knee_h) / (2.0f * knee) :
-            x_over
-        };
+            x_over};
 
-        const ALfloat y2_crest{*(crestFactor++)};
+        const float y2_crest{*(crestFactor++)};
         if(autoAttack)
         {
             t_att = 2.0f*attack/y2_crest;
@@ -245,16 +242,16 @@ void GainCompressor(Compressor *Comp, const ALuint SamplesToDo)
          * detector.  The attack time is subtracted from the release time
          * above to compensate for the chained operating mode.
          */
-        const ALfloat x_L{-slope * y_G};
-        y_1 = maxf(x_L, lerp(x_L, y_1, a_rel));
-        y_L = lerp(y_1, y_L, a_att);
+        const float x_L{-slope * y_G};
+        y_1 = maxf(x_L, lerpf(x_L, y_1, a_rel));
+        y_L = lerpf(y_1, y_L, a_att);
 
         /* Knee width and make-up gain automation make use of a smoothed
          * measurement of deviation between the control signal and estimate.
          * The estimate is also used to bias the measurement to hot-start its
          * average.
          */
-        c_dev = lerp(-(y_L+c_est), c_dev, a_adp);
+        c_dev = lerpf(-(y_L+c_est), c_dev, a_adp);
 
         if(autoPostGain)
         {
@@ -283,22 +280,22 @@ void GainCompressor(Compressor *Comp, const ALuint SamplesToDo)
  * reaching the offending impulse.  This is best used when operating as a
  * limiter.
  */
-void SignalDelay(Compressor *Comp, const ALuint SamplesToDo, FloatBufferLine *OutBuffer)
+void SignalDelay(Compressor *Comp, const uint SamplesToDo, FloatBufferLine *OutBuffer)
 {
-    const ALuint numChans{Comp->mNumChans};
-    const ALuint lookAhead{Comp->mLookAhead};
+    const size_t numChans{Comp->mNumChans};
+    const uint lookAhead{Comp->mLookAhead};
 
     ASSUME(SamplesToDo > 0);
     ASSUME(numChans > 0);
     ASSUME(lookAhead > 0);
 
-    for(ALuint c{0};c < numChans;c++)
+    for(size_t c{0};c < numChans;c++)
     {
-        ALfloat *inout{al::assume_aligned<16>(OutBuffer[c].data())};
-        ALfloat *delaybuf{al::assume_aligned<16>(Comp->mDelay[c].data())};
+        float *inout{al::assume_aligned<16>(OutBuffer[c].data())};
+        float *delaybuf{al::assume_aligned<16>(Comp->mDelay[c].data())};
 
         auto inout_end = inout + SamplesToDo;
-        if LIKELY(SamplesToDo >= lookAhead)
+        if(SamplesToDo >= lookAhead) LIKELY
         {
             auto delay_end = std::rotate(inout, inout_end - lookAhead, inout_end);
             std::swap_ranges(inout, delay_end, delaybuf);
@@ -313,41 +310,17 @@ void SignalDelay(Compressor *Comp, const ALuint SamplesToDo, FloatBufferLine *Ou
 
 } // namespace
 
-/* The compressor is initialized with the following settings:
- *
- *   NumChans       - Number of channels to process.
- *   SampleRate     - Sample rate to process.
- *   AutoKnee       - Whether to automate the knee width parameter.
- *   AutoAttack     - Whether to automate the attack time parameter.
- *   AutoRelease    - Whether to automate the release time parameter.
- *   AutoPostGain   - Whether to automate the make-up (post) gain parameter.
- *   AutoDeclip     - Whether to automate clipping reduction.  Ignored when
- *                    not automating make-up gain.
- *   LookAheadTime  - Look-ahead time (in seconds).
- *   HoldTime       - Peak hold-time (in seconds).
- *   PreGainDb      - Gain applied before detection (in dB).
- *   PostGainDb     - Make-up gain applied after compression (in dB).
- *   ThresholdDb    - Triggering threshold (in dB).
- *   Ratio          - Compression ratio (x:1).  Set to INFINITY for true
- *                    limiting.  Ignored when automating knee width.
- *   KneeDb         - Knee width (in dB).  Ignored when automating knee
- *                    width.
- *   AttackTimeMin  - Attack time (in seconds).  Acts as a maximum when
- *                    automating attack time.
- *   ReleaseTimeMin - Release time (in seconds).  Acts as a maximum when
- *                    automating release time.
- */
-std::unique_ptr<Compressor> CompressorInit(const ALuint NumChans, const ALfloat SampleRate,
-    const ALboolean AutoKnee, const ALboolean AutoAttack, const ALboolean AutoRelease,
-    const ALboolean AutoPostGain, const ALboolean AutoDeclip, const ALfloat LookAheadTime,
-    const ALfloat HoldTime, const ALfloat PreGainDb, const ALfloat PostGainDb,
-    const ALfloat ThresholdDb, const ALfloat Ratio, const ALfloat KneeDb, const ALfloat AttackTime,
-    const ALfloat ReleaseTime)
+
+std::unique_ptr<Compressor> Compressor::Create(const size_t NumChans, const float SampleRate,
+    const bool AutoKnee, const bool AutoAttack, const bool AutoRelease, const bool AutoPostGain,
+    const bool AutoDeclip, const float LookAheadTime, const float HoldTime, const float PreGainDb,
+    const float PostGainDb, const float ThresholdDb, const float Ratio, const float KneeDb,
+    const float AttackTime, const float ReleaseTime)
 {
-    const auto lookAhead = static_cast<ALuint>(
-        clampf(std::round(LookAheadTime*SampleRate), 0.0f, BUFFERSIZE-1));
-    const auto hold = static_cast<ALuint>(
-        clampf(std::round(HoldTime*SampleRate), 0.0f, BUFFERSIZE-1));
+    const auto lookAhead = static_cast<uint>(
+        clampf(std::round(LookAheadTime*SampleRate), 0.0f, BufferLineSize-1));
+    const auto hold = static_cast<uint>(
+        clampf(std::round(HoldTime*SampleRate), 0.0f, BufferLineSize-1));
 
     size_t size{sizeof(Compressor)};
     if(lookAhead > 0)
@@ -361,12 +334,12 @@ std::unique_ptr<Compressor> CompressorInit(const ALuint NumChans, const ALfloat
             size += sizeof(*Compressor::mHold);
     }
 
-    auto Comp = std::unique_ptr<Compressor>{new (al_calloc(16, size)) Compressor{}};
+    auto Comp = CompressorPtr{al::construct_at(static_cast<Compressor*>(al_calloc(16, size)))};
     Comp->mNumChans = NumChans;
-    Comp->mAuto.Knee = AutoKnee != AL_FALSE;
-    Comp->mAuto.Attack = AutoAttack != AL_FALSE;
-    Comp->mAuto.Release = AutoRelease != AL_FALSE;
-    Comp->mAuto.PostGain = AutoPostGain != AL_FALSE;
+    Comp->mAuto.Knee = AutoKnee;
+    Comp->mAuto.Attack = AutoAttack;
+    Comp->mAuto.Release = AutoRelease;
+    Comp->mAuto.PostGain = AutoPostGain;
     Comp->mAuto.Declip = AutoPostGain && AutoDeclip;
     Comp->mLookAhead = lookAhead;
     Comp->mPreGain = std::pow(10.0f, PreGainDb / 20.0f);
@@ -388,17 +361,15 @@ std::unique_ptr<Compressor> CompressorInit(const ALuint NumChans, const ALfloat
     {
         if(hold > 1)
         {
-            Comp->mHold = ::new (static_cast<void*>(Comp.get() + 1)) SlidingHold{};
+            Comp->mHold = al::construct_at(reinterpret_cast<SlidingHold*>(Comp.get() + 1));
             Comp->mHold->mValues[0] = -std::numeric_limits<float>::infinity();
             Comp->mHold->mExpiries[0] = hold;
             Comp->mHold->mLength = hold;
-            Comp->mDelay = ::new (static_cast<void*>(Comp->mHold + 1)) FloatBufferLine[NumChans];
+            Comp->mDelay = reinterpret_cast<FloatBufferLine*>(Comp->mHold + 1);
         }
         else
-        {
-            Comp->mDelay = ::new (static_cast<void*>(Comp.get() + 1)) FloatBufferLine[NumChans];
-        }
-        std::fill_n(Comp->mDelay, NumChans, FloatBufferLine{});
+            Comp->mDelay = reinterpret_cast<FloatBufferLine*>(Comp.get() + 1);
+        std::uninitialized_fill_n(Comp->mDelay, NumChans, FloatBufferLine{});
     }
 
     Comp->mCrestCoeff = std::exp(-1.0f / (0.200f * SampleRate)); // 200ms
@@ -419,21 +390,21 @@ Compressor::~Compressor()
 }
 
 
-void Compressor::process(const ALuint SamplesToDo, FloatBufferLine *OutBuffer)
+void Compressor::process(const uint SamplesToDo, FloatBufferLine *OutBuffer)
 {
-    const ALuint numChans{mNumChans};
+    const size_t numChans{mNumChans};
 
     ASSUME(SamplesToDo > 0);
     ASSUME(numChans > 0);
 
-    const ALfloat preGain{mPreGain};
+    const float preGain{mPreGain};
     if(preGain != 1.0f)
     {
         auto apply_gain = [SamplesToDo,preGain](FloatBufferLine &input) noexcept -> void
         {
-            ALfloat *buffer{al::assume_aligned<16>(input.data())};
+            float *buffer{al::assume_aligned<16>(input.data())};
             std::transform(buffer, buffer+SamplesToDo, buffer,
-                std::bind(std::multiplies<float>{}, _1, preGain));
+                [preGain](float s) { return s * preGain; });
         };
         std::for_each(OutBuffer, OutBuffer+numChans, apply_gain);
     }
@@ -453,13 +424,13 @@ void Compressor::process(const ALuint SamplesToDo, FloatBufferLine *OutBuffer)
     if(mDelay)
         SignalDelay(this, SamplesToDo, OutBuffer);
 
-    const ALfloat (&sideChain)[BUFFERSIZE*2] = mSideChain;
+    const float (&sideChain)[BufferLineSize*2] = mSideChain;
     auto apply_comp = [SamplesToDo,&sideChain](FloatBufferLine &input) noexcept -> void
     {
-        ALfloat *buffer{al::assume_aligned<16>(input.data())};
-        const ALfloat *gains{al::assume_aligned<16>(&sideChain[0])};
+        float *buffer{al::assume_aligned<16>(input.data())};
+        const float *gains{al::assume_aligned<16>(&sideChain[0])};
         std::transform(gains, gains+SamplesToDo, buffer, buffer,
-            std::bind(std::multiplies<float>{}, _1, _2));
+            [](float g, float s) { return g * s; });
     };
     std::for_each(OutBuffer, OutBuffer+numChans, apply_comp);
 
diff --git a/core/mastering.h b/core/mastering.h
new file mode 100644
index 00000000..1a36937c
--- /dev/null
+++ b/core/mastering.h
@@ -0,0 +1,105 @@
+#ifndef CORE_MASTERING_H
+#define CORE_MASTERING_H
+
+#include <memory>
+
+#include "almalloc.h"
+#include "bufferline.h"
+
+struct SlidingHold;
+
+using uint = unsigned int;
+
+
+/* General topology and basic automation was based on the following paper:
+ *
+ *   D. Giannoulis, M. Massberg and J. D. Reiss,
+ *   "Parameter Automation in a Dynamic Range Compressor,"
+ *   Journal of the Audio Engineering Society, v61 (10), Oct. 2013
+ *
+ * Available (along with supplemental reading) at:
+ *
+ *   http://c4dm.eecs.qmul.ac.uk/audioengineering/compressors/
+ */
+struct Compressor {
+    size_t mNumChans{0u};
+
+    struct {
+        bool Knee : 1;
+        bool Attack : 1;
+        bool Release : 1;
+        bool PostGain : 1;
+        bool Declip : 1;
+    } mAuto{};
+
+    uint mLookAhead{0};
+
+    float mPreGain{0.0f};
+    float mPostGain{0.0f};
+
+    float mThreshold{0.0f};
+    float mSlope{0.0f};
+    float mKnee{0.0f};
+
+    float mAttack{0.0f};
+    float mRelease{0.0f};
+
+    alignas(16) float mSideChain[2*BufferLineSize]{};
+    alignas(16) float mCrestFactor[BufferLineSize]{};
+
+    SlidingHold *mHold{nullptr};
+    FloatBufferLine *mDelay{nullptr};
+
+    float mCrestCoeff{0.0f};
+    float mGainEstimate{0.0f};
+    float mAdaptCoeff{0.0f};
+
+    float mLastPeakSq{0.0f};
+    float mLastRmsSq{0.0f};
+    float mLastRelease{0.0f};
+    float mLastAttack{0.0f};
+    float mLastGainDev{0.0f};
+
+
+    ~Compressor();
+    void process(const uint SamplesToDo, FloatBufferLine *OutBuffer);
+    int getLookAhead() const noexcept { return static_cast<int>(mLookAhead); }
+
+    DEF_PLACE_NEWDEL()
+
+    /**
+     * The compressor is initialized with the following settings:
+     *
+     * \param NumChans      Number of channels to process.
+     * \param SampleRate    Sample rate to process.
+     * \param AutoKnee      Whether to automate the knee width parameter.
+     * \param AutoAttack    Whether to automate the attack time parameter.
+     * \param AutoRelease   Whether to automate the release time parameter.
+     * \param AutoPostGain  Whether to automate the make-up (post) gain
+     *        parameter.
+     * \param AutoDeclip    Whether to automate clipping reduction. Ignored
+     *        when not automating make-up gain.
+     * \param LookAheadTime Look-ahead time (in seconds).
+     * \param HoldTime      Peak hold-time (in seconds).
+     * \param PreGainDb     Gain applied before detection (in dB).
+     * \param PostGainDb    Make-up gain applied after compression (in dB).
+     * \param ThresholdDb   Triggering threshold (in dB).
+     * \param Ratio         Compression ratio (x:1). Set to INFINIFTY for true
+     *        limiting. Ignored when automating knee width.
+     * \param KneeDb        Knee width (in dB). Ignored when automating knee
+     *        width.
+     * \param AttackTime    Attack time (in seconds). Acts as a maximum when
+     *        automating attack time.
+     * \param ReleaseTime   Release time (in seconds). Acts as a maximum when
+     *        automating release time.
+     */
+    static std::unique_ptr<Compressor> Create(const size_t NumChans, const float SampleRate,
+        const bool AutoKnee, const bool AutoAttack, const bool AutoRelease,
+        const bool AutoPostGain, const bool AutoDeclip, const float LookAheadTime,
+        const float HoldTime, const float PreGainDb, const float PostGainDb,
+        const float ThresholdDb, const float Ratio, const float KneeDb, const float AttackTime,
+        const float ReleaseTime);
+};
+using CompressorPtr = std::unique_ptr<Compressor>;
+
+#endif /* CORE_MASTERING_H */
diff --git a/core/mixer.cpp b/core/mixer.cpp
new file mode 100644
index 00000000..066c57bd
--- /dev/null
+++ b/core/mixer.cpp
@@ -0,0 +1,95 @@
+
+#include "config.h"
+
+#include "mixer.h"
+
+#include <cmath>
+
+#include "alnumbers.h"
+#include "devformat.h"
+#include "device.h"
+#include "mixer/defs.h"
+
+struct CTag;
+
+
+MixerOutFunc MixSamplesOut{Mix_<CTag>};
+MixerOneFunc MixSamplesOne{Mix_<CTag>};
+
+
+std::array<float,MaxAmbiChannels> CalcAmbiCoeffs(const float y, const float z, const float x,
+    const float spread)
+{
+    std::array<float,MaxAmbiChannels> coeffs{CalcAmbiCoeffs(y, z, x)};
+
+    if(spread > 0.0f)
+    {
+        /* Implement the spread by using a spherical source that subtends the
+         * angle spread. See:
+         * http://www.ppsloan.org/publications/StupidSH36.pdf - Appendix A3
+         *
+         * When adjusted for N3D normalization instead of SN3D, these
+         * calculations are:
+         *
+         * ZH0 = -sqrt(pi) * (-1+ca);
+         * ZH1 =  0.5*sqrt(pi) * sa*sa;
+         * ZH2 = -0.5*sqrt(pi) * ca*(-1+ca)*(ca+1);
+         * ZH3 = -0.125*sqrt(pi) * (-1+ca)*(ca+1)*(5*ca*ca - 1);
+         * ZH4 = -0.125*sqrt(pi) * ca*(-1+ca)*(ca+1)*(7*ca*ca - 3);
+         * ZH5 = -0.0625*sqrt(pi) * (-1+ca)*(ca+1)*(21*ca*ca*ca*ca - 14*ca*ca + 1);
+         *
+         * The gain of the source is compensated for size, so that the
+         * loudness doesn't depend on the spread. Thus:
+         *
+         * ZH0 = 1.0f;
+         * ZH1 = 0.5f * (ca+1.0f);
+         * ZH2 = 0.5f * (ca+1.0f)*ca;
+         * ZH3 = 0.125f * (ca+1.0f)*(5.0f*ca*ca - 1.0f);
+         * ZH4 = 0.125f * (ca+1.0f)*(7.0f*ca*ca - 3.0f)*ca;
+         * ZH5 = 0.0625f * (ca+1.0f)*(21.0f*ca*ca*ca*ca - 14.0f*ca*ca + 1.0f);
+         */
+        const float ca{std::cos(spread * 0.5f)};
+        /* Increase the source volume by up to +3dB for a full spread. */
+        const float scale{std::sqrt(1.0f + al::numbers::inv_pi_v<float>/2.0f*spread)};
+
+        const float ZH0_norm{scale};
+        const float ZH1_norm{scale * 0.5f * (ca+1.f)};
+        const float ZH2_norm{scale * 0.5f * (ca+1.f)*ca};
+        const float ZH3_norm{scale * 0.125f * (ca+1.f)*(5.f*ca*ca-1.f)};
+
+        /* Zeroth-order */
+        coeffs[0]  *= ZH0_norm;
+        /* First-order */
+        coeffs[1]  *= ZH1_norm;
+        coeffs[2]  *= ZH1_norm;
+        coeffs[3]  *= ZH1_norm;
+        /* Second-order */
+        coeffs[4]  *= ZH2_norm;
+        coeffs[5]  *= ZH2_norm;
+        coeffs[6]  *= ZH2_norm;
+        coeffs[7]  *= ZH2_norm;
+        coeffs[8]  *= ZH2_norm;
+        /* Third-order */
+        coeffs[9]  *= ZH3_norm;
+        coeffs[10] *= ZH3_norm;
+        coeffs[11] *= ZH3_norm;
+        coeffs[12] *= ZH3_norm;
+        coeffs[13] *= ZH3_norm;
+        coeffs[14] *= ZH3_norm;
+        coeffs[15] *= ZH3_norm;
+    }
+
+    return coeffs;
+}
+
+void ComputePanGains(const MixParams *mix, const float*RESTRICT coeffs, const float ingain,
+    const al::span<float,MaxAmbiChannels> gains)
+{
+    auto ambimap = mix->AmbiMap.cbegin();
+
+    auto iter = std::transform(ambimap, ambimap+mix->Buffer.size(), gains.begin(),
+        [coeffs,ingain](const BFChannelConfig &chanmap) noexcept -> float
+        { return chanmap.Scale * coeffs[chanmap.Index] * ingain; }
+    );
+    std::fill(iter, gains.end(), 0.0f);
+}
diff --git a/core/mixer.h b/core/mixer.h
new file mode 100644
index 00000000..aa7597bb
--- /dev/null
+++ b/core/mixer.h
@@ -0,0 +1,109 @@
+#ifndef CORE_MIXER_H
+#define CORE_MIXER_H
+
+#include <array>
+#include <cmath>
+#include <stddef.h>
+#include <type_traits>
+
+#include "alspan.h"
+#include "ambidefs.h"
+#include "bufferline.h"
+#include "devformat.h"
+
+struct MixParams;
+
+/* Mixer functions that handle one input and multiple output channels. */
+using MixerOutFunc = void(*)(const al::span<const float> InSamples,
+    const al::span<FloatBufferLine> OutBuffer, float *CurrentGains, const float *TargetGains,
+    const size_t Counter, const size_t OutPos);
+
+extern MixerOutFunc MixSamplesOut;
+inline void MixSamples(const al::span<const float> InSamples,
+    const al::span<FloatBufferLine> OutBuffer, float *CurrentGains, const float *TargetGains,
+    const size_t Counter, const size_t OutPos)
+{ MixSamplesOut(InSamples, OutBuffer, CurrentGains, TargetGains, Counter, OutPos); }
+
+/* Mixer functions that handle one input and one output channel. */
+using MixerOneFunc = void(*)(const al::span<const float> InSamples, float *OutBuffer,
+    float &CurrentGain, const float TargetGain, const size_t Counter);
+
+extern MixerOneFunc MixSamplesOne;
+inline void MixSamples(const al::span<const float> InSamples, float *OutBuffer, float &CurrentGain,
+    const float TargetGain, const size_t Counter)
+{ MixSamplesOne(InSamples, OutBuffer, CurrentGain, TargetGain, Counter); }
+
+
+/**
+ * Calculates ambisonic encoder coefficients using the X, Y, and Z direction
+ * components, which must represent a normalized (unit length) vector, and the
+ * spread is the angular width of the sound (0...tau).
+ *
+ * NOTE: The components use ambisonic coordinates. As a result:
+ *
+ * Ambisonic Y = OpenAL -X
+ * Ambisonic Z = OpenAL Y
+ * Ambisonic X = OpenAL -Z
+ *
+ * The components are ordered such that OpenAL's X, Y, and Z are the first,
+ * second, and third parameters respectively -- simply negate X and Z.
+ */
+std::array<float,MaxAmbiChannels> CalcAmbiCoeffs(const float y, const float z, const float x,
+    const float spread);
+
+/**
+ * CalcDirectionCoeffs
+ *
+ * Calculates ambisonic coefficients based on an OpenAL direction vector. The
+ * vector must be normalized (unit length), and the spread is the angular width
+ * of the sound (0...tau).
+ */
+inline std::array<float,MaxAmbiChannels> CalcDirectionCoeffs(const float (&dir)[3],
+    const float spread)
+{
+    /* Convert from OpenAL coords to Ambisonics. */
+    return CalcAmbiCoeffs(-dir[0], dir[1], -dir[2], spread);
+}
+
+/**
+ * CalcDirectionCoeffs
+ *
+ * Calculates ambisonic coefficients based on an OpenAL direction vector. The
+ * vector must be normalized (unit length).
+ */
+constexpr std::array<float,MaxAmbiChannels> CalcDirectionCoeffs(const float (&dir)[3])
+{
+    /* Convert from OpenAL coords to Ambisonics. */
+    return CalcAmbiCoeffs(-dir[0], dir[1], -dir[2]);
+}
+
+/**
+ * CalcAngleCoeffs
+ *
+ * Calculates ambisonic coefficients based on azimuth and elevation. The
+ * azimuth and elevation parameters are in radians, going right and up
+ * respectively.
+ */
+inline std::array<float,MaxAmbiChannels> CalcAngleCoeffs(const float azimuth,
+    const float elevation, const float spread)
+{
+    const float x{-std::sin(azimuth) * std::cos(elevation)};
+    const float y{ std::sin(elevation)};
+    const float z{ std::cos(azimuth) * std::cos(elevation)};
+
+    return CalcAmbiCoeffs(x, y, z, spread);
+}
+
+
+/**
+ * ComputePanGains
+ *
+ * Computes panning gains using the given channel decoder coefficients and the
+ * pre-calculated direction or angle coefficients. For B-Format sources, the
+ * coeffs are a 'slice' of a transform matrix for the input channel, used to
+ * scale and orient the sound samples.
+ */
+void ComputePanGains(const MixParams *mix, const float*RESTRICT coeffs, const float ingain,
+    const al::span<float,MaxAmbiChannels> gains);
+
+#endif /* CORE_MIXER_H */
diff --git a/core/mixer/defs.h b/core/mixer/defs.h
new file mode 100644
index 00000000..48daca9b
--- /dev/null
+++ b/core/mixer/defs.h
@@ -0,0 +1,109 @@
+#ifndef CORE_MIXER_DEFS_H
+#define CORE_MIXER_DEFS_H
+
+#include <array>
+#include <stdlib.h>
+
+#include "alspan.h"
+#include "core/bufferline.h"
+#include "core/resampler_limits.h"
+
+struct CubicCoefficients;
+struct HrtfChannelState;
+struct HrtfFilter;
+struct MixHrtfFilter;
+
+using uint = unsigned int;
+using float2 = std::array<float,2>;
+
+
+constexpr int MixerFracBits{16};
+constexpr int MixerFracOne{1 << MixerFracBits};
+constexpr int MixerFracMask{MixerFracOne - 1};
+constexpr int MixerFracHalf{MixerFracOne >> 1};
+
+constexpr float GainSilenceThreshold{0.00001f}; /* -100dB */
+
+
+enum class Resampler : uint8_t {
+    Point,
+    Linear,
+    Cubic,
+    FastBSinc12,
+    BSinc12,
+    FastBSinc24,
+    BSinc24,
+
+    Max = BSinc24
+};
+
+/* Interpolator state. Kind of a misnomer since the interpolator itself is
+ * stateless. This just keeps it from having to recompute scale-related
+ * mappings for every sample.
+ */
+struct BsincState {
+    float sf; /* Scale interpolation factor. */
+    uint m; /* Coefficient count. */
+    uint l; /* Left coefficient offset. */
+    /* Filter coefficients, followed by the phase, scale, and scale-phase
+     * delta coefficients. Starting at phase index 0, each subsequent phase
+     * index follows contiguously.
+     */
+    const float *filter;
+};
+
+struct CubicState {
+    /* Filter coefficients, and coefficient deltas. Starting at phase index 0,
+     * each subsequent phase index follows contiguously.
+     */
+    const CubicCoefficients *filter;
+};
+
+union InterpState {
+    CubicState cubic;
+    BsincState bsinc;
+};
+
+using ResamplerFunc = void(*)(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst);
+
+ResamplerFunc PrepareResampler(Resampler resampler, uint increment, InterpState *state);
+
+
+template<typename TypeTag, typename InstTag>
+void Resample_(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst);
+
+template<typename InstTag>
+void Mix_(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
+    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos);
+template<typename InstTag>
+void Mix_(const al::span<const float> InSamples, float *OutBuffer, float &CurrentGain,
+    const float TargetGain, const size_t Counter);
+
+template<typename InstTag>
+void MixHrtf_(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize);
+template<typename InstTag>
+void MixHrtfBlend_(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const HrtfFilter *oldparams, const MixHrtfFilter *newparams, const size_t BufferSize);
+template<typename InstTag>
+void MixDirectHrtf_(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples,
+    float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize);
+
+/* Vectorized resampler helpers */
+template<size_t N>
+inline void InitPosArrays(uint frac, uint increment, uint (&frac_arr)[N], uint (&pos_arr)[N])
+{
+    pos_arr[0] = 0;
+    frac_arr[0] = frac;
+    for(size_t i{1};i < N;i++)
+    {
+        const uint frac_tmp{frac_arr[i-1] + increment};
+        pos_arr[i] = pos_arr[i-1] + (frac_tmp>>MixerFracBits);
+        frac_arr[i] = frac_tmp&MixerFracMask;
+    }
+}
+
+#endif /* CORE_MIXER_DEFS_H */
diff --git a/core/mixer/hrtfbase.h b/core/mixer/hrtfbase.h
new file mode 100644
index 00000000..36f88e49
--- /dev/null
+++ b/core/mixer/hrtfbase.h
@@ -0,0 +1,129 @@
+#ifndef CORE_MIXER_HRTFBASE_H
+#define CORE_MIXER_HRTFBASE_H
+
+#include <algorithm>
+#include <cmath>
+
+#include "almalloc.h"
+#include "hrtfdefs.h"
+#include "opthelpers.h"
+
+
+using uint = unsigned int;
+
+using ApplyCoeffsT = void(&)(float2 *RESTRICT Values, const size_t irSize,
+    const ConstHrirSpan Coeffs, const float left, const float right);
+
+template<ApplyCoeffsT ApplyCoeffs>
+inline void MixHrtfBase(const float *InSamples, float2 *RESTRICT AccumSamples, const size_t IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize)
+{
+    ASSUME(BufferSize > 0);
+
+    const ConstHrirSpan Coeffs{hrtfparams->Coeffs};
+    const float gainstep{hrtfparams->GainStep};
+    const float gain{hrtfparams->Gain};
+
+    size_t ldelay{HrtfHistoryLength - hrtfparams->Delay[0]};
+    size_t rdelay{HrtfHistoryLength - hrtfparams->Delay[1]};
+    float stepcount{0.0f};
+    for(size_t i{0u};i < BufferSize;++i)
+    {
+        const float g{gain + gainstep*stepcount};
+        const float left{InSamples[ldelay++] * g};
+        const float right{InSamples[rdelay++] * g};
+        ApplyCoeffs(AccumSamples+i, IrSize, Coeffs, left, right);
+
+        stepcount += 1.0f;
+    }
+}
+
+template<ApplyCoeffsT ApplyCoeffs>
+inline void MixHrtfBlendBase(const float *InSamples, float2 *RESTRICT AccumSamples,
+    const size_t IrSize, const HrtfFilter *oldparams, const MixHrtfFilter *newparams,
+    const size_t BufferSize)
+{
+    ASSUME(BufferSize > 0);
+
+    const ConstHrirSpan OldCoeffs{oldparams->Coeffs};
+    const float oldGainStep{oldparams->Gain / static_cast<float>(BufferSize)};
+    const ConstHrirSpan NewCoeffs{newparams->Coeffs};
+    const float newGainStep{newparams->GainStep};
+
+    if(oldparams->Gain > GainSilenceThreshold) LIKELY
+    {
+        size_t ldelay{HrtfHistoryLength - oldparams->Delay[0]};
+        size_t rdelay{HrtfHistoryLength - oldparams->Delay[1]};
+        auto stepcount = static_cast<float>(BufferSize);
+        for(size_t i{0u};i < BufferSize;++i)
+        {
+            const float g{oldGainStep*stepcount};
+            const float left{InSamples[ldelay++] * g};
+            const float right{InSamples[rdelay++] * g};
+            ApplyCoeffs(AccumSamples+i, IrSize, OldCoeffs, left, right);
+
+            stepcount -= 1.0f;
+        }
+    }
+
+    if(newGainStep*static_cast<float>(BufferSize) > GainSilenceThreshold) LIKELY
+    {
+        size_t ldelay{HrtfHistoryLength+1 - newparams->Delay[0]};
+        size_t rdelay{HrtfHistoryLength+1 - newparams->Delay[1]};
+        float stepcount{1.0f};
+        for(size_t i{1u};i < BufferSize;++i)
+        {
+            const float g{newGainStep*stepcount};
+            const float left{InSamples[ldelay++] * g};
+            const float right{InSamples[rdelay++] * g};
+            ApplyCoeffs(AccumSamples+i, IrSize, NewCoeffs, left, right);
+
+            stepcount += 1.0f;
+        }
+    }
+}
+
+template<ApplyCoeffsT ApplyCoeffs>
+inline void MixDirectHrtfBase(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *RESTRICT AccumSamples,
+    float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize)
+{
+    ASSUME(BufferSize > 0);
+
+    for(const FloatBufferLine &input : InSamples)
+    {
+        /* For dual-band processing, the signal needs extra scaling applied to
+         * the high frequency response. The band-splitter applies this scaling
+         * with a consistent phase shift regardless of the scale amount.
+         */
+        ChanState->mSplitter.processHfScale({input.data(), BufferSize}, TempBuf,
+            ChanState->mHfScale);
+
+        /* Now apply the HRIR coefficients to this channel. */
+        const float *RESTRICT tempbuf{al::assume_aligned<16>(TempBuf)};
+        const ConstHrirSpan Coeffs{ChanState->mCoeffs};
+        for(size_t i{0u};i < BufferSize;++i)
+        {
+            const float insample{tempbuf[i]};
+            ApplyCoeffs(AccumSamples+i, IrSize, Coeffs, insample, insample);
+        }
+
+        ++ChanState;
+    }
+
+    /* Add the HRTF signal to the existing "direct" signal. */
+    float *RESTRICT left{al::assume_aligned<16>(LeftOut.data())};
+    float *RESTRICT right{al::assume_aligned<16>(RightOut.data())};
+    for(size_t i{0u};i < BufferSize;++i)
+        left[i]  += AccumSamples[i][0];
+    for(size_t i{0u};i < BufferSize;++i)
+        right[i] += AccumSamples[i][1];
+
+    /* Copy the new in-progress accumulation values to the front and clear the
+     * following samples for the next mix.
+     */
+    auto accum_iter = std::copy_n(AccumSamples+BufferSize, HrirLength, AccumSamples);
+    std::fill_n(accum_iter, BufferSize, float2{});
+}
+
+#endif /* CORE_MIXER_HRTFBASE_H */
diff --git a/core/mixer/hrtfdefs.h b/core/mixer/hrtfdefs.h
new file mode 100644
index 00000000..3c903ed8
--- /dev/null
+++ b/core/mixer/hrtfdefs.h
@@ -0,0 +1,53 @@
+#ifndef CORE_MIXER_HRTFDEFS_H
+#define CORE_MIXER_HRTFDEFS_H
+
+#include <array>
+
+#include "alspan.h"
+#include "core/ambidefs.h"
+#include "core/bufferline.h"
+#include "core/filters/splitter.h"
+
+
+using float2 = std::array<float,2>;
+using ubyte = unsigned char;
+using ubyte2 = std::array<ubyte,2>;
+using ushort = unsigned short;
+using uint = unsigned int;
+using uint2 = std::array<uint,2>;
+
+constexpr uint HrtfHistoryBits{6};
+constexpr uint HrtfHistoryLength{1 << HrtfHistoryBits};
+constexpr uint HrtfHistoryMask{HrtfHistoryLength - 1};
+
+constexpr uint HrirBits{7};
+constexpr uint HrirLength{1 << HrirBits};
+constexpr uint HrirMask{HrirLength - 1};
+
+constexpr uint MinIrLength{8};
+
+using HrirArray = std::array<float2,HrirLength>;
+using HrirSpan = al::span<float2,HrirLength>;
+using ConstHrirSpan = al::span<const float2,HrirLength>;
+
+struct MixHrtfFilter {
+    const ConstHrirSpan Coeffs;
+    uint2 Delay;
+    float Gain;
+    float GainStep;
+};
+
+struct HrtfFilter {
+    alignas(16) HrirArray Coeffs;
+    uint2 Delay;
+    float Gain;
+};
+
+
+struct HrtfChannelState {
+    BandSplitter mSplitter;
+    float mHfScale{};
+    alignas(16) HrirArray mCoeffs{};
+};
+
+#endif /* CORE_MIXER_HRTFDEFS_H */
diff --git a/core/mixer/mixer_c.cpp b/core/mixer/mixer_c.cpp
new file mode 100644
index 00000000..28a92ef7
--- /dev/null
+++ b/core/mixer/mixer_c.cpp
@@ -0,0 +1,218 @@
+#include "config.h"
+
+#include <cassert>
+#include <cmath>
+#include <limits>
+
+#include "alnumeric.h"
+#include "core/bsinc_defs.h"
+#include "core/cubic_defs.h"
+#include "defs.h"
+#include "hrtfbase.h"
+
+struct CTag;
+struct PointTag;
+struct LerpTag;
+struct CubicTag;
+struct BSincTag;
+struct FastBSincTag;
+
+
+namespace {
+
+constexpr uint BsincPhaseDiffBits{MixerFracBits - BSincPhaseBits};
+constexpr uint BsincPhaseDiffOne{1 << BsincPhaseDiffBits};
+constexpr uint BsincPhaseDiffMask{BsincPhaseDiffOne - 1u};
+
+constexpr uint CubicPhaseDiffBits{MixerFracBits - CubicPhaseBits};
+constexpr uint CubicPhaseDiffOne{1 << CubicPhaseDiffBits};
+constexpr uint CubicPhaseDiffMask{CubicPhaseDiffOne - 1u};
+
+inline float do_point(const InterpState&, const float *RESTRICT vals, const uint)
+{ return vals[0]; }
+inline float do_lerp(const InterpState&, const float *RESTRICT vals, const uint frac)
+{ return lerpf(vals[0], vals[1], static_cast<float>(frac)*(1.0f/MixerFracOne)); }
+inline float do_cubic(const InterpState &istate, const float *RESTRICT vals, const uint frac)
+{
+    /* Calculate the phase index and factor. */
+    const uint pi{frac >> CubicPhaseDiffBits};
+    const float pf{static_cast<float>(frac&CubicPhaseDiffMask) * (1.0f/CubicPhaseDiffOne)};
+
+    const float *RESTRICT fil{al::assume_aligned<16>(istate.cubic.filter[pi].mCoeffs)};
+    const float *RESTRICT phd{al::assume_aligned<16>(istate.cubic.filter[pi].mDeltas)};
+
+    /* Apply the phase interpolated filter. */
+    return (fil[0] + pf*phd[0])*vals[0] + (fil[1] + pf*phd[1])*vals[1]
+        + (fil[2] + pf*phd[2])*vals[2] + (fil[3] + pf*phd[3])*vals[3];
+}
+inline float do_bsinc(const InterpState &istate, const float *RESTRICT vals, const uint frac)
+{
+    const size_t m{istate.bsinc.m};
+    ASSUME(m > 0);
+
+    /* Calculate the phase index and factor. */
+    const uint pi{frac >> BsincPhaseDiffBits};
+    const float pf{static_cast<float>(frac&BsincPhaseDiffMask) * (1.0f/BsincPhaseDiffOne)};
+
+    const float *RESTRICT fil{istate.bsinc.filter + m*pi*2};
+    const float *RESTRICT phd{fil + m};
+    const float *RESTRICT scd{fil + BSincPhaseCount*2*m};
+    const float *RESTRICT spd{scd + m};
+
+    /* Apply the scale and phase interpolated filter. */
+    float r{0.0f};
+    for(size_t j_f{0};j_f < m;j_f++)
+        r += (fil[j_f] + istate.bsinc.sf*scd[j_f] + pf*(phd[j_f] + istate.bsinc.sf*spd[j_f])) * vals[j_f];
+    return r;
+}
+inline float do_fastbsinc(const InterpState &istate, const float *RESTRICT vals, const uint frac)
+{
+    const size_t m{istate.bsinc.m};
+    ASSUME(m > 0);
+
+    /* Calculate the phase index and factor. */
+    const uint pi{frac >> BsincPhaseDiffBits};
+    const float pf{static_cast<float>(frac&BsincPhaseDiffMask) * (1.0f/BsincPhaseDiffOne)};
+
+    const float *RESTRICT fil{istate.bsinc.filter + m*pi*2};
+    const float *RESTRICT phd{fil + m};
+
+    /* Apply the phase interpolated filter. */
+    float r{0.0f};
+    for(size_t j_f{0};j_f < m;j_f++)
+        r += (fil[j_f] + pf*phd[j_f]) * vals[j_f];
+    return r;
+}
+
+using SamplerT = float(&)(const InterpState&, const float*RESTRICT, const uint);
+template<SamplerT Sampler>
+void DoResample(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    const InterpState istate{*state};
+    ASSUME(frac < MixerFracOne);
+    for(float &out : dst)
+    {
+        out = Sampler(istate, src, frac);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+inline void ApplyCoeffs(float2 *RESTRICT Values, const size_t IrSize, const ConstHrirSpan Coeffs,
+    const float left, const float right)
+{
+    ASSUME(IrSize >= MinIrLength);
+    for(size_t c{0};c < IrSize;++c)
+    {
+        Values[c][0] += Coeffs[c][0] * left;
+        Values[c][1] += Coeffs[c][1] * right;
+    }
+}
+
+force_inline void MixLine(const al::span<const float> InSamples, float *RESTRICT dst,
+    float &CurrentGain, const float TargetGain, const float delta, const size_t min_len,
+    size_t Counter)
+{
+    float gain{CurrentGain};
+    const float step{(TargetGain-gain) * delta};
+
+    size_t pos{0};
+    if(!(std::abs(step) > std::numeric_limits<float>::epsilon()))
+        gain = TargetGain;
+    else
+    {
+        float step_count{0.0f};
+        for(;pos != min_len;++pos)
+        {
+            dst[pos] += InSamples[pos] * (gain + step*step_count);
+            step_count += 1.0f;
+        }
+        if(pos == Counter)
+            gain = TargetGain;
+        else
+            gain += step*step_count;
+    }
+    CurrentGain = gain;
+
+    if(!(std::abs(gain) > GainSilenceThreshold))
+        return;
+    for(;pos != InSamples.size();++pos)
+        dst[pos] += InSamples[pos] * gain;
+}
+
+} // namespace
+
+template<>
+void Resample_<PointTag,CTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{ DoResample<do_point>(state, src, frac, increment, dst); }
+
+template<>
+void Resample_<LerpTag,CTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{ DoResample<do_lerp>(state, src, frac, increment, dst); }
+
+template<>
+void Resample_<CubicTag,CTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{ DoResample<do_cubic>(state, src-1, frac, increment, dst); }
+
+template<>
+void Resample_<BSincTag,CTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{ DoResample<do_bsinc>(state, src-state->bsinc.l, frac, increment, dst); }
+
+template<>
+void Resample_<FastBSincTag,CTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{ DoResample<do_fastbsinc>(state, src-state->bsinc.l, frac, increment, dst); }
+
+
+template<>
+void MixHrtf_<CTag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize)
+{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
+
+template<>
+void MixHrtfBlend_<CTag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const HrtfFilter *oldparams, const MixHrtfFilter *newparams, const size_t BufferSize)
+{
+    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
+        BufferSize);
+}
+
+template<>
+void MixDirectHrtf_<CTag>(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples,
+    float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize)
+{
+    MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, TempBuf, ChanState,
+        IrSize, BufferSize);
+}
+
+
+template<>
+void Mix_<CTag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
+    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+
+    for(FloatBufferLine &output : OutBuffer)
+        MixLine(InSamples, al::assume_aligned<16>(output.data()+OutPos), *CurrentGains++,
+            *TargetGains++, delta, min_len, Counter);
+}
+
+template<>
+void Mix_<CTag>(const al::span<const float> InSamples, float *OutBuffer, float &CurrentGain,
+    const float TargetGain, const size_t Counter)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+
+    MixLine(InSamples, al::assume_aligned<16>(OutBuffer), CurrentGain,
+        TargetGain, delta, min_len, Counter);
+}
diff --git a/core/mixer/mixer_neon.cpp b/core/mixer/mixer_neon.cpp
new file mode 100644
index 00000000..ef2936b3
--- /dev/null
+++ b/core/mixer/mixer_neon.cpp
@@ -0,0 +1,362 @@
+#include "config.h"
+
+#include <arm_neon.h>
+
+#include <cmath>
+#include <limits>
+
+#include "alnumeric.h"
+#include "core/bsinc_defs.h"
+#include "core/cubic_defs.h"
+#include "defs.h"
+#include "hrtfbase.h"
+
+struct NEONTag;
+struct LerpTag;
+struct CubicTag;
+struct BSincTag;
+struct FastBSincTag;
+
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ARM_NEON)
+#pragma GCC target("fpu=neon")
+#endif
+
+namespace {
+
+constexpr uint BSincPhaseDiffBits{MixerFracBits - BSincPhaseBits};
+constexpr uint BSincPhaseDiffOne{1 << BSincPhaseDiffBits};
+constexpr uint BSincPhaseDiffMask{BSincPhaseDiffOne - 1u};
+
+constexpr uint CubicPhaseDiffBits{MixerFracBits - CubicPhaseBits};
+constexpr uint CubicPhaseDiffOne{1 << CubicPhaseDiffBits};
+constexpr uint CubicPhaseDiffMask{CubicPhaseDiffOne - 1u};
+
+inline float32x4_t set_f4(float l0, float l1, float l2, float l3)
+{
+    float32x4_t ret{vmovq_n_f32(l0)};
+    ret = vsetq_lane_f32(l1, ret, 1);
+    ret = vsetq_lane_f32(l2, ret, 2);
+    ret = vsetq_lane_f32(l3, ret, 3);
+    return ret;
+}
+
+inline void ApplyCoeffs(float2 *RESTRICT Values, const size_t IrSize, const ConstHrirSpan Coeffs,
+    const float left, const float right)
+{
+    float32x4_t leftright4;
+    {
+        float32x2_t leftright2{vmov_n_f32(left)};
+        leftright2 = vset_lane_f32(right, leftright2, 1);
+        leftright4 = vcombine_f32(leftright2, leftright2);
+    }
+
+    ASSUME(IrSize >= MinIrLength);
+    for(size_t c{0};c < IrSize;c += 2)
+    {
+        float32x4_t vals = vld1q_f32(&Values[c][0]);
+        float32x4_t coefs = vld1q_f32(&Coeffs[c][0]);
+
+        vals = vmlaq_f32(vals, coefs, leftright4);
+
+        vst1q_f32(&Values[c][0], vals);
+    }
+}
+
+force_inline void MixLine(const al::span<const float> InSamples, float *RESTRICT dst,
+    float &CurrentGain, const float TargetGain, const float delta, const size_t min_len,
+    const size_t aligned_len, size_t Counter)
+{
+    float gain{CurrentGain};
+    const float step{(TargetGain-gain) * delta};
+
+    size_t pos{0};
+    if(!(std::abs(step) > std::numeric_limits<float>::epsilon()))
+        gain = TargetGain;
+    else
+    {
+        float step_count{0.0f};
+        /* Mix with applying gain steps in aligned multiples of 4. */
+        if(size_t todo{min_len >> 2})
+        {
+            const float32x4_t four4{vdupq_n_f32(4.0f)};
+            const float32x4_t step4{vdupq_n_f32(step)};
+            const float32x4_t gain4{vdupq_n_f32(gain)};
+            float32x4_t step_count4{vdupq_n_f32(0.0f)};
+            step_count4 = vsetq_lane_f32(1.0f, step_count4, 1);
+            step_count4 = vsetq_lane_f32(2.0f, step_count4, 2);
+            step_count4 = vsetq_lane_f32(3.0f, step_count4, 3);
+
+            do {
+                const float32x4_t val4 = vld1q_f32(&InSamples[pos]);
+                float32x4_t dry4 = vld1q_f32(&dst[pos]);
+                dry4 = vmlaq_f32(dry4, val4, vmlaq_f32(gain4, step4, step_count4));
+                step_count4 = vaddq_f32(step_count4, four4);
+                vst1q_f32(&dst[pos], dry4);
+                pos += 4;
+            } while(--todo);
+            /* NOTE: step_count4 now represents the next four counts after the
+             * last four mixed samples, so the lowest element represents the
+             * next step count to apply.
+             */
+            step_count = vgetq_lane_f32(step_count4, 0);
+        }
+        /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
+        for(size_t leftover{min_len&3};leftover;++pos,--leftover)
+        {
+            dst[pos] += InSamples[pos] * (gain + step*step_count);
+            step_count += 1.0f;
+        }
+        if(pos == Counter)
+            gain = TargetGain;
+        else
+            gain += step*step_count;
+
+        /* Mix until pos is aligned with 4 or the mix is done. */
+        for(size_t leftover{aligned_len&3};leftover;++pos,--leftover)
+            dst[pos] += InSamples[pos] * gain;
+    }
+    CurrentGain = gain;
+
+    if(!(std::abs(gain) > GainSilenceThreshold))
+        return;
+    if(size_t todo{(InSamples.size()-pos) >> 2})
+    {
+        const float32x4_t gain4 = vdupq_n_f32(gain);
+        do {
+            const float32x4_t val4 = vld1q_f32(&InSamples[pos]);
+            float32x4_t dry4 = vld1q_f32(&dst[pos]);
+            dry4 = vmlaq_f32(dry4, val4, gain4);
+            vst1q_f32(&dst[pos], dry4);
+            pos += 4;
+        } while(--todo);
+    }
+    for(size_t leftover{(InSamples.size()-pos)&3};leftover;++pos,--leftover)
+        dst[pos] += InSamples[pos] * gain;
+}
+
+} // namespace
+
+template<>
+void Resample_<LerpTag,NEONTag>(const InterpState*, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    ASSUME(frac < MixerFracOne);
+
+    const int32x4_t increment4 = vdupq_n_s32(static_cast<int>(increment*4));
+    const float32x4_t fracOne4 = vdupq_n_f32(1.0f/MixerFracOne);
+    const int32x4_t fracMask4 = vdupq_n_s32(MixerFracMask);
+    alignas(16) uint pos_[4], frac_[4];
+    int32x4_t pos4, frac4;
+
+    InitPosArrays(frac, increment, frac_, pos_);
+    frac4 = vld1q_s32(reinterpret_cast<int*>(frac_));
+    pos4 = vld1q_s32(reinterpret_cast<int*>(pos_));
+
+    auto dst_iter = dst.begin();
+    for(size_t todo{dst.size()>>2};todo;--todo)
+    {
+        const int pos0{vgetq_lane_s32(pos4, 0)};
+        const int pos1{vgetq_lane_s32(pos4, 1)};
+        const int pos2{vgetq_lane_s32(pos4, 2)};
+        const int pos3{vgetq_lane_s32(pos4, 3)};
+        const float32x4_t val1{set_f4(src[pos0], src[pos1], src[pos2], src[pos3])};
+        const float32x4_t val2{set_f4(src[pos0+1], src[pos1+1], src[pos2+1], src[pos3+1])};
+
+        /* val1 + (val2-val1)*mu */
+        const float32x4_t r0{vsubq_f32(val2, val1)};
+        const float32x4_t mu{vmulq_f32(vcvtq_f32_s32(frac4), fracOne4)};
+        const float32x4_t out{vmlaq_f32(val1, mu, r0)};
+
+        vst1q_f32(dst_iter, out);
+        dst_iter += 4;
+
+        frac4 = vaddq_s32(frac4, increment4);
+        pos4 = vaddq_s32(pos4, vshrq_n_s32(frac4, MixerFracBits));
+        frac4 = vandq_s32(frac4, fracMask4);
+    }
+
+    if(size_t todo{dst.size()&3})
+    {
+        src += static_cast<uint>(vgetq_lane_s32(pos4, 0));
+        frac = static_cast<uint>(vgetq_lane_s32(frac4, 0));
+
+        do {
+            *(dst_iter++) = lerpf(src[0], src[1], static_cast<float>(frac) * (1.0f/MixerFracOne));
+
+            frac += increment;
+            src  += frac>>MixerFracBits;
+            frac &= MixerFracMask;
+        } while(--todo);
+    }
+}
+
+template<>
+void Resample_<CubicTag,NEONTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    ASSUME(frac < MixerFracOne);
+
+    const CubicCoefficients *RESTRICT filter = al::assume_aligned<16>(state->cubic.filter);
+
+    src -= 1;
+    for(float &out_sample : dst)
+    {
+        const uint pi{frac >> CubicPhaseDiffBits};
+        const float pf{static_cast<float>(frac&CubicPhaseDiffMask) * (1.0f/CubicPhaseDiffOne)};
+        const float32x4_t pf4{vdupq_n_f32(pf)};
+
+        /* Apply the phase interpolated filter. */
+
+        /* f = fil + pf*phd */
+        const float32x4_t f4 = vmlaq_f32(vld1q_f32(filter[pi].mCoeffs), pf4,
+            vld1q_f32(filter[pi].mDeltas));
+        /* r = f*src */
+        float32x4_t r4{vmulq_f32(f4, vld1q_f32(src))};
+
+        r4 = vaddq_f32(r4, vrev64q_f32(r4));
+        out_sample = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+template<>
+void Resample_<BSincTag,NEONTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    const float *const filter{state->bsinc.filter};
+    const float32x4_t sf4{vdupq_n_f32(state->bsinc.sf)};
+    const size_t m{state->bsinc.m};
+    ASSUME(m > 0);
+    ASSUME(frac < MixerFracOne);
+
+    src -= state->bsinc.l;
+    for(float &out_sample : dst)
+    {
+        // Calculate the phase index and factor.
+        const uint pi{frac >> BSincPhaseDiffBits};
+        const float pf{static_cast<float>(frac&BSincPhaseDiffMask) * (1.0f/BSincPhaseDiffOne)};
+
+        // Apply the scale and phase interpolated filter.
+        float32x4_t r4{vdupq_n_f32(0.0f)};
+        {
+            const float32x4_t pf4{vdupq_n_f32(pf)};
+            const float *RESTRICT fil{filter + m*pi*2};
+            const float *RESTRICT phd{fil + m};
+            const float *RESTRICT scd{fil + BSincPhaseCount*2*m};
+            const float *RESTRICT spd{scd + m};
+            size_t td{m >> 2};
+            size_t j{0u};
+
+            do {
+                /* f = ((fil + sf*scd) + pf*(phd + sf*spd)) */
+                const float32x4_t f4 = vmlaq_f32(
+                    vmlaq_f32(vld1q_f32(&fil[j]), sf4, vld1q_f32(&scd[j])),
+                    pf4, vmlaq_f32(vld1q_f32(&phd[j]), sf4, vld1q_f32(&spd[j])));
+                /* r += f*src */
+                r4 = vmlaq_f32(r4, f4, vld1q_f32(&src[j]));
+                j += 4;
+            } while(--td);
+        }
+        r4 = vaddq_f32(r4, vrev64q_f32(r4));
+        out_sample = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+template<>
+void Resample_<FastBSincTag,NEONTag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    const float *const filter{state->bsinc.filter};
+    const size_t m{state->bsinc.m};
+    ASSUME(m > 0);
+    ASSUME(frac < MixerFracOne);
+
+    src -= state->bsinc.l;
+    for(float &out_sample : dst)
+    {
+        // Calculate the phase index and factor.
+        const uint pi{frac >> BSincPhaseDiffBits};
+        const float pf{static_cast<float>(frac&BSincPhaseDiffMask) * (1.0f/BSincPhaseDiffOne)};
+
+        // Apply the phase interpolated filter.
+        float32x4_t r4{vdupq_n_f32(0.0f)};
+        {
+            const float32x4_t pf4{vdupq_n_f32(pf)};
+            const float *RESTRICT fil{filter + m*pi*2};
+            const float *RESTRICT phd{fil + m};
+            size_t td{m >> 2};
+            size_t j{0u};
+
+            do {
+                /* f = fil + pf*phd */
+                const float32x4_t f4 = vmlaq_f32(vld1q_f32(&fil[j]), pf4, vld1q_f32(&phd[j]));
+                /* r += f*src */
+                r4 = vmlaq_f32(r4, f4, vld1q_f32(&src[j]));
+                j += 4;
+            } while(--td);
+        }
+        r4 = vaddq_f32(r4, vrev64q_f32(r4));
+        out_sample = vget_lane_f32(vadd_f32(vget_low_f32(r4), vget_high_f32(r4)), 0);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+
+template<>
+void MixHrtf_<NEONTag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize)
+{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
+
+template<>
+void MixHrtfBlend_<NEONTag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const HrtfFilter *oldparams, const MixHrtfFilter *newparams, const size_t BufferSize)
+{
+    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
+        BufferSize);
+}
+
+template<>
+void MixDirectHrtf_<NEONTag>(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples,
+    float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize)
+{
+    MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, TempBuf, ChanState,
+        IrSize, BufferSize);
+}
+
+
+template<>
+void Mix_<NEONTag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
+    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+    const auto aligned_len = minz((min_len+3) & ~size_t{3}, InSamples.size()) - min_len;
+
+    for(FloatBufferLine &output : OutBuffer)
+        MixLine(InSamples, al::assume_aligned<16>(output.data()+OutPos), *CurrentGains++,
+            *TargetGains++, delta, min_len, aligned_len, Counter);
+}
+
+template<>
+void Mix_<NEONTag>(const al::span<const float> InSamples, float *OutBuffer, float &CurrentGain,
+    const float TargetGain, const size_t Counter)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+    const auto aligned_len = minz((min_len+3) & ~size_t{3}, InSamples.size()) - min_len;
+
+    MixLine(InSamples, al::assume_aligned<16>(OutBuffer), CurrentGain, TargetGain, delta, min_len,
+        aligned_len, Counter);
+}
diff --git a/core/mixer/mixer_sse.cpp b/core/mixer/mixer_sse.cpp
new file mode 100644
index 00000000..0aa5d5fb
--- /dev/null
+++ b/core/mixer/mixer_sse.cpp
@@ -0,0 +1,327 @@
+#include "config.h"
+
+#include <xmmintrin.h>
+
+#include <cmath>
+#include <limits>
+
+#include "alnumeric.h"
+#include "core/bsinc_defs.h"
+#include "core/cubic_defs.h"
+#include "defs.h"
+#include "hrtfbase.h"
+
+struct SSETag;
+struct CubicTag;
+struct BSincTag;
+struct FastBSincTag;
+
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__SSE__)
+#pragma GCC target("sse")
+#endif
+
+namespace {
+
+constexpr uint BSincPhaseDiffBits{MixerFracBits - BSincPhaseBits};
+constexpr uint BSincPhaseDiffOne{1 << BSincPhaseDiffBits};
+constexpr uint BSincPhaseDiffMask{BSincPhaseDiffOne - 1u};
+
+constexpr uint CubicPhaseDiffBits{MixerFracBits - CubicPhaseBits};
+constexpr uint CubicPhaseDiffOne{1 << CubicPhaseDiffBits};
+constexpr uint CubicPhaseDiffMask{CubicPhaseDiffOne - 1u};
+
+#define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z))
+
+inline void ApplyCoeffs(float2 *RESTRICT Values, const size_t IrSize, const ConstHrirSpan Coeffs,
+    const float left, const float right)
+{
+    const __m128 lrlr{_mm_setr_ps(left, right, left, right)};
+
+    ASSUME(IrSize >= MinIrLength);
+    /* This isn't technically correct to test alignment, but it's true for
+     * systems that support SSE, which is the only one that needs to know the
+     * alignment of Values (which alternates between 8- and 16-byte aligned).
+     */
+    if(!(reinterpret_cast<uintptr_t>(Values)&15))
+    {
+        for(size_t i{0};i < IrSize;i += 2)
+        {
+            const __m128 coeffs{_mm_load_ps(Coeffs[i].data())};
+            __m128 vals{_mm_load_ps(Values[i].data())};
+            vals = MLA4(vals, lrlr, coeffs);
+            _mm_store_ps(Values[i].data(), vals);
+        }
+    }
+    else
+    {
+        __m128 imp0, imp1;
+        __m128 coeffs{_mm_load_ps(Coeffs[0].data())};
+        __m128 vals{_mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64*>(Values[0].data()))};
+        imp0 = _mm_mul_ps(lrlr, coeffs);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_storel_pi(reinterpret_cast<__m64*>(Values[0].data()), vals);
+        size_t td{((IrSize+1)>>1) - 1};
+        size_t i{1};
+        do {
+            coeffs = _mm_load_ps(Coeffs[i+1].data());
+            vals = _mm_load_ps(Values[i].data());
+            imp1 = _mm_mul_ps(lrlr, coeffs);
+            imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
+            vals = _mm_add_ps(imp0, vals);
+            _mm_store_ps(Values[i].data(), vals);
+            imp0 = imp1;
+            i += 2;
+        } while(--td);
+        vals = _mm_loadl_pi(vals, reinterpret_cast<__m64*>(Values[i].data()));
+        imp0 = _mm_movehl_ps(imp0, imp0);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_storel_pi(reinterpret_cast<__m64*>(Values[i].data()), vals);
+    }
+}
+
+force_inline void MixLine(const al::span<const float> InSamples, float *RESTRICT dst,
+    float &CurrentGain, const float TargetGain, const float delta, const size_t min_len,
+    const size_t aligned_len, size_t Counter)
+{
+    float gain{CurrentGain};
+    const float step{(TargetGain-gain) * delta};
+
+    size_t pos{0};
+    if(!(std::abs(step) > std::numeric_limits<float>::epsilon()))
+        gain = TargetGain;
+    else
+    {
+        float step_count{0.0f};
+        /* Mix with applying gain steps in aligned multiples of 4. */
+        if(size_t todo{min_len >> 2})
+        {
+            const __m128 four4{_mm_set1_ps(4.0f)};
+            const __m128 step4{_mm_set1_ps(step)};
+            const __m128 gain4{_mm_set1_ps(gain)};
+            __m128 step_count4{_mm_setr_ps(0.0f, 1.0f, 2.0f, 3.0f)};
+            do {
+                const __m128 val4{_mm_load_ps(&InSamples[pos])};
+                __m128 dry4{_mm_load_ps(&dst[pos])};
+
+                /* dry += val * (gain + step*step_count) */
+                dry4 = MLA4(dry4, val4, MLA4(gain4, step4, step_count4));
+
+                _mm_store_ps(&dst[pos], dry4);
+                step_count4 = _mm_add_ps(step_count4, four4);
+                pos += 4;
+            } while(--todo);
+            /* NOTE: step_count4 now represents the next four counts after the
+             * last four mixed samples, so the lowest element represents the
+             * next step count to apply.
+             */
+            step_count = _mm_cvtss_f32(step_count4);
+        }
+        /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
+        for(size_t leftover{min_len&3};leftover;++pos,--leftover)
+        {
+            dst[pos] += InSamples[pos] * (gain + step*step_count);
+            step_count += 1.0f;
+        }
+        if(pos == Counter)
+            gain = TargetGain;
+        else
+            gain += step*step_count;
+
+        /* Mix until pos is aligned with 4 or the mix is done. */
+        for(size_t leftover{aligned_len&3};leftover;++pos,--leftover)
+            dst[pos] += InSamples[pos] * gain;
+    }
+    CurrentGain = gain;
+
+    if(!(std::abs(gain) > GainSilenceThreshold))
+        return;
+    if(size_t todo{(InSamples.size()-pos) >> 2})
+    {
+        const __m128 gain4{_mm_set1_ps(gain)};
+        do {
+            const __m128 val4{_mm_load_ps(&InSamples[pos])};
+            __m128 dry4{_mm_load_ps(&dst[pos])};
+            dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
+            _mm_store_ps(&dst[pos], dry4);
+            pos += 4;
+        } while(--todo);
+    }
+    for(size_t leftover{(InSamples.size()-pos)&3};leftover;++pos,--leftover)
+        dst[pos] += InSamples[pos] * gain;
+}
+
+} // namespace
+
+template<>
+void Resample_<CubicTag,SSETag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    ASSUME(frac < MixerFracOne);
+
+    const CubicCoefficients *RESTRICT filter = al::assume_aligned<16>(state->cubic.filter);
+
+    src -= 1;
+    for(float &out_sample : dst)
+    {
+        const uint pi{frac >> CubicPhaseDiffBits};
+        const float pf{static_cast<float>(frac&CubicPhaseDiffMask) * (1.0f/CubicPhaseDiffOne)};
+        const __m128 pf4{_mm_set1_ps(pf)};
+
+        /* Apply the phase interpolated filter. */
+
+        /* f = fil + pf*phd */
+        const __m128 f4 = MLA4(_mm_load_ps(filter[pi].mCoeffs), pf4,
+            _mm_load_ps(filter[pi].mDeltas));
+        /* r = f*src */
+        __m128 r4{_mm_mul_ps(f4, _mm_loadu_ps(src))};
+
+        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
+        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+        out_sample = _mm_cvtss_f32(r4);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+template<>
+void Resample_<BSincTag,SSETag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    const float *const filter{state->bsinc.filter};
+    const __m128 sf4{_mm_set1_ps(state->bsinc.sf)};
+    const size_t m{state->bsinc.m};
+    ASSUME(m > 0);
+    ASSUME(frac < MixerFracOne);
+
+    src -= state->bsinc.l;
+    for(float &out_sample : dst)
+    {
+        // Calculate the phase index and factor.
+        const uint pi{frac >> BSincPhaseDiffBits};
+        const float pf{static_cast<float>(frac&BSincPhaseDiffMask) * (1.0f/BSincPhaseDiffOne)};
+
+        // Apply the scale and phase interpolated filter.
+        __m128 r4{_mm_setzero_ps()};
+        {
+            const __m128 pf4{_mm_set1_ps(pf)};
+            const float *RESTRICT fil{filter + m*pi*2};
+            const float *RESTRICT phd{fil + m};
+            const float *RESTRICT scd{fil + BSincPhaseCount*2*m};
+            const float *RESTRICT spd{scd + m};
+            size_t td{m >> 2};
+            size_t j{0u};
+
+            do {
+                /* f = ((fil + sf*scd) + pf*(phd + sf*spd)) */
+                const __m128 f4 = MLA4(
+                    MLA4(_mm_load_ps(&fil[j]), sf4, _mm_load_ps(&scd[j])),
+                    pf4, MLA4(_mm_load_ps(&phd[j]), sf4, _mm_load_ps(&spd[j])));
+                /* r += f*src */
+                r4 = MLA4(r4, f4, _mm_loadu_ps(&src[j]));
+                j += 4;
+            } while(--td);
+        }
+        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
+        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+        out_sample = _mm_cvtss_f32(r4);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+template<>
+void Resample_<FastBSincTag,SSETag>(const InterpState *state, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
+{
+    const float *const filter{state->bsinc.filter};
+    const size_t m{state->bsinc.m};
+    ASSUME(m > 0);
+    ASSUME(frac < MixerFracOne);
+
+    src -= state->bsinc.l;
+    for(float &out_sample : dst)
+    {
+        // Calculate the phase index and factor.
+        const uint pi{frac >> BSincPhaseDiffBits};
+        const float pf{static_cast<float>(frac&BSincPhaseDiffMask) * (1.0f/BSincPhaseDiffOne)};
+
+        // Apply the phase interpolated filter.
+        __m128 r4{_mm_setzero_ps()};
+        {
+            const __m128 pf4{_mm_set1_ps(pf)};
+            const float *RESTRICT fil{filter + m*pi*2};
+            const float *RESTRICT phd{fil + m};
+            size_t td{m >> 2};
+            size_t j{0u};
+
+            do {
+                /* f = fil + pf*phd */
+                const __m128 f4 = MLA4(_mm_load_ps(&fil[j]), pf4, _mm_load_ps(&phd[j]));
+                /* r += f*src */
+                r4 = MLA4(r4, f4, _mm_loadu_ps(&src[j]));
+                j += 4;
+            } while(--td);
+        }
+        r4 = _mm_add_ps(r4, _mm_shuffle_ps(r4, r4, _MM_SHUFFLE(0, 1, 2, 3)));
+        r4 = _mm_add_ps(r4, _mm_movehl_ps(r4, r4));
+        out_sample = _mm_cvtss_f32(r4);
+
+        frac += increment;
+        src  += frac>>MixerFracBits;
+        frac &= MixerFracMask;
+    }
+}
+
+
+template<>
+void MixHrtf_<SSETag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize)
+{ MixHrtfBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); }
+
+template<>
+void MixHrtfBlend_<SSETag>(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const HrtfFilter *oldparams, const MixHrtfFilter *newparams, const size_t BufferSize)
+{
+    MixHrtfBlendBase<ApplyCoeffs>(InSamples, AccumSamples, IrSize, oldparams, newparams,
+        BufferSize);
+}
+
+template<>
+void MixDirectHrtf_<SSETag>(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples,
+    float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize)
+{
+    MixDirectHrtfBase<ApplyCoeffs>(LeftOut, RightOut, InSamples, AccumSamples, TempBuf, ChanState,
+        IrSize, BufferSize);
+}
+
+
+template<>
+void Mix_<SSETag>(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutBuffer,
+    float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+    const auto aligned_len = minz((min_len+3) & ~size_t{3}, InSamples.size()) - min_len;
+
+    for(FloatBufferLine &output : OutBuffer)
+        MixLine(InSamples, al::assume_aligned<16>(output.data()+OutPos), *CurrentGains++,
+            *TargetGains++, delta, min_len, aligned_len, Counter);
+}
+
+template<>
+void Mix_<SSETag>(const al::span<const float> InSamples, float *OutBuffer, float &CurrentGain,
+    const float TargetGain, const size_t Counter)
+{
+    const float delta{(Counter > 0) ? 1.0f / static_cast<float>(Counter) : 0.0f};
+    const auto min_len = minz(Counter, InSamples.size());
+    const auto aligned_len = minz((min_len+3) & ~size_t{3}, InSamples.size()) - min_len;
+
+    MixLine(InSamples, al::assume_aligned<16>(OutBuffer), CurrentGain, TargetGain, delta, min_len,
+        aligned_len, Counter);
+}
diff --git a/alc/mixer/mixer_sse2.cpp b/core/mixer/mixer_sse2.cpp
index 897cd1f7..edaaf7a1 100644
--- a/alc/mixer/mixer_sse2.cpp
+++ b/core/mixer/mixer_sse2.cpp
@@ -23,33 +23,41 @@
 #include <xmmintrin.h>
 #include <emmintrin.h>
 
-#include "alu.h"
+#include "alnumeric.h"
 #include "defs.h"
 
+struct SSE2Tag;
+struct LerpTag;
+
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__SSE2__)
+#pragma GCC target("sse2")
+#endif
 
 template<>
-const ALfloat *Resample_<LerpTag,SSE2Tag>(const InterpState*, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
+void Resample_<LerpTag,SSE2Tag>(const InterpState*, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
 {
+    ASSUME(frac < MixerFracOne);
+
     const __m128i increment4{_mm_set1_epi32(static_cast<int>(increment*4))};
-    const __m128 fracOne4{_mm_set1_ps(1.0f/FRACTIONONE)};
-    const __m128i fracMask4{_mm_set1_epi32(FRACTIONMASK)};
+    const __m128 fracOne4{_mm_set1_ps(1.0f/MixerFracOne)};
+    const __m128i fracMask4{_mm_set1_epi32(MixerFracMask)};
 
-    alignas(16) ALuint pos_[4], frac_[4];
-    InitPosArrays(frac, increment, frac_, pos_, 4);
+    alignas(16) uint pos_[4], frac_[4];
+    InitPosArrays(frac, increment, frac_, pos_);
     __m128i frac4{_mm_setr_epi32(static_cast<int>(frac_[0]), static_cast<int>(frac_[1]),
         static_cast<int>(frac_[2]), static_cast<int>(frac_[3]))};
     __m128i pos4{_mm_setr_epi32(static_cast<int>(pos_[0]), static_cast<int>(pos_[1]),
         static_cast<int>(pos_[2]), static_cast<int>(pos_[3]))};
 
     auto dst_iter = dst.begin();
-    const auto aligned_end = (dst.size()&~3u) + dst_iter;
-    while(dst_iter != aligned_end)
+    for(size_t todo{dst.size()>>2};todo;--todo)
     {
-        const int pos0{_mm_cvtsi128_si32(_mm_shuffle_epi32(pos4, _MM_SHUFFLE(0, 0, 0, 0)))};
-        const int pos1{_mm_cvtsi128_si32(_mm_shuffle_epi32(pos4, _MM_SHUFFLE(1, 1, 1, 1)))};
-        const int pos2{_mm_cvtsi128_si32(_mm_shuffle_epi32(pos4, _MM_SHUFFLE(2, 2, 2, 2)))};
-        const int pos3{_mm_cvtsi128_si32(_mm_shuffle_epi32(pos4, _MM_SHUFFLE(3, 3, 3, 3)))};
+        const int pos0{_mm_cvtsi128_si32(pos4)};
+        const int pos1{_mm_cvtsi128_si32(_mm_srli_si128(pos4, 4))};
+        const int pos2{_mm_cvtsi128_si32(_mm_srli_si128(pos4, 8))};
+        const int pos3{_mm_cvtsi128_si32(_mm_srli_si128(pos4, 12))};
         const __m128 val1{_mm_setr_ps(src[pos0  ], src[pos1  ], src[pos2  ], src[pos3  ])};
         const __m128 val2{_mm_setr_ps(src[pos0+1], src[pos1+1], src[pos2+1], src[pos3+1])};
 
@@ -62,22 +70,21 @@ const ALfloat *Resample_<LerpTag,SSE2Tag>(const InterpState*, const ALfloat *RES
         dst_iter += 4;
 
         frac4 = _mm_add_epi32(frac4, increment4);
-        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, FRACTIONBITS));
+        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, MixerFracBits));
         frac4 = _mm_and_si128(frac4, fracMask4);
     }
 
-    if(dst_iter != dst.end())
+    if(size_t todo{dst.size()&3})
     {
-        src += static_cast<ALuint>(_mm_cvtsi128_si32(pos4));
-        frac = static_cast<ALuint>(_mm_cvtsi128_si32(frac4));
+        src += static_cast<uint>(_mm_cvtsi128_si32(pos4));
+        frac = static_cast<uint>(_mm_cvtsi128_si32(frac4));
 
         do {
-            *(dst_iter++) = lerp(src[0], src[1], static_cast<float>(frac) * (1.0f/FRACTIONONE));
+            *(dst_iter++) = lerpf(src[0], src[1], static_cast<float>(frac) * (1.0f/MixerFracOne));
 
             frac += increment;
-            src  += frac>>FRACTIONBITS;
-            frac &= FRACTIONMASK;
-        } while(dst_iter != dst.end());
+            src  += frac>>MixerFracBits;
+            frac &= MixerFracMask;
+        } while(--todo);
     }
-    return dst.begin();
 }
diff --git a/alc/mixer/mixer_sse3.cpp b/core/mixer/mixer_sse3.cpp
index e69de29b..e69de29b 100644
--- a/alc/mixer/mixer_sse3.cpp
+++ b/core/mixer/mixer_sse3.cpp
diff --git a/alc/mixer/mixer_sse41.cpp b/core/mixer/mixer_sse41.cpp
index cfa21e99..8ccd9fd3 100644
--- a/alc/mixer/mixer_sse41.cpp
+++ b/core/mixer/mixer_sse41.cpp
@@ -24,28 +24,36 @@
 #include <emmintrin.h>
 #include <smmintrin.h>
 
-#include "alu.h"
+#include "alnumeric.h"
 #include "defs.h"
 
+struct SSE4Tag;
+struct LerpTag;
+
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__SSE4_1__)
+#pragma GCC target("sse4.1")
+#endif
 
 template<>
-const ALfloat *Resample_<LerpTag,SSE4Tag>(const InterpState*, const ALfloat *RESTRICT src,
-    ALuint frac, ALuint increment, const al::span<float> dst)
+void Resample_<LerpTag,SSE4Tag>(const InterpState*, const float *RESTRICT src, uint frac,
+    const uint increment, const al::span<float> dst)
 {
+    ASSUME(frac < MixerFracOne);
+
     const __m128i increment4{_mm_set1_epi32(static_cast<int>(increment*4))};
-    const __m128 fracOne4{_mm_set1_ps(1.0f/FRACTIONONE)};
-    const __m128i fracMask4{_mm_set1_epi32(FRACTIONMASK)};
+    const __m128 fracOne4{_mm_set1_ps(1.0f/MixerFracOne)};
+    const __m128i fracMask4{_mm_set1_epi32(MixerFracMask)};
 
-    alignas(16) ALuint pos_[4], frac_[4];
-    InitPosArrays(frac, increment, frac_, pos_, 4);
+    alignas(16) uint pos_[4], frac_[4];
+    InitPosArrays(frac, increment, frac_, pos_);
     __m128i frac4{_mm_setr_epi32(static_cast<int>(frac_[0]), static_cast<int>(frac_[1]),
         static_cast<int>(frac_[2]), static_cast<int>(frac_[3]))};
     __m128i pos4{_mm_setr_epi32(static_cast<int>(pos_[0]), static_cast<int>(pos_[1]),
         static_cast<int>(pos_[2]), static_cast<int>(pos_[3]))};
 
     auto dst_iter = dst.begin();
-    const auto aligned_end = (dst.size()&~3u) + dst_iter;
-    while(dst_iter != aligned_end)
+    for(size_t todo{dst.size()>>2};todo;--todo)
     {
         const int pos0{_mm_extract_epi32(pos4, 0)};
         const int pos1{_mm_extract_epi32(pos4, 1)};
@@ -63,26 +71,25 @@ const ALfloat *Resample_<LerpTag,SSE4Tag>(const InterpState*, const ALfloat *RES
         dst_iter += 4;
 
         frac4 = _mm_add_epi32(frac4, increment4);
-        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, FRACTIONBITS));
+        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, MixerFracBits));
         frac4 = _mm_and_si128(frac4, fracMask4);
     }
 
-    if(dst_iter != dst.end())
+    if(size_t todo{dst.size()&3})
     {
         /* NOTE: These four elements represent the position *after* the last
          * four samples, so the lowest element is the next position to
          * resample.
          */
-        src += static_cast<ALuint>(_mm_cvtsi128_si32(pos4));
-        frac = static_cast<ALuint>(_mm_cvtsi128_si32(frac4));
+        src += static_cast<uint>(_mm_cvtsi128_si32(pos4));
+        frac = static_cast<uint>(_mm_cvtsi128_si32(frac4));
 
         do {
-            *(dst_iter++) = lerp(src[0], src[1], static_cast<float>(frac) * (1.0f/FRACTIONONE));
+            *(dst_iter++) = lerpf(src[0], src[1], static_cast<float>(frac) * (1.0f/MixerFracOne));
 
             frac += increment;
-            src  += frac>>FRACTIONBITS;
-            frac &= FRACTIONMASK;
-        } while(dst_iter != dst.end());
+            src  += frac>>MixerFracBits;
+            frac &= MixerFracMask;
+        } while(--todo);
     }
-    return dst.begin();
 }
diff --git a/core/resampler_limits.h b/core/resampler_limits.h
new file mode 100644
index 00000000..9d4cefda
--- /dev/null
+++ b/core/resampler_limits.h
@@ -0,0 +1,12 @@
+#ifndef CORE_RESAMPLER_LIMITS_H
+#define CORE_RESAMPLER_LIMITS_H
+
+/* Maximum number of samples to pad on the ends of a buffer for resampling.
+ * Note that the padding is symmetric (half at the beginning and half at the
+ * end)!
+ */
+constexpr int MaxResamplerPadding{48};
+
+constexpr int MaxResamplerEdge{MaxResamplerPadding >> 1};
+
+#endif /* CORE_RESAMPLER_LIMITS_H */
diff --git a/core/rtkit.cpp b/core/rtkit.cpp
new file mode 100644
index 00000000..ff944ebf
--- /dev/null
+++ b/core/rtkit.cpp
@@ -0,0 +1,236 @@
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+/***
+        Copyright 2009 Lennart Poettering
+        Copyright 2010 David Henningsson <[email protected]>
+        Copyright 2021 Chris Robinson
+
+        Permission is hereby granted, free of charge, to any person
+        obtaining a copy of this software and associated documentation files
+        (the "Software"), to deal in the Software without restriction,
+        including without limitation the rights to use, copy, modify, merge,
+        publish, distribute, sublicense, and/or sell copies of the Software,
+        and to permit persons to whom the Software is furnished to do so,
+        subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+        BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+        ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+        CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+***/
+
+#include "config.h"
+
+#include "rtkit.h"
+
+#include <errno.h>
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <memory>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#ifdef __linux__
+#include <sys/syscall.h>
+#elif defined(__FreeBSD__)
+#include <sys/thr.h>
+#endif
+
+
+namespace dbus {
+
+constexpr int TypeString{'s'};
+constexpr int TypeVariant{'v'};
+constexpr int TypeInt32{'i'};
+constexpr int TypeUInt32{'u'};
+constexpr int TypeInt64{'x'};
+constexpr int TypeUInt64{'t'};
+constexpr int TypeInvalid{'\0'};
+
+struct MessageDeleter {
+    void operator()(DBusMessage *m) { dbus_message_unref(m); }
+};
+using MessagePtr = std::unique_ptr<DBusMessage,MessageDeleter>;
+
+} // namespace dbus
+
+namespace {
+
+inline pid_t _gettid()
+{
+#ifdef __linux__
+    return static_cast<pid_t>(syscall(SYS_gettid));
+#elif defined(__FreeBSD__)
+    long pid{};
+    thr_self(&pid);
+    return static_cast<pid_t>(pid);
+#else
+#warning gettid not available
+    return 0;
+#endif
+}
+
+int translate_error(const char *name)
+{
+    if(strcmp(name, DBUS_ERROR_NO_MEMORY) == 0)
+        return -ENOMEM;
+    if(strcmp(name, DBUS_ERROR_SERVICE_UNKNOWN) == 0
+        || strcmp(name, DBUS_ERROR_NAME_HAS_NO_OWNER) == 0)
+        return -ENOENT;
+    if(strcmp(name, DBUS_ERROR_ACCESS_DENIED) == 0
+        || strcmp(name, DBUS_ERROR_AUTH_FAILED) == 0)
+        return -EACCES;
+    return -EIO;
+}
+
+int rtkit_get_int_property(DBusConnection *connection, const char *propname, long long *propval)
+{
+    dbus::MessagePtr m{dbus_message_new_method_call(RTKIT_SERVICE_NAME, RTKIT_OBJECT_PATH,
+        "org.freedesktop.DBus.Properties", "Get")};
+    if(!m) return -ENOMEM;
+
+    const char *interfacestr = RTKIT_SERVICE_NAME;
+    auto ready = dbus_message_append_args(m.get(),
+        dbus::TypeString, &interfacestr,
+        dbus::TypeString, &propname,
+        dbus::TypeInvalid);
+    if(!ready) return -ENOMEM;
+
+    dbus::Error error;
+    dbus::MessagePtr r{dbus_connection_send_with_reply_and_block(connection, m.get(), -1,
+        &error.get())};
+    if(!r) return translate_error(error->name);
+
+    if(dbus_set_error_from_message(&error.get(), r.get()))
+        return translate_error(error->name);
+
+    int ret{-EBADMSG};
+    DBusMessageIter iter{};
+    dbus_message_iter_init(r.get(), &iter);
+    while(int curtype{dbus_message_iter_get_arg_type(&iter)})
+    {
+        if(curtype == dbus::TypeVariant)
+        {
+            DBusMessageIter subiter{};
+            dbus_message_iter_recurse(&iter, &subiter);
+
+            while((curtype=dbus_message_iter_get_arg_type(&subiter)) != dbus::TypeInvalid)
+            {
+                if(curtype == dbus::TypeInt32)
+                {
+                    dbus_int32_t i32{};
+                    dbus_message_iter_get_basic(&subiter, &i32);
+                    *propval = i32;
+                    ret = 0;
+                }
+
+                if(curtype == dbus::TypeInt64)
+                {
+                    dbus_int64_t i64{};
+                    dbus_message_iter_get_basic(&subiter, &i64);
+                    *propval = i64;
+                    ret = 0;
+                }
+
+                dbus_message_iter_next(&subiter);
+            }
+        }
+        dbus_message_iter_next(&iter);
+    }
+
+    return ret;
+}
+
+} // namespace
+
+int rtkit_get_max_realtime_priority(DBusConnection *connection)
+{
+    long long retval{};
+    int err{rtkit_get_int_property(connection, "MaxRealtimePriority", &retval)};
+    return err < 0 ? err : static_cast<int>(retval);
+}
+
+int rtkit_get_min_nice_level(DBusConnection *connection, int *min_nice_level)
+{
+    long long retval{};
+    int err{rtkit_get_int_property(connection, "MinNiceLevel", &retval)};
+    if(err >= 0) *min_nice_level = static_cast<int>(retval);
+    return err;
+}
+
+long long rtkit_get_rttime_usec_max(DBusConnection *connection)
+{
+    long long retval{};
+    int err{rtkit_get_int_property(connection, "RTTimeUSecMax", &retval)};
+    return err < 0 ? err : retval;
+}
+
+int rtkit_make_realtime(DBusConnection *connection, pid_t thread, int priority)
+{
+    if(thread == 0)
+        thread = _gettid();
+    if(thread == 0)
+        return -ENOTSUP;
+
+    dbus::MessagePtr m{dbus_message_new_method_call(RTKIT_SERVICE_NAME, RTKIT_OBJECT_PATH,
+        "org.freedesktop.RealtimeKit1", "MakeThreadRealtime")};
+    if(!m) return -ENOMEM;
+
+    auto u64 = static_cast<dbus_uint64_t>(thread);
+    auto u32 = static_cast<dbus_uint32_t>(priority);
+    auto ready = dbus_message_append_args(m.get(),
+        dbus::TypeUInt64, &u64,
+        dbus::TypeUInt32, &u32,
+        dbus::TypeInvalid);
+    if(!ready) return -ENOMEM;
+
+    dbus::Error error;
+    dbus::MessagePtr r{dbus_connection_send_with_reply_and_block(connection, m.get(), -1,
+        &error.get())};
+    if(!r) return translate_error(error->name);
+
+    if(dbus_set_error_from_message(&error.get(), r.get()))
+        return translate_error(error->name);
+
+    return 0;
+}
+
+int rtkit_make_high_priority(DBusConnection *connection, pid_t thread, int nice_level)
+{
+    if(thread == 0)
+        thread = _gettid();
+    if(thread == 0)
+        return -ENOTSUP;
+
+    dbus::MessagePtr m{dbus_message_new_method_call(RTKIT_SERVICE_NAME, RTKIT_OBJECT_PATH,
+        "org.freedesktop.RealtimeKit1", "MakeThreadHighPriority")};
+    if(!m) return -ENOMEM;
+
+    auto u64 = static_cast<dbus_uint64_t>(thread);
+    auto s32 = static_cast<dbus_int32_t>(nice_level);
+    auto ready = dbus_message_append_args(m.get(),
+        dbus::TypeUInt64, &u64,
+        dbus::TypeInt32, &s32,
+        dbus::TypeInvalid);
+    if(!ready) return -ENOMEM;
+
+    dbus::Error error;
+    dbus::MessagePtr r{dbus_connection_send_with_reply_and_block(connection, m.get(), -1,
+        &error.get())};
+    if(!r) return translate_error(error->name);
+
+    if(dbus_set_error_from_message(&error.get(), r.get()))
+        return translate_error(error->name);
+
+    return 0;
+}
diff --git a/core/rtkit.h b/core/rtkit.h
new file mode 100644
index 00000000..d4994e27
--- /dev/null
+++ b/core/rtkit.h
@@ -0,0 +1,71 @@
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foortkithfoo
+#define foortkithfoo
+
+/***
+        Copyright 2009 Lennart Poettering
+        Copyright 2010 David Henningsson <[email protected]>
+
+        Permission is hereby granted, free of charge, to any person
+        obtaining a copy of this software and associated documentation files
+        (the "Software"), to deal in the Software without restriction,
+        including without limitation the rights to use, copy, modify, merge,
+        publish, distribute, sublicense, and/or sell copies of the Software,
+        and to permit persons to whom the Software is furnished to do so,
+        subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+        BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+        ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+        CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+***/
+
+#include <sys/types.h>
+
+#include "dbus_wrap.h"
+
+/* This is the reference implementation for a client for
+ * RealtimeKit. You don't have to use this, but if do, just copy these
+ * sources into your repository */
+
+#define RTKIT_SERVICE_NAME "org.freedesktop.RealtimeKit1"
+#define RTKIT_OBJECT_PATH "/org/freedesktop/RealtimeKit1"
+
+/* This is mostly equivalent to sched_setparam(thread, SCHED_RR, {
+ * .sched_priority = priority }). 'thread' needs to be a kernel thread
+ * id as returned by gettid(), not a pthread_t! If 'thread' is 0 the
+ * current thread is used. The returned value is a negative errno
+ * style error code, or 0 on success. */
+int rtkit_make_realtime(DBusConnection *system_bus, pid_t thread, int priority);
+
+/* This is mostly equivalent to setpriority(PRIO_PROCESS, thread,
+ * nice_level). 'thread' needs to be a kernel thread id as returned by
+ * gettid(), not a pthread_t! If 'thread' is 0 the current thread is
+ * used. The returned value is a negative errno style error code, or 0
+ * on success.*/
+int rtkit_make_high_priority(DBusConnection *system_bus, pid_t thread, int nice_level);
+
+/* Return the maximum value of realtime priority available. Realtime requests
+ * above this value will fail. A negative value is an errno style error code.
+ */
+int rtkit_get_max_realtime_priority(DBusConnection *system_bus);
+
+/* Retreive the minimum value of nice level available. High prio requests
+ * below this value will fail. The returned value is a negative errno
+ * style error code, or 0 on success.*/
+int rtkit_get_min_nice_level(DBusConnection *system_bus, int *min_nice_level);
+
+/* Return the maximum value of RLIMIT_RTTIME to set before attempting a
+ * realtime request. A negative value is an errno style error code.
+ */
+long long rtkit_get_rttime_usec_max(DBusConnection *system_bus);
+
+#endif
diff --git a/core/uhjfilter.cpp b/core/uhjfilter.cpp
new file mode 100644
index 00000000..df50956a
--- /dev/null
+++ b/core/uhjfilter.cpp
@@ -0,0 +1,539 @@
+
+#include "config.h"
+
+#include "uhjfilter.h"
+
+#include <algorithm>
+#include <iterator>
+
+#include "alcomplex.h"
+#include "alnumeric.h"
+#include "opthelpers.h"
+#include "phase_shifter.h"
+
+
+UhjQualityType UhjDecodeQuality{UhjQualityType::Default};
+UhjQualityType UhjEncodeQuality{UhjQualityType::Default};
+
+
+namespace {
+
+const PhaseShifterT<UhjLength256> PShiftLq{};
+const PhaseShifterT<UhjLength512> PShiftHq{};
+
+template<size_t N>
+struct GetPhaseShifter;
+template<>
+struct GetPhaseShifter<UhjLength256> { static auto& Get() noexcept { return PShiftLq; } };
+template<>
+struct GetPhaseShifter<UhjLength512> { static auto& Get() noexcept { return PShiftHq; } };
+
+
+constexpr float square(float x) noexcept
+{ return x*x; }
+
+/* Filter coefficients for the 'base' all-pass IIR, which applies a frequency-
+ * dependent phase-shift of N degrees. The output of the filter requires a 1-
+ * sample delay.
+ */
+constexpr std::array<float,4> Filter1Coeff{{
+    square(0.6923878f), square(0.9360654322959f), square(0.9882295226860f),
+    square(0.9987488452737f)
+}};
+/* Filter coefficients for the offset all-pass IIR, which applies a frequency-
+ * dependent phase-shift of N+90 degrees.
+ */
+constexpr std::array<float,4> Filter2Coeff{{
+    square(0.4021921162426f), square(0.8561710882420f), square(0.9722909545651f),
+    square(0.9952884791278f)
+}};
+
+} // namespace
+
+void UhjAllPassFilter::process(const al::span<const float,4> coeffs,
+    const al::span<const float> src, const bool updateState, float *RESTRICT dst)
+{
+    auto state = mState;
+
+    auto proc_sample = [&state,coeffs](float x) noexcept -> float
+    {
+        for(size_t i{0};i < 4;++i)
+        {
+            const float y{x*coeffs[i] + state[i].z[0]};
+            state[i].z[0] = state[i].z[1];
+            state[i].z[1] = y*coeffs[i] - x;
+            x = y;
+        }
+        return x;
+    };
+    std::transform(src.begin(), src.end(), dst, proc_sample);
+    if(updateState) LIKELY mState = state;
+}
+
+
+/* Encoding UHJ from B-Format is done as:
+ *
+ * S = 0.9396926*W + 0.1855740*X
+ * D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y
+ *
+ * Left = (S + D)/2.0
+ * Right = (S - D)/2.0
+ * T = j(-0.1432*W + 0.6512*X) - 0.7071068*Y
+ * Q = 0.9772*Z
+ *
+ * where j is a wide-band +90 degree phase shift. 3-channel UHJ excludes Q,
+ * while 2-channel excludes Q and T.
+ *
+ * The phase shift is done using a linear FIR filter derived from an FFT'd
+ * impulse with the desired shift.
+ */
+
+template<size_t N>
+void UhjEncoder<N>::encode(float *LeftOut, float *RightOut,
+    const al::span<const float*const,3> InSamples, const size_t SamplesToDo)
+{
+    const auto &PShift = GetPhaseShifter<N>::Get();
+
+    ASSUME(SamplesToDo > 0);
+
+    const float *RESTRICT winput{al::assume_aligned<16>(InSamples[0])};
+    const float *RESTRICT xinput{al::assume_aligned<16>(InSamples[1])};
+    const float *RESTRICT yinput{al::assume_aligned<16>(InSamples[2])};
+
+    std::copy_n(winput, SamplesToDo, mW.begin()+sFilterDelay);
+    std::copy_n(xinput, SamplesToDo, mX.begin()+sFilterDelay);
+    std::copy_n(yinput, SamplesToDo, mY.begin()+sFilterDelay);
+
+    /* S = 0.9396926*W + 0.1855740*X */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mS[i] = 0.9396926f*mW[i] + 0.1855740f*mX[i];
+
+    /* Precompute j(-0.3420201*W + 0.5098604*X) and store in mD. */
+    std::transform(winput, winput+SamplesToDo, xinput, mWX.begin() + sWXInOffset,
+        [](const float w, const float x) noexcept -> float
+        { return -0.3420201f*w + 0.5098604f*x; });
+    PShift.process({mD.data(), SamplesToDo}, mWX.data());
+
+    /* D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mD[i] = mD[i] + 0.6554516f*mY[i];
+
+    /* Copy the future samples to the front for next time. */
+    std::copy(mW.cbegin()+SamplesToDo, mW.cbegin()+SamplesToDo+sFilterDelay, mW.begin());
+    std::copy(mX.cbegin()+SamplesToDo, mX.cbegin()+SamplesToDo+sFilterDelay, mX.begin());
+    std::copy(mY.cbegin()+SamplesToDo, mY.cbegin()+SamplesToDo+sFilterDelay, mY.begin());
+    std::copy(mWX.cbegin()+SamplesToDo, mWX.cbegin()+SamplesToDo+sWXInOffset, mWX.begin());
+
+    /* Apply a delay to the existing output to align with the input delay. */
+    auto *delayBuffer = mDirectDelay.data();
+    for(float *buffer : {LeftOut, RightOut})
+    {
+        float *distbuf{al::assume_aligned<16>(delayBuffer->data())};
+        ++delayBuffer;
+
+        float *inout{al::assume_aligned<16>(buffer)};
+        auto inout_end = inout + SamplesToDo;
+        if(SamplesToDo >= sFilterDelay) LIKELY
+        {
+            auto delay_end = std::rotate(inout, inout_end - sFilterDelay, inout_end);
+            std::swap_ranges(inout, delay_end, distbuf);
+        }
+        else
+        {
+            auto delay_start = std::swap_ranges(inout, inout_end, distbuf);
+            std::rotate(distbuf, delay_start, distbuf + sFilterDelay);
+        }
+    }
+
+    /* Combine the direct signal with the produced output. */
+
+    /* Left = (S + D)/2.0 */
+    float *RESTRICT left{al::assume_aligned<16>(LeftOut)};
+    for(size_t i{0};i < SamplesToDo;i++)
+        left[i] += (mS[i] + mD[i]) * 0.5f;
+    /* Right = (S - D)/2.0 */
+    float *RESTRICT right{al::assume_aligned<16>(RightOut)};
+    for(size_t i{0};i < SamplesToDo;i++)
+        right[i] += (mS[i] - mD[i]) * 0.5f;
+}
+
+/* This encoding implementation uses two sets of four chained IIR filters to
+ * produce the desired relative phase shift. The first filter chain produces a
+ * phase shift of varying degrees over a wide range of frequencies, while the
+ * second filter chain produces a phase shift 90 degrees ahead of the first
+ * over the same range. Further details are described here:
+ *
+ * https://web.archive.org/web/20060708031958/http://www.biochem.oulu.fi/~oniemita/dsp/hilbert/
+ *
+ * 2-channel UHJ output requires the use of three filter chains. The S channel
+ * output uses a Filter1 chain on the W and X channel mix, while the D channel
+ * output uses a Filter1 chain on the Y channel plus a Filter2 chain on the W
+ * and X channel mix. This results in the W and X input mix on the D channel
+ * output having the required +90 degree phase shift relative to the other
+ * inputs.
+ */
+void UhjEncoderIIR::encode(float *LeftOut, float *RightOut,
+    const al::span<const float *const, 3> InSamples, const size_t SamplesToDo)
+{
+    ASSUME(SamplesToDo > 0);
+
+    const float *RESTRICT winput{al::assume_aligned<16>(InSamples[0])};
+    const float *RESTRICT xinput{al::assume_aligned<16>(InSamples[1])};
+    const float *RESTRICT yinput{al::assume_aligned<16>(InSamples[2])};
+
+    /* S = 0.9396926*W + 0.1855740*X */
+    std::transform(winput, winput+SamplesToDo, xinput, mTemp.begin(),
+        [](const float w, const float x) noexcept { return 0.9396926f*w + 0.1855740f*x; });
+    mFilter1WX.process(Filter1Coeff, {mTemp.data(), SamplesToDo}, true, mS.data()+1);
+    mS[0] = mDelayWX; mDelayWX = mS[SamplesToDo];
+
+    /* Precompute j(-0.3420201*W + 0.5098604*X) and store in mWX. */
+    std::transform(winput, winput+SamplesToDo, xinput, mTemp.begin(),
+        [](const float w, const float x) noexcept { return -0.3420201f*w + 0.5098604f*x; });
+    mFilter2WX.process(Filter2Coeff, {mTemp.data(), SamplesToDo}, true, mWX.data());
+
+    /* Apply filter1 to Y and store in mD. */
+    mFilter1Y.process(Filter1Coeff, {yinput, SamplesToDo}, SamplesToDo, mD.data()+1);
+    mD[0] = mDelayY; mDelayY = mD[SamplesToDo];
+
+    /* D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mD[i] = mWX[i] + 0.6554516f*mD[i];
+
+    /* Apply the base filter to the existing output to align with the processed
+     * signal.
+     */
+    mFilter1Direct[0].process(Filter1Coeff, {LeftOut, SamplesToDo}, true, mTemp.data()+1);
+    mTemp[0] = mDirectDelay[0]; mDirectDelay[0] = mTemp[SamplesToDo];
+
+    /* Left = (S + D)/2.0 */
+    float *RESTRICT left{al::assume_aligned<16>(LeftOut)};
+    for(size_t i{0};i < SamplesToDo;i++)
+        left[i] = (mS[i] + mD[i])*0.5f + mTemp[i];
+
+    mFilter1Direct[1].process(Filter1Coeff, {RightOut, SamplesToDo}, true, mTemp.data()+1);
+    mTemp[0] = mDirectDelay[1]; mDirectDelay[1] = mTemp[SamplesToDo];
+
+    /* Right = (S - D)/2.0 */
+    float *RESTRICT right{al::assume_aligned<16>(RightOut)};
+    for(size_t i{0};i < SamplesToDo;i++)
+        right[i] = (mS[i] - mD[i])*0.5f + mTemp[i];
+}
+
+
+/* Decoding UHJ is done as:
+ *
+ * S = Left + Right
+ * D = Left - Right
+ *
+ * W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T)
+ * X = 0.418496*S - j(0.828331*D + 0.767820*T)
+ * Y = 0.795968*D - 0.676392*T + j(0.186633*S)
+ * Z = 1.023332*Q
+ *
+ * where j is a +90 degree phase shift. 3-channel UHJ excludes Q, while 2-
+ * channel excludes Q and T.
+ */
+template<size_t N>
+void UhjDecoder<N>::decode(const al::span<float*> samples, const size_t samplesToDo,
+    const bool updateState)
+{
+    static_assert(sInputPadding <= sMaxPadding, "Filter padding is too large");
+
+    const auto &PShift = GetPhaseShifter<N>::Get();
+
+    ASSUME(samplesToDo > 0);
+
+    {
+        const float *RESTRICT left{al::assume_aligned<16>(samples[0])};
+        const float *RESTRICT right{al::assume_aligned<16>(samples[1])};
+        const float *RESTRICT t{al::assume_aligned<16>(samples[2])};
+
+        /* S = Left + Right */
+        for(size_t i{0};i < samplesToDo+sInputPadding;++i)
+            mS[i] = left[i] + right[i];
+
+        /* D = Left - Right */
+        for(size_t i{0};i < samplesToDo+sInputPadding;++i)
+            mD[i] = left[i] - right[i];
+
+        /* T */
+        for(size_t i{0};i < samplesToDo+sInputPadding;++i)
+            mT[i] = t[i];
+    }
+
+    float *RESTRICT woutput{al::assume_aligned<16>(samples[0])};
+    float *RESTRICT xoutput{al::assume_aligned<16>(samples[1])};
+    float *RESTRICT youtput{al::assume_aligned<16>(samples[2])};
+
+    /* Precompute j(0.828331*D + 0.767820*T) and store in xoutput. */
+    auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
+    std::transform(mD.cbegin(), mD.cbegin()+samplesToDo+sInputPadding, mT.cbegin(), tmpiter,
+        [](const float d, const float t) noexcept { return 0.828331f*d + 0.767820f*t; });
+    if(updateState) LIKELY
+        std::copy_n(mTemp.cbegin()+samplesToDo, mDTHistory.size(), mDTHistory.begin());
+    PShift.process({xoutput, samplesToDo}, mTemp.data());
+
+    /* W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T) */
+    for(size_t i{0};i < samplesToDo;++i)
+        woutput[i] = 0.981532f*mS[i] + 0.197484f*xoutput[i];
+    /* X = 0.418496*S - j(0.828331*D + 0.767820*T) */
+    for(size_t i{0};i < samplesToDo;++i)
+        xoutput[i] = 0.418496f*mS[i] - xoutput[i];
+
+    /* Precompute j*S and store in youtput. */
+    tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
+    std::copy_n(mS.cbegin(), samplesToDo+sInputPadding, tmpiter);
+    if(updateState) LIKELY
+        std::copy_n(mTemp.cbegin()+samplesToDo, mSHistory.size(), mSHistory.begin());
+    PShift.process({youtput, samplesToDo}, mTemp.data());
+
+    /* Y = 0.795968*D - 0.676392*T + j(0.186633*S) */
+    for(size_t i{0};i < samplesToDo;++i)
+        youtput[i] = 0.795968f*mD[i] - 0.676392f*mT[i] + 0.186633f*youtput[i];
+
+    if(samples.size() > 3)
+    {
+        float *RESTRICT zoutput{al::assume_aligned<16>(samples[3])};
+        /* Z = 1.023332*Q */
+        for(size_t i{0};i < samplesToDo;++i)
+            zoutput[i] = 1.023332f*zoutput[i];
+    }
+}
+
+void UhjDecoderIIR::decode(const al::span<float*> samples, const size_t samplesToDo,
+    const bool updateState)
+{
+    static_assert(sInputPadding <= sMaxPadding, "Filter padding is too large");
+
+    ASSUME(samplesToDo > 0);
+
+    {
+        const float *RESTRICT left{al::assume_aligned<16>(samples[0])};
+        const float *RESTRICT right{al::assume_aligned<16>(samples[1])};
+
+        /* S = Left + Right */
+        for(size_t i{0};i < samplesToDo;++i)
+            mS[i] = left[i] + right[i];
+
+        /* D = Left - Right */
+        for(size_t i{0};i < samplesToDo;++i)
+            mD[i] = left[i] - right[i];
+    }
+
+    float *RESTRICT woutput{al::assume_aligned<16>(samples[0])};
+    float *RESTRICT xoutput{al::assume_aligned<16>(samples[1])};
+    float *RESTRICT youtput{al::assume_aligned<16>(samples[2])};
+
+    /* Precompute j(0.828331*D + 0.767820*T) and store in xoutput. */
+    std::transform(mD.cbegin(), mD.cbegin()+samplesToDo, youtput, mTemp.begin(),
+        [](const float d, const float t) noexcept { return 0.828331f*d + 0.767820f*t; });
+    mFilter2DT.process(Filter2Coeff, {mTemp.data(), samplesToDo}, updateState, xoutput);
+
+    /* Apply filter1 to S and store in mTemp. */
+    mTemp[0] = mDelayS;
+    mFilter1S.process(Filter1Coeff, {mS.data(), samplesToDo}, updateState, mTemp.data()+1);
+    if(updateState) LIKELY mDelayS = mTemp[samplesToDo];
+
+    /* W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T) */
+    for(size_t i{0};i < samplesToDo;++i)
+        woutput[i] = 0.981532f*mTemp[i] + 0.197484f*xoutput[i];
+    /* X = 0.418496*S - j(0.828331*D + 0.767820*T) */
+    for(size_t i{0};i < samplesToDo;++i)
+        xoutput[i] = 0.418496f*mTemp[i] - xoutput[i];
+
+
+    /* Apply filter1 to (0.795968*D - 0.676392*T) and store in mTemp. */
+    std::transform(mD.cbegin(), mD.cbegin()+samplesToDo, youtput, youtput,
+        [](const float d, const float t) noexcept { return 0.795968f*d - 0.676392f*t; });
+    mTemp[0] = mDelayDT;
+    mFilter1DT.process(Filter1Coeff, {youtput, samplesToDo}, updateState, mTemp.data()+1);
+    if(updateState) LIKELY mDelayDT = mTemp[samplesToDo];
+
+    /* Precompute j*S and store in youtput. */
+    mFilter2S.process(Filter2Coeff, {mS.data(), samplesToDo}, updateState, youtput);
+
+    /* Y = 0.795968*D - 0.676392*T + j(0.186633*S) */
+    for(size_t i{0};i < samplesToDo;++i)
+        youtput[i] = mTemp[i] + 0.186633f*youtput[i];
+
+
+    if(samples.size() > 3)
+    {
+        float *RESTRICT zoutput{al::assume_aligned<16>(samples[3])};
+
+        /* Apply filter1 to Q and store in mTemp. */
+        mTemp[0] = mDelayQ;
+        mFilter1Q.process(Filter1Coeff, {zoutput, samplesToDo}, updateState, mTemp.data()+1);
+        if(updateState) LIKELY mDelayQ = mTemp[samplesToDo];
+
+        /* Z = 1.023332*Q */
+        for(size_t i{0};i < samplesToDo;++i)
+            zoutput[i] = 1.023332f*mTemp[i];
+    }
+}
+
+
+/* Super Stereo processing is done as:
+ *
+ * S = Left + Right
+ * D = Left - Right
+ *
+ * W = 0.6098637*S - 0.6896511*j*w*D
+ * X = 0.8624776*S + 0.7626955*j*w*D
+ * Y = 1.6822415*w*D - 0.2156194*j*S
+ *
+ * where j is a +90 degree phase shift. w is a variable control for the
+ * resulting stereo width, with the range 0 <= w <= 0.7.
+ */
+template<size_t N>
+void UhjStereoDecoder<N>::decode(const al::span<float*> samples, const size_t samplesToDo,
+    const bool updateState)
+{
+    static_assert(sInputPadding <= sMaxPadding, "Filter padding is too large");
+
+    const auto &PShift = GetPhaseShifter<N>::Get();
+
+    ASSUME(samplesToDo > 0);
+
+    {
+        const float *RESTRICT left{al::assume_aligned<16>(samples[0])};
+        const float *RESTRICT right{al::assume_aligned<16>(samples[1])};
+
+        for(size_t i{0};i < samplesToDo+sInputPadding;++i)
+            mS[i] = left[i] + right[i];
+
+        /* Pre-apply the width factor to the difference signal D. Smoothly
+         * interpolate when it changes.
+         */
+        const float wtarget{mWidthControl};
+        const float wcurrent{(mCurrentWidth < 0.0f) ? wtarget : mCurrentWidth};
+        if(wtarget == wcurrent || !updateState)
+        {
+            for(size_t i{0};i < samplesToDo+sInputPadding;++i)
+                mD[i] = (left[i] - right[i]) * wcurrent;
+            mCurrentWidth = wcurrent;
+        }
+        else
+        {
+            const float wstep{(wtarget - wcurrent) / static_cast<float>(samplesToDo)};
+            float fi{0.0f};
+            for(size_t i{0};i < samplesToDo;++i)
+            {
+                mD[i] = (left[i] - right[i]) * (wcurrent + wstep*fi);
+                fi += 1.0f;
+            }
+            for(size_t i{samplesToDo};i < samplesToDo+sInputPadding;++i)
+                mD[i] = (left[i] - right[i]) * wtarget;
+            mCurrentWidth = wtarget;
+        }
+    }
+
+    float *RESTRICT woutput{al::assume_aligned<16>(samples[0])};
+    float *RESTRICT xoutput{al::assume_aligned<16>(samples[1])};
+    float *RESTRICT youtput{al::assume_aligned<16>(samples[2])};
+
+    /* Precompute j*D and store in xoutput. */
+    auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
+    std::copy_n(mD.cbegin(), samplesToDo+sInputPadding, tmpiter);
+    if(updateState) LIKELY
+        std::copy_n(mTemp.cbegin()+samplesToDo, mDTHistory.size(), mDTHistory.begin());
+    PShift.process({xoutput, samplesToDo}, mTemp.data());
+
+    /* W = 0.6098637*S - 0.6896511*j*w*D */
+    for(size_t i{0};i < samplesToDo;++i)
+        woutput[i] = 0.6098637f*mS[i] - 0.6896511f*xoutput[i];
+    /* X = 0.8624776*S + 0.7626955*j*w*D */
+    for(size_t i{0};i < samplesToDo;++i)
+        xoutput[i] = 0.8624776f*mS[i] + 0.7626955f*xoutput[i];
+
+    /* Precompute j*S and store in youtput. */
+    tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
+    std::copy_n(mS.cbegin(), samplesToDo+sInputPadding, tmpiter);
+    if(updateState) LIKELY
+        std::copy_n(mTemp.cbegin()+samplesToDo, mSHistory.size(), mSHistory.begin());
+    PShift.process({youtput, samplesToDo}, mTemp.data());
+
+    /* Y = 1.6822415*w*D - 0.2156194*j*S */
+    for(size_t i{0};i < samplesToDo;++i)
+        youtput[i] = 1.6822415f*mD[i] - 0.2156194f*youtput[i];
+}
+
+void UhjStereoDecoderIIR::decode(const al::span<float*> samples, const size_t samplesToDo,
+    const bool updateState)
+{
+    static_assert(sInputPadding <= sMaxPadding, "Filter padding is too large");
+
+    ASSUME(samplesToDo > 0);
+
+    {
+        const float *RESTRICT left{al::assume_aligned<16>(samples[0])};
+        const float *RESTRICT right{al::assume_aligned<16>(samples[1])};
+
+        for(size_t i{0};i < samplesToDo;++i)
+            mS[i] = left[i] + right[i];
+
+        /* Pre-apply the width factor to the difference signal D. Smoothly
+         * interpolate when it changes.
+         */
+        const float wtarget{mWidthControl};
+        const float wcurrent{(mCurrentWidth < 0.0f) ? wtarget : mCurrentWidth};
+        if(wtarget == wcurrent || !updateState)
+        {
+            for(size_t i{0};i < samplesToDo;++i)
+                mD[i] = (left[i] - right[i]) * wcurrent;
+            mCurrentWidth = wcurrent;
+        }
+        else
+        {
+            const float wstep{(wtarget - wcurrent) / static_cast<float>(samplesToDo)};
+            float fi{0.0f};
+            for(size_t i{0};i < samplesToDo;++i)
+            {
+                mD[i] = (left[i] - right[i]) * (wcurrent + wstep*fi);
+                fi += 1.0f;
+            }
+            mCurrentWidth = wtarget;
+        }
+    }
+
+    float *RESTRICT woutput{al::assume_aligned<16>(samples[0])};
+    float *RESTRICT xoutput{al::assume_aligned<16>(samples[1])};
+    float *RESTRICT youtput{al::assume_aligned<16>(samples[2])};
+
+    /* Apply filter1 to S and store in mTemp. */
+    mTemp[0] = mDelayS;
+    mFilter1S.process(Filter1Coeff, {mS.data(), samplesToDo}, updateState, mTemp.data()+1);
+    if(updateState) LIKELY mDelayS = mTemp[samplesToDo];
+
+    /* Precompute j*D and store in xoutput. */
+    mFilter2D.process(Filter2Coeff, {mD.data(), samplesToDo}, updateState, xoutput);
+
+    /* W = 0.6098637*S - 0.6896511*j*w*D */
+    for(size_t i{0};i < samplesToDo;++i)
+        woutput[i] = 0.6098637f*mTemp[i] - 0.6896511f*xoutput[i];
+    /* X = 0.8624776*S + 0.7626955*j*w*D */
+    for(size_t i{0};i < samplesToDo;++i)
+        xoutput[i] = 0.8624776f*mTemp[i] + 0.7626955f*xoutput[i];
+
+    /* Precompute j*S and store in youtput. */
+    mFilter2S.process(Filter2Coeff, {mS.data(), samplesToDo}, updateState, youtput);
+
+    /* Apply filter1 to D and store in mTemp. */
+    mTemp[0] = mDelayD;
+    mFilter1D.process(Filter1Coeff, {mD.data(), samplesToDo}, updateState, mTemp.data()+1);
+    if(updateState) LIKELY mDelayD = mTemp[samplesToDo];
+
+    /* Y = 1.6822415*w*D - 0.2156194*j*S */
+    for(size_t i{0};i < samplesToDo;++i)
+        youtput[i] = 1.6822415f*mTemp[i] - 0.2156194f*youtput[i];
+}
+
+
+template struct UhjEncoder<UhjLength256>;
+template struct UhjDecoder<UhjLength256>;
+template struct UhjStereoDecoder<UhjLength256>;
+
+template struct UhjEncoder<UhjLength512>;
+template struct UhjDecoder<UhjLength512>;
+template struct UhjStereoDecoder<UhjLength512>;
diff --git a/core/uhjfilter.h b/core/uhjfilter.h
new file mode 100644
index 00000000..df308094
--- /dev/null
+++ b/core/uhjfilter.h
@@ -0,0 +1,234 @@
+#ifndef CORE_UHJFILTER_H
+#define CORE_UHJFILTER_H
+
+#include <array>
+
+#include "almalloc.h"
+#include "alspan.h"
+#include "bufferline.h"
+
+
+static constexpr size_t UhjLength256{256};
+static constexpr size_t UhjLength512{512};
+
+enum class UhjQualityType : uint8_t {
+    IIR = 0,
+    FIR256,
+    FIR512,
+    Default = IIR
+};
+
+extern UhjQualityType UhjDecodeQuality;
+extern UhjQualityType UhjEncodeQuality;
+
+
+struct UhjAllPassFilter {
+    struct AllPassState {
+        /* Last two delayed components for direct form II. */
+        float z[2];
+    };
+    std::array<AllPassState,4> mState;
+
+    void process(const al::span<const float,4> coeffs, const al::span<const float> src,
+        const bool update, float *RESTRICT dst);
+};
+
+
+struct UhjEncoderBase {
+    virtual ~UhjEncoderBase() = default;
+
+    virtual size_t getDelay() noexcept = 0;
+
+    /**
+     * Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
+     * signal. The input must use FuMa channel ordering and UHJ scaling (FuMa
+     * with an additional +3dB boost).
+     */
+    virtual void encode(float *LeftOut, float *RightOut,
+        const al::span<const float*const,3> InSamples, const size_t SamplesToDo) = 0;
+};
+
+template<size_t N>
+struct UhjEncoder final : public UhjEncoderBase {
+    static constexpr size_t sFilterDelay{N/2};
+
+    /* Delays and processing storage for the input signal. */
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mW{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mX{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mY{};
+
+    alignas(16) std::array<float,BufferLineSize> mS{};
+    alignas(16) std::array<float,BufferLineSize> mD{};
+
+    /* History and temp storage for the FIR filter. New samples should be
+     * written to index sFilterDelay*2 - 1.
+     */
+    static constexpr size_t sWXInOffset{sFilterDelay*2 - 1};
+    alignas(16) std::array<float,BufferLineSize + sFilterDelay*2> mWX{};
+
+    alignas(16) std::array<std::array<float,sFilterDelay>,2> mDirectDelay{};
+
+    size_t getDelay() noexcept override { return sFilterDelay; }
+
+    /**
+     * Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
+     * signal. The input must use FuMa channel ordering and UHJ scaling (FuMa
+     * with an additional +3dB boost).
+     */
+    void encode(float *LeftOut, float *RightOut, const al::span<const float*const,3> InSamples,
+        const size_t SamplesToDo) override;
+
+    DEF_NEWDEL(UhjEncoder)
+};
+
+struct UhjEncoderIIR final : public UhjEncoderBase {
+    static constexpr size_t sFilterDelay{1};
+
+    /* Processing storage for the input signal. */
+    alignas(16) std::array<float,BufferLineSize+1> mS{};
+    alignas(16) std::array<float,BufferLineSize+1> mD{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mWX{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mTemp{};
+    float mDelayWX{}, mDelayY{};
+
+    UhjAllPassFilter mFilter1WX;
+    UhjAllPassFilter mFilter2WX;
+    UhjAllPassFilter mFilter1Y;
+
+    std::array<UhjAllPassFilter,2> mFilter1Direct;
+    std::array<float,2> mDirectDelay{};
+
+    size_t getDelay() noexcept override { return sFilterDelay; }
+
+    /**
+     * Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
+     * signal. The input must use FuMa channel ordering and UHJ scaling (FuMa
+     * with an additional +3dB boost).
+     */
+    void encode(float *LeftOut, float *RightOut, const al::span<const float*const,3> InSamples,
+        const size_t SamplesToDo) override;
+
+    DEF_NEWDEL(UhjEncoderIIR)
+};
+
+
+struct DecoderBase {
+    static constexpr size_t sMaxPadding{256};
+
+    /* For 2-channel UHJ, shelf filters should use these LF responses. */
+    static constexpr float sWLFScale{0.661f};
+    static constexpr float sXYLFScale{1.293f};
+
+    virtual ~DecoderBase() = default;
+
+    virtual void decode(const al::span<float*> samples, const size_t samplesToDo,
+        const bool updateState) = 0;
+
+    /**
+     * The width factor for Super Stereo processing. Can be changed in between
+     * calls to decode, with valid values being between 0...0.7.
+     */
+    float mWidthControl{0.593f};
+};
+
+template<size_t N>
+struct UhjDecoder final : public DecoderBase {
+    /* The number of extra sample frames needed for input. */
+    static constexpr size_t sInputPadding{N/2};
+
+    alignas(16) std::array<float,BufferLineSize+sInputPadding> mS{};
+    alignas(16) std::array<float,BufferLineSize+sInputPadding> mD{};
+    alignas(16) std::array<float,BufferLineSize+sInputPadding> mT{};
+
+    alignas(16) std::array<float,sInputPadding-1> mDTHistory{};
+    alignas(16) std::array<float,sInputPadding-1> mSHistory{};
+
+    alignas(16) std::array<float,BufferLineSize + sInputPadding*2> mTemp{};
+
+    /**
+     * Decodes a 3- or 4-channel UHJ signal into a B-Format signal with FuMa
+     * channel ordering and UHJ scaling. For 3-channel, the 3rd channel may be
+     * attenuated by 'n', where 0 <= n <= 1. So to decode 2-channel UHJ, supply
+     * 3 channels with the 3rd channel silent (n=0). The B-Format signal
+     * reconstructed from 2-channel UHJ should not be run through a normal
+     * B-Format decoder, as it needs different shelf filters.
+     */
+    void decode(const al::span<float*> samples, const size_t samplesToDo,
+        const bool updateState) override;
+
+    DEF_NEWDEL(UhjDecoder)
+};
+
+struct UhjDecoderIIR final : public DecoderBase {
+    /* FIXME: These IIR decoder filters actually have a 1-sample delay on the
+     * non-filtered components, which is not reflected in the source latency
+     * value. sInputPadding is 0, however, because it doesn't need any extra
+     * input samples.
+     */
+    static constexpr size_t sInputPadding{0};
+
+    alignas(16) std::array<float,BufferLineSize> mS{};
+    alignas(16) std::array<float,BufferLineSize> mD{};
+    alignas(16) std::array<float,BufferLineSize+1> mTemp{};
+    float mDelayS{}, mDelayDT{}, mDelayQ{};
+
+    UhjAllPassFilter mFilter1S;
+    UhjAllPassFilter mFilter2DT;
+    UhjAllPassFilter mFilter1DT;
+    UhjAllPassFilter mFilter2S;
+    UhjAllPassFilter mFilter1Q;
+
+    void decode(const al::span<float*> samples, const size_t samplesToDo,
+        const bool updateState) override;
+
+    DEF_NEWDEL(UhjDecoderIIR)
+};
+
+template<size_t N>
+struct UhjStereoDecoder final : public DecoderBase {
+    static constexpr size_t sInputPadding{N/2};
+
+    float mCurrentWidth{-1.0f};
+
+    alignas(16) std::array<float,BufferLineSize+sInputPadding> mS{};
+    alignas(16) std::array<float,BufferLineSize+sInputPadding> mD{};
+
+    alignas(16) std::array<float,sInputPadding-1> mDTHistory{};
+    alignas(16) std::array<float,sInputPadding-1> mSHistory{};
+
+    alignas(16) std::array<float,BufferLineSize + sInputPadding*2> mTemp{};
+
+    /**
+     * Applies Super Stereo processing on a stereo signal to create a B-Format
+     * signal with FuMa channel ordering and UHJ scaling. The samples span
+     * should contain 3 channels, the first two being the left and right stereo
+     * channels, and the third left empty.
+     */
+    void decode(const al::span<float*> samples, const size_t samplesToDo,
+        const bool updateState) override;
+
+    DEF_NEWDEL(UhjStereoDecoder)
+};
+
+struct UhjStereoDecoderIIR final : public DecoderBase {
+    static constexpr size_t sInputPadding{0};
+
+    float mCurrentWidth{-1.0f};
+
+    alignas(16) std::array<float,BufferLineSize> mS{};
+    alignas(16) std::array<float,BufferLineSize> mD{};
+    alignas(16) std::array<float,BufferLineSize+1> mTemp{};
+    float mDelayS{}, mDelayD{};
+
+    UhjAllPassFilter mFilter1S;
+    UhjAllPassFilter mFilter2D;
+    UhjAllPassFilter mFilter1D;
+    UhjAllPassFilter mFilter2S;
+
+    void decode(const al::span<float*> samples, const size_t samplesToDo,
+        const bool updateState) override;
+
+    DEF_NEWDEL(UhjStereoDecoderIIR)
+};
+
+#endif /* CORE_UHJFILTER_H */
diff --git a/alc/uiddefs.cpp b/core/uiddefs.cpp
index 244c01a5..244c01a5 100644
--- a/alc/uiddefs.cpp
+++ b/core/uiddefs.cpp
diff --git a/core/voice.cpp b/core/voice.cpp
new file mode 100644
index 00000000..e8fbcccd
--- /dev/null
+++ b/core/voice.cpp
@@ -0,0 +1,1304 @@
+
+#include "config.h"
+
+#include "voice.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cassert>
+#include <climits>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <new>
+#include <stdlib.h>
+#include <utility>
+#include <vector>
+
+#include "albyte.h"
+#include "alnumeric.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "alstring.h"
+#include "ambidefs.h"
+#include "async_event.h"
+#include "buffer_storage.h"
+#include "context.h"
+#include "cpu_caps.h"
+#include "devformat.h"
+#include "device.h"
+#include "filters/biquad.h"
+#include "filters/nfc.h"
+#include "filters/splitter.h"
+#include "fmt_traits.h"
+#include "logging.h"
+#include "mixer.h"
+#include "mixer/defs.h"
+#include "mixer/hrtfdefs.h"
+#include "opthelpers.h"
+#include "resampler_limits.h"
+#include "ringbuffer.h"
+#include "vector.h"
+#include "voice_change.h"
+
+struct CTag;
+#ifdef HAVE_SSE
+struct SSETag;
+#endif
+#ifdef HAVE_NEON
+struct NEONTag;
+#endif
+
+
+static_assert(!(sizeof(DeviceBase::MixerBufferLine)&15),
+    "DeviceBase::MixerBufferLine must be a multiple of 16 bytes");
+static_assert(!(MaxResamplerEdge&3), "MaxResamplerEdge is not a multiple of 4");
+
+static_assert((BufferLineSize-1)/MaxPitch > 0, "MaxPitch is too large for BufferLineSize!");
+static_assert((INT_MAX>>MixerFracBits)/MaxPitch > BufferLineSize,
+    "MaxPitch and/or BufferLineSize are too large for MixerFracBits!");
+
+Resampler ResamplerDefault{Resampler::Cubic};
+
+namespace {
+
+using uint = unsigned int;
+using namespace std::chrono;
+
+using HrtfMixerFunc = void(*)(const float *InSamples, float2 *AccumSamples, const uint IrSize,
+    const MixHrtfFilter *hrtfparams, const size_t BufferSize);
+using HrtfMixerBlendFunc = void(*)(const float *InSamples, float2 *AccumSamples,
+    const uint IrSize, const HrtfFilter *oldparams, const MixHrtfFilter *newparams,
+    const size_t BufferSize);
+
+HrtfMixerFunc MixHrtfSamples{MixHrtf_<CTag>};
+HrtfMixerBlendFunc MixHrtfBlendSamples{MixHrtfBlend_<CTag>};
+
+inline MixerOutFunc SelectMixer()
+{
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return Mix_<NEONTag>;
+#endif
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return Mix_<SSETag>;
+#endif
+    return Mix_<CTag>;
+}
+
+inline MixerOneFunc SelectMixerOne()
+{
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return Mix_<NEONTag>;
+#endif
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return Mix_<SSETag>;
+#endif
+    return Mix_<CTag>;
+}
+
+inline HrtfMixerFunc SelectHrtfMixer()
+{
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return MixHrtf_<NEONTag>;
+#endif
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return MixHrtf_<SSETag>;
+#endif
+    return MixHrtf_<CTag>;
+}
+
+inline HrtfMixerBlendFunc SelectHrtfBlendMixer()
+{
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return MixHrtfBlend_<NEONTag>;
+#endif
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return MixHrtfBlend_<SSETag>;
+#endif
+    return MixHrtfBlend_<CTag>;
+}
+
+} // namespace
+
+void Voice::InitMixer(al::optional<std::string> resampler)
+{
+    if(resampler)
+    {
+        struct ResamplerEntry {
+            const char name[16];
+            const Resampler resampler;
+        };
+        constexpr ResamplerEntry ResamplerList[]{
+            { "none", Resampler::Point },
+            { "point", Resampler::Point },
+            { "linear", Resampler::Linear },
+            { "cubic", Resampler::Cubic },
+            { "bsinc12", Resampler::BSinc12 },
+            { "fast_bsinc12", Resampler::FastBSinc12 },
+            { "bsinc24", Resampler::BSinc24 },
+            { "fast_bsinc24", Resampler::FastBSinc24 },
+        };
+
+        const char *str{resampler->c_str()};
+        if(al::strcasecmp(str, "bsinc") == 0)
+        {
+            WARN("Resampler option \"%s\" is deprecated, using bsinc12\n", str);
+            str = "bsinc12";
+        }
+        else if(al::strcasecmp(str, "sinc4") == 0 || al::strcasecmp(str, "sinc8") == 0)
+        {
+            WARN("Resampler option \"%s\" is deprecated, using cubic\n", str);
+            str = "cubic";
+        }
+
+        auto iter = std::find_if(std::begin(ResamplerList), std::end(ResamplerList),
+            [str](const ResamplerEntry &entry) -> bool
+            { return al::strcasecmp(str, entry.name) == 0; });
+        if(iter == std::end(ResamplerList))
+            ERR("Invalid resampler: %s\n", str);
+        else
+            ResamplerDefault = iter->resampler;
+    }
+
+    MixSamplesOut = SelectMixer();
+    MixSamplesOne = SelectMixerOne();
+    MixHrtfBlendSamples = SelectHrtfBlendMixer();
+    MixHrtfSamples = SelectHrtfMixer();
+}
+
+
+namespace {
+
+/* IMA ADPCM Stepsize table */
+constexpr int IMAStep_size[89] = {
+       7,    8,    9,   10,   11,   12,   13,   14,   16,   17,   19,
+      21,   23,   25,   28,   31,   34,   37,   41,   45,   50,   55,
+      60,   66,   73,   80,   88,   97,  107,  118,  130,  143,  157,
+     173,  190,  209,  230,  253,  279,  307,  337,  371,  408,  449,
+     494,  544,  598,  658,  724,  796,  876,  963, 1060, 1166, 1282,
+    1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660,
+    4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,
+   11487,12635,13899,15289,16818,18500,20350,22358,24633,27086,29794,
+   32767
+};
+
+/* IMA4 ADPCM Codeword decode table */
+constexpr int IMA4Codeword[16] = {
+    1, 3, 5, 7, 9, 11, 13, 15,
+   -1,-3,-5,-7,-9,-11,-13,-15,
+};
+
+/* IMA4 ADPCM Step index adjust decode table */
+constexpr int IMA4Index_adjust[16] = {
+   -1,-1,-1,-1, 2, 4, 6, 8,
+   -1,-1,-1,-1, 2, 4, 6, 8
+};
+
+/* MSADPCM Adaption table */
+constexpr int MSADPCMAdaption[16] = {
+    230, 230, 230, 230, 307, 409, 512, 614,
+    768, 614, 512, 409, 307, 230, 230, 230
+};
+
+/* MSADPCM Adaption Coefficient tables */
+constexpr int MSADPCMAdaptionCoeff[7][2] = {
+    { 256,    0 },
+    { 512, -256 },
+    {   0,    0 },
+    { 192,   64 },
+    { 240,    0 },
+    { 460, -208 },
+    { 392, -232 }
+};
+
+
+void SendSourceStoppedEvent(ContextBase *context, uint id)
+{
+    RingBuffer *ring{context->mAsyncEvents.get()};
+    auto evt_vec = ring->getWriteVector();
+    if(evt_vec.first.len < 1) return;
+
+    AsyncEvent *evt{al::construct_at(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf),
+        AsyncEvent::SourceStateChange)};
+    evt->u.srcstate.id = id;
+    evt->u.srcstate.state = AsyncEvent::SrcState::Stop;
+
+    ring->writeAdvance(1);
+}
+
+
+const float *DoFilters(BiquadFilter &lpfilter, BiquadFilter &hpfilter, float *dst,
+    const al::span<const float> src, int type)
+{
+    switch(type)
+    {
+    case AF_None:
+        lpfilter.clear();
+        hpfilter.clear();
+        break;
+
+    case AF_LowPass:
+        lpfilter.process(src, dst);
+        hpfilter.clear();
+        return dst;
+    case AF_HighPass:
+        lpfilter.clear();
+        hpfilter.process(src, dst);
+        return dst;
+
+    case AF_BandPass:
+        DualBiquad{lpfilter, hpfilter}.process(src, dst);
+        return dst;
+    }
+    return src.data();
+}
+
+
+template<FmtType Type>
+inline void LoadSamples(float *RESTRICT dstSamples, const al::byte *src, const size_t srcChan,
+    const size_t srcOffset, const size_t srcStep, const size_t /*samplesPerBlock*/,
+    const size_t samplesToLoad) noexcept
+{
+    constexpr size_t sampleSize{sizeof(typename al::FmtTypeTraits<Type>::Type)};
+    auto s = src + (srcOffset*srcStep + srcChan)*sampleSize;
+
+    al::LoadSampleArray<Type>(dstSamples, s, srcStep, samplesToLoad);
+}
+
+template<>
+inline void LoadSamples<FmtIMA4>(float *RESTRICT dstSamples, const al::byte *src,
+    const size_t srcChan, const size_t srcOffset, const size_t srcStep,
+    const size_t samplesPerBlock, const size_t samplesToLoad) noexcept
+{
+    const size_t blockBytes{((samplesPerBlock-1)/2 + 4)*srcStep};
+
+    /* Skip to the ADPCM block containing the srcOffset sample. */
+    src += srcOffset/samplesPerBlock*blockBytes;
+    /* Calculate how many samples need to be skipped in the block. */
+    size_t skip{srcOffset % samplesPerBlock};
+
+    /* NOTE: This could probably be optimized better. */
+    size_t wrote{0};
+    do {
+        /* Each IMA4 block starts with a signed 16-bit sample, and a signed
+         * 16-bit table index. The table index needs to be clamped.
+         */
+        int sample{src[srcChan*4] | (src[srcChan*4 + 1] << 8)};
+        int index{src[srcChan*4 + 2] | (src[srcChan*4 + 3] << 8)};
+
+        sample = (sample^0x8000) - 32768;
+        index = clampi((index^0x8000) - 32768, 0, al::size(IMAStep_size)-1);
+
+        if(skip == 0)
+        {
+            dstSamples[wrote++] = static_cast<float>(sample) / 32768.0f;
+            if(wrote == samplesToLoad) return;
+        }
+        else
+            --skip;
+
+        auto decode_sample = [&sample,&index](const uint nibble)
+        {
+            sample += IMA4Codeword[nibble] * IMAStep_size[index] / 8;
+            sample = clampi(sample, -32768, 32767);
+
+            index += IMA4Index_adjust[nibble];
+            index = clampi(index, 0, al::size(IMAStep_size)-1);
+
+            return sample;
+        };
+
+        /* The rest of the block is arranged as a series of nibbles, contained
+         * in 4 *bytes* per channel interleaved. So every 8 nibbles we need to
+         * skip 4 bytes per channel to get the next nibbles for this channel.
+         *
+         * First, decode the samples that we need to skip in the block (will
+         * always be less than the block size). They need to be decoded despite
+         * being ignored for proper state on the remaining samples.
+         */
+        const al::byte *nibbleData{src + (srcStep+srcChan)*4};
+        size_t nibbleOffset{0};
+        const size_t startOffset{skip + 1};
+        for(;skip;--skip)
+        {
+            const size_t byteShift{(nibbleOffset&1) * 4};
+            const size_t wordOffset{(nibbleOffset>>1) & ~size_t{3}};
+            const size_t byteOffset{wordOffset*srcStep + ((nibbleOffset>>1)&3u)};
+            ++nibbleOffset;
+
+            std::ignore = decode_sample((nibbleData[byteOffset]>>byteShift) & 15u);
+        }
+
+        /* Second, decode the rest of the block and write to the output, until
+         * the end of the block or the end of output.
+         */
+        const size_t todo{minz(samplesPerBlock-startOffset, samplesToLoad-wrote)};
+        for(size_t i{0};i < todo;++i)
+        {
+            const size_t byteShift{(nibbleOffset&1) * 4};
+            const size_t wordOffset{(nibbleOffset>>1) & ~size_t{3}};
+            const size_t byteOffset{wordOffset*srcStep + ((nibbleOffset>>1)&3u)};
+            ++nibbleOffset;
+
+            const int result{decode_sample((nibbleData[byteOffset]>>byteShift) & 15u)};
+            dstSamples[wrote++] = static_cast<float>(result) / 32768.0f;
+        }
+        if(wrote == samplesToLoad)
+            return;
+
+        src += blockBytes;
+    } while(true);
+}
+
+template<>
+inline void LoadSamples<FmtMSADPCM>(float *RESTRICT dstSamples, const al::byte *src,
+    const size_t srcChan, const size_t srcOffset, const size_t srcStep,
+    const size_t samplesPerBlock, const size_t samplesToLoad) noexcept
+{
+    const size_t blockBytes{((samplesPerBlock-2)/2 + 7)*srcStep};
+
+    src += srcOffset/samplesPerBlock*blockBytes;
+    size_t skip{srcOffset % samplesPerBlock};
+
+    size_t wrote{0};
+    do {
+        /* Each MS ADPCM block starts with an 8-bit block predictor, used to
+         * dictate how the two sample history values are mixed with the decoded
+         * sample, and an initial signed 16-bit delta value which scales the
+         * nibble sample value. This is followed by the two initial 16-bit
+         * sample history values.
+         */
+        const al::byte *input{src};
+        const uint8_t blockpred{std::min(input[srcChan], uint8_t{6})};
+        input += srcStep;
+        int delta{input[2*srcChan + 0] | (input[2*srcChan + 1] << 8)};
+        input += srcStep*2;
+
+        int sampleHistory[2]{};
+        sampleHistory[0] = input[2*srcChan + 0] | (input[2*srcChan + 1]<<8);
+        input += srcStep*2;
+        sampleHistory[1] = input[2*srcChan + 0] | (input[2*srcChan + 1]<<8);
+        input += srcStep*2;
+
+        const auto coeffs = al::as_span(MSADPCMAdaptionCoeff[blockpred]);
+        delta = (delta^0x8000) - 32768;
+        sampleHistory[0] = (sampleHistory[0]^0x8000) - 32768;
+        sampleHistory[1] = (sampleHistory[1]^0x8000) - 32768;
+
+        /* The second history sample is "older", so it's the first to be
+         * written out.
+         */
+        if(skip == 0)
+        {
+            dstSamples[wrote++] = static_cast<float>(sampleHistory[1]) / 32768.0f;
+            if(wrote == samplesToLoad) return;
+            dstSamples[wrote++] = static_cast<float>(sampleHistory[0]) / 32768.0f;
+            if(wrote == samplesToLoad) return;
+        }
+        else if(skip == 1)
+        {
+            --skip;
+            dstSamples[wrote++] = static_cast<float>(sampleHistory[0]) / 32768.0f;
+            if(wrote == samplesToLoad) return;
+        }
+        else
+            skip -= 2;
+
+        auto decode_sample = [&sampleHistory,&delta,coeffs](const int nibble)
+        {
+            int pred{(sampleHistory[0]*coeffs[0] + sampleHistory[1]*coeffs[1]) / 256};
+            pred += ((nibble^0x08) - 0x08) * delta;
+            pred  = clampi(pred, -32768, 32767);
+
+            sampleHistory[1] = sampleHistory[0];
+            sampleHistory[0] = pred;
+
+            delta = (MSADPCMAdaption[nibble] * delta) / 256;
+            delta = maxi(16, delta);
+
+            return pred;
+        };
+
+        /* The rest of the block is a series of nibbles, interleaved per-
+         * channel. First, skip samples.
+         */
+        const size_t startOffset{skip + 2};
+        size_t nibbleOffset{srcChan};
+        for(;skip;--skip)
+        {
+            const size_t byteOffset{nibbleOffset>>1};
+            const size_t byteShift{((nibbleOffset&1)^1) * 4};
+            nibbleOffset += srcStep;
+
+            std::ignore = decode_sample((input[byteOffset]>>byteShift) & 15);
+        }
+
+        /* Now decode the rest of the block, until the end of the block or the
+         * dst buffer is filled.
+         */
+        const size_t todo{minz(samplesPerBlock-startOffset, samplesToLoad-wrote)};
+        for(size_t j{0};j < todo;++j)
+        {
+            const size_t byteOffset{nibbleOffset>>1};
+            const size_t byteShift{((nibbleOffset&1)^1) * 4};
+            nibbleOffset += srcStep;
+
+            const int sample{decode_sample((input[byteOffset]>>byteShift) & 15)};
+            dstSamples[wrote++] = static_cast<float>(sample) / 32768.0f;
+        }
+        if(wrote == samplesToLoad)
+            return;
+
+        src += blockBytes;
+    } while(true);
+}
+
+void LoadSamples(float *dstSamples, const al::byte *src, const size_t srcChan,
+    const size_t srcOffset, const FmtType srcType, const size_t srcStep,
+    const size_t samplesPerBlock, const size_t samplesToLoad) noexcept
+{
+#define HANDLE_FMT(T) case T:                                                 \
+    LoadSamples<T>(dstSamples, src, srcChan, srcOffset, srcStep,              \
+        samplesPerBlock, samplesToLoad);                                      \
+    break
+
+    switch(srcType)
+    {
+    HANDLE_FMT(FmtUByte);
+    HANDLE_FMT(FmtShort);
+    HANDLE_FMT(FmtFloat);
+    HANDLE_FMT(FmtDouble);
+    HANDLE_FMT(FmtMulaw);
+    HANDLE_FMT(FmtAlaw);
+    HANDLE_FMT(FmtIMA4);
+    HANDLE_FMT(FmtMSADPCM);
+    }
+#undef HANDLE_FMT
+}
+
+void LoadBufferStatic(VoiceBufferItem *buffer, VoiceBufferItem *bufferLoopItem,
+    const size_t dataPosInt, const FmtType sampleType, const size_t srcChannel,
+    const size_t srcStep, size_t samplesLoaded, const size_t samplesToLoad,
+    float *voiceSamples)
+{
+    if(!bufferLoopItem)
+    {
+        /* Load what's left to play from the buffer */
+        if(buffer->mSampleLen > dataPosInt) LIKELY
+        {
+            const size_t buffer_remaining{buffer->mSampleLen - dataPosInt};
+            const size_t remaining{minz(samplesToLoad-samplesLoaded, buffer_remaining)};
+            LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, dataPosInt,
+                sampleType, srcStep, buffer->mBlockAlign, remaining);
+            samplesLoaded += remaining;
+        }
+
+        if(const size_t toFill{samplesToLoad - samplesLoaded})
+        {
+            auto srcsamples = voiceSamples + samplesLoaded;
+            std::fill_n(srcsamples, toFill, *(srcsamples-1));
+        }
+    }
+    else
+    {
+        const size_t loopStart{buffer->mLoopStart};
+        const size_t loopEnd{buffer->mLoopEnd};
+        ASSUME(loopEnd > loopStart);
+
+        const size_t intPos{(dataPosInt < loopEnd) ? dataPosInt
+            : (((dataPosInt-loopStart)%(loopEnd-loopStart)) + loopStart)};
+
+        /* Load what's left of this loop iteration */
+        const size_t remaining{minz(samplesToLoad-samplesLoaded, loopEnd-dataPosInt)};
+        LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, intPos, sampleType,
+            srcStep, buffer->mBlockAlign, remaining);
+        samplesLoaded += remaining;
+
+        /* Load repeats of the loop to fill the buffer. */
+        const size_t loopSize{loopEnd - loopStart};
+        while(const size_t toFill{minz(samplesToLoad - samplesLoaded, loopSize)})
+        {
+            LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, loopStart,
+                sampleType, srcStep, buffer->mBlockAlign, toFill);
+            samplesLoaded += toFill;
+        }
+    }
+}
+
+void LoadBufferCallback(VoiceBufferItem *buffer, const size_t dataPosInt,
+    const size_t numCallbackSamples, const FmtType sampleType, const size_t srcChannel,
+    const size_t srcStep, size_t samplesLoaded, const size_t samplesToLoad, float *voiceSamples)
+{
+    /* Load what's left to play from the buffer */
+    if(numCallbackSamples > dataPosInt) LIKELY
+    {
+        const size_t remaining{minz(samplesToLoad-samplesLoaded, numCallbackSamples-dataPosInt)};
+        LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, dataPosInt,
+            sampleType, srcStep, buffer->mBlockAlign, remaining);
+        samplesLoaded += remaining;
+    }
+
+    if(const size_t toFill{samplesToLoad - samplesLoaded})
+    {
+        auto srcsamples = voiceSamples + samplesLoaded;
+        std::fill_n(srcsamples, toFill, *(srcsamples-1));
+    }
+}
+
+void LoadBufferQueue(VoiceBufferItem *buffer, VoiceBufferItem *bufferLoopItem,
+    size_t dataPosInt, const FmtType sampleType, const size_t srcChannel,
+    const size_t srcStep, size_t samplesLoaded, const size_t samplesToLoad,
+    float *voiceSamples)
+{
+    /* Crawl the buffer queue to fill in the temp buffer */
+    while(buffer && samplesLoaded != samplesToLoad)
+    {
+        if(dataPosInt >= buffer->mSampleLen)
+        {
+            dataPosInt -= buffer->mSampleLen;
+            buffer = buffer->mNext.load(std::memory_order_acquire);
+            if(!buffer) buffer = bufferLoopItem;
+            continue;
+        }
+
+        const size_t remaining{minz(samplesToLoad-samplesLoaded, buffer->mSampleLen-dataPosInt)};
+        LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, dataPosInt,
+            sampleType, srcStep, buffer->mBlockAlign, remaining);
+
+        samplesLoaded += remaining;
+        if(samplesLoaded == samplesToLoad)
+            break;
+
+        dataPosInt = 0;
+        buffer = buffer->mNext.load(std::memory_order_acquire);
+        if(!buffer) buffer = bufferLoopItem;
+    }
+    if(const size_t toFill{samplesToLoad - samplesLoaded})
+    {
+        auto srcsamples = voiceSamples + samplesLoaded;
+        std::fill_n(srcsamples, toFill, *(srcsamples-1));
+    }
+}
+
+
+void DoHrtfMix(const float *samples, const uint DstBufferSize, DirectParams &parms,
+    const float TargetGain, const uint Counter, uint OutPos, const bool IsPlaying,
+    DeviceBase *Device)
+{
+    const uint IrSize{Device->mIrSize};
+    auto &HrtfSamples = Device->HrtfSourceData;
+    auto &AccumSamples = Device->HrtfAccumData;
+
+    /* Copy the HRTF history and new input samples into a temp buffer. */
+    auto src_iter = std::copy(parms.Hrtf.History.begin(), parms.Hrtf.History.end(),
+        std::begin(HrtfSamples));
+    std::copy_n(samples, DstBufferSize, src_iter);
+    /* Copy the last used samples back into the history buffer for later. */
+    if(IsPlaying) LIKELY
+        std::copy_n(std::begin(HrtfSamples) + DstBufferSize, parms.Hrtf.History.size(),
+            parms.Hrtf.History.begin());
+
+    /* If fading and this is the first mixing pass, fade between the IRs. */
+    uint fademix{0u};
+    if(Counter && OutPos == 0)
+    {
+        fademix = minu(DstBufferSize, Counter);
+
+        float gain{TargetGain};
+
+        /* The new coefficients need to fade in completely since they're
+         * replacing the old ones. To keep the gain fading consistent,
+         * interpolate between the old and new target gains given how much of
+         * the fade time this mix handles.
+         */
+        if(Counter > fademix)
+        {
+            const float a{static_cast<float>(fademix) / static_cast<float>(Counter)};
+            gain = lerpf(parms.Hrtf.Old.Gain, TargetGain, a);
+        }
+
+        MixHrtfFilter hrtfparams{
+            parms.Hrtf.Target.Coeffs,
+            parms.Hrtf.Target.Delay,
+            0.0f, gain / static_cast<float>(fademix)};
+        MixHrtfBlendSamples(HrtfSamples, AccumSamples+OutPos, IrSize, &parms.Hrtf.Old, &hrtfparams,
+            fademix);
+
+        /* Update the old parameters with the result. */
+        parms.Hrtf.Old = parms.Hrtf.Target;
+        parms.Hrtf.Old.Gain = gain;
+        OutPos += fademix;
+    }
+
+    if(fademix < DstBufferSize)
+    {
+        const uint todo{DstBufferSize - fademix};
+        float gain{TargetGain};
+
+        /* Interpolate the target gain if the gain fading lasts longer than
+         * this mix.
+         */
+        if(Counter > DstBufferSize)
+        {
+            const float a{static_cast<float>(todo) / static_cast<float>(Counter-fademix)};
+            gain = lerpf(parms.Hrtf.Old.Gain, TargetGain, a);
+        }
+
+        MixHrtfFilter hrtfparams{
+            parms.Hrtf.Target.Coeffs,
+            parms.Hrtf.Target.Delay,
+            parms.Hrtf.Old.Gain,
+            (gain - parms.Hrtf.Old.Gain) / static_cast<float>(todo)};
+        MixHrtfSamples(HrtfSamples+fademix, AccumSamples+OutPos, IrSize, &hrtfparams, todo);
+
+        /* Store the now-current gain for next time. */
+        parms.Hrtf.Old.Gain = gain;
+    }
+}
+
+void DoNfcMix(const al::span<const float> samples, FloatBufferLine *OutBuffer, DirectParams &parms,
+    const float *TargetGains, const uint Counter, const uint OutPos, DeviceBase *Device)
+{
+    using FilterProc = void (NfcFilter::*)(const al::span<const float>, float*);
+    static constexpr FilterProc NfcProcess[MaxAmbiOrder+1]{
+        nullptr, &NfcFilter::process1, &NfcFilter::process2, &NfcFilter::process3};
+
+    float *CurrentGains{parms.Gains.Current.data()};
+    MixSamples(samples, {OutBuffer, 1u}, CurrentGains, TargetGains, Counter, OutPos);
+    ++OutBuffer;
+    ++CurrentGains;
+    ++TargetGains;
+
+    const al::span<float> nfcsamples{Device->NfcSampleData, samples.size()};
+    size_t order{1};
+    while(const size_t chancount{Device->NumChannelsPerOrder[order]})
+    {
+        (parms.NFCtrlFilter.*NfcProcess[order])(samples, nfcsamples.data());
+        MixSamples(nfcsamples, {OutBuffer, chancount}, CurrentGains, TargetGains, Counter, OutPos);
+        OutBuffer += chancount;
+        CurrentGains += chancount;
+        TargetGains += chancount;
+        if(++order == MaxAmbiOrder+1)
+            break;
+    }
+}
+
+} // namespace
+
+void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds deviceTime,
+    const uint SamplesToDo)
+{
+    static constexpr std::array<float,MAX_OUTPUT_CHANNELS> SilentTarget{};
+
+    ASSUME(SamplesToDo > 0);
+
+    DeviceBase *Device{Context->mDevice};
+    const uint NumSends{Device->NumAuxSends};
+
+    /* Get voice info */
+    int DataPosInt{mPosition.load(std::memory_order_relaxed)};
+    uint DataPosFrac{mPositionFrac.load(std::memory_order_relaxed)};
+    VoiceBufferItem *BufferListItem{mCurrentBuffer.load(std::memory_order_relaxed)};
+    VoiceBufferItem *BufferLoopItem{mLoopBuffer.load(std::memory_order_relaxed)};
+    const uint increment{mStep};
+    if(increment < 1) UNLIKELY
+    {
+        /* If the voice is supposed to be stopping but can't be mixed, just
+         * stop it before bailing.
+         */
+        if(vstate == Stopping)
+            mPlayState.store(Stopped, std::memory_order_release);
+        return;
+    }
+
+    /* If the static voice's current position is beyond the buffer loop end
+     * position, disable looping.
+     */
+    if(mFlags.test(VoiceIsStatic) && BufferLoopItem)
+    {
+        if(DataPosInt >= 0 && static_cast<uint>(DataPosInt) >= BufferListItem->mLoopEnd)
+            BufferLoopItem = nullptr;
+    }
+
+    uint OutPos{0u};
+
+    /* Check if we're doing a delayed start, and we start in this update. */
+    if(mStartTime > deviceTime) UNLIKELY
+    {
+        /* If the voice is supposed to be stopping but hasn't actually started
+         * yet, make sure its stopped.
+         */
+        if(vstate == Stopping)
+        {
+            mPlayState.store(Stopped, std::memory_order_release);
+            return;
+        }
+
+        /* If the start time is too far ahead, don't bother. */
+        auto diff = mStartTime - deviceTime;
+        if(diff >= seconds{1})
+            return;
+
+        /* Get the number of samples ahead of the current time that output
+         * should start at. Skip this update if it's beyond the output sample
+         * count.
+         *
+         * Round the start position to a multiple of 4, which some mixers want.
+         * This makes the start time accurate to 4 samples. This could be made
+         * sample-accurate by forcing non-SIMD functions on the first run.
+         */
+        seconds::rep sampleOffset{duration_cast<seconds>(diff * Device->Frequency).count()};
+        sampleOffset = (sampleOffset+2) & ~seconds::rep{3};
+        if(sampleOffset >= SamplesToDo)
+            return;
+
+        OutPos = static_cast<uint>(sampleOffset);
+    }
+
+    /* Calculate the number of samples to mix, and the number of (resampled)
+     * samples that need to be loaded (mixing samples and decoder padding).
+     */
+    const uint samplesToMix{SamplesToDo - OutPos};
+    const uint samplesToLoad{samplesToMix + mDecoderPadding};
+
+    /* Get a span of pointers to hold the floating point, deinterlaced,
+     * resampled buffer data to be mixed.
+     */
+    std::array<float*,DeviceBase::MixerChannelsMax> SamplePointers;
+    const al::span<float*> MixingSamples{SamplePointers.data(), mChans.size()};
+    auto get_bufferline = [](DeviceBase::MixerBufferLine &bufline) noexcept -> float*
+    { return bufline.data(); };
+    std::transform(Device->mSampleData.end() - mChans.size(), Device->mSampleData.end(),
+        MixingSamples.begin(), get_bufferline);
+
+    /* If there's a matching sample step and no phase offset, use a simple copy
+     * for resampling.
+     */
+    const ResamplerFunc Resample{(increment == MixerFracOne && DataPosFrac == 0)
+        ? ResamplerFunc{[](const InterpState*, const float *RESTRICT src, uint, const uint,
+            const al::span<float> dst) { std::copy_n(src, dst.size(), dst.begin()); }}
+        : mResampler};
+
+    /* UHJ2 and SuperStereo only have 2 buffer channels, but 3 mixing channels
+     * (3rd channel is generated from decoding).
+     */
+    const size_t realChannels{(mFmtChannels == FmtUHJ2 || mFmtChannels == FmtSuperStereo) ? 2u
+        : MixingSamples.size()};
+    for(size_t chan{0};chan < realChannels;++chan)
+    {
+        using ResBufType = decltype(DeviceBase::mResampleData);
+        static constexpr uint srcSizeMax{static_cast<uint>(ResBufType{}.size()-MaxResamplerEdge)};
+
+        const auto prevSamples = al::as_span(mPrevSamples[chan]);
+        const auto resampleBuffer = std::copy(prevSamples.cbegin(), prevSamples.cend(),
+            Device->mResampleData.begin()) - MaxResamplerEdge;
+        int intPos{DataPosInt};
+        uint fracPos{DataPosFrac};
+
+        /* Load samples for this channel from the available buffer(s), with
+         * resampling.
+         */
+        for(uint samplesLoaded{0};samplesLoaded < samplesToLoad;)
+        {
+            /* Calculate the number of dst samples that can be loaded this
+             * iteration, given the available resampler buffer size, and the
+             * number of src samples that are needed to load it.
+             */
+            auto calc_buffer_sizes = [fracPos,increment](uint dstBufferSize)
+            {
+                /* If ext=true, calculate the last written dst pos from the dst
+                 * count, convert to the last read src pos, then add one to get
+                 * the src count.
+                 *
+                 * If ext=false, convert the dst count to src count directly.
+                 *
+                 * Without this, the src count could be short by one when
+                 * increment < 1.0, or not have a full src at the end when
+                 * increment > 1.0.
+                 */
+                const bool ext{increment <= MixerFracOne};
+                uint64_t dataSize64{dstBufferSize - ext};
+                dataSize64 = (dataSize64*increment + fracPos) >> MixerFracBits;
+                /* Also include resampler padding. */
+                dataSize64 += ext + MaxResamplerEdge;
+
+                if(dataSize64 <= srcSizeMax)
+                    return std::make_pair(dstBufferSize, static_cast<uint>(dataSize64));
+
+                /* If the source size got saturated, we can't fill the desired
+                 * dst size. Figure out how many dst samples we can fill.
+                 */
+                dataSize64 = srcSizeMax - MaxResamplerEdge;
+                dataSize64 = ((dataSize64<<MixerFracBits) - fracPos) / increment;
+                if(dataSize64 < dstBufferSize)
+                {
+                    /* Some resamplers require the destination being 16-byte
+                     * aligned, so limit to a multiple of 4 samples to maintain
+                     * alignment if we need to do another iteration after this.
+                     */
+                    dstBufferSize = static_cast<uint>(dataSize64) & ~3u;
+                }
+                return std::make_pair(dstBufferSize, srcSizeMax);
+            };
+            const auto bufferSizes = calc_buffer_sizes(samplesToLoad - samplesLoaded);
+            const auto dstBufferSize = bufferSizes.first;
+            const auto srcBufferSize = bufferSizes.second;
+
+            /* Load the necessary samples from the given buffer(s). */
+            if(!BufferListItem)
+            {
+                const uint avail{minu(srcBufferSize, MaxResamplerEdge)};
+                const uint tofill{maxu(srcBufferSize, MaxResamplerEdge)};
+
+                /* When loading from a voice that ended prematurely, only take
+                 * the samples that get closest to 0 amplitude. This helps
+                 * certain sounds fade out better.
+                 */
+                auto abs_lt = [](const float lhs, const float rhs) noexcept -> bool
+                { return std::abs(lhs) < std::abs(rhs); };
+                auto srciter = std::min_element(resampleBuffer, resampleBuffer+avail, abs_lt);
+
+                std::fill(srciter+1, resampleBuffer+tofill, *srciter);
+            }
+            else
+            {
+                size_t srcSampleDelay{0};
+                if(intPos < 0) UNLIKELY
+                {
+                    /* If the current position is negative, there's that many
+                     * silent samples to load before using the buffer.
+                     */
+                    srcSampleDelay = static_cast<uint>(-intPos);
+                    if(srcSampleDelay >= srcBufferSize)
+                    {
+                        /* If the number of silent source samples exceeds the
+                         * number to load, the output will be silent.
+                         */
+                        std::fill_n(MixingSamples[chan]+samplesLoaded, dstBufferSize, 0.0f);
+                        std::fill_n(resampleBuffer, srcBufferSize, 0.0f);
+                        goto skip_resample;
+                    }
+
+                    std::fill_n(resampleBuffer, srcSampleDelay, 0.0f);
+                }
+                const uint uintPos{static_cast<uint>(maxi(intPos, 0))};
+
+                if(mFlags.test(VoiceIsStatic))
+                    LoadBufferStatic(BufferListItem, BufferLoopItem, uintPos, mFmtType, chan,
+                        mFrameStep, srcSampleDelay, srcBufferSize, al::to_address(resampleBuffer));
+                else if(mFlags.test(VoiceIsCallback))
+                {
+                    const uint callbackBase{mCallbackBlockBase * mSamplesPerBlock};
+                    const size_t bufferOffset{uintPos - callbackBase};
+                    const size_t needSamples{bufferOffset + srcBufferSize - srcSampleDelay};
+                    const size_t needBlocks{(needSamples + mSamplesPerBlock-1) / mSamplesPerBlock};
+                    if(!mFlags.test(VoiceCallbackStopped) && needBlocks > mNumCallbackBlocks)
+                    {
+                        const size_t byteOffset{mNumCallbackBlocks*mBytesPerBlock};
+                        const size_t needBytes{(needBlocks-mNumCallbackBlocks)*mBytesPerBlock};
+
+                        const int gotBytes{BufferListItem->mCallback(BufferListItem->mUserData,
+                            &BufferListItem->mSamples[byteOffset], static_cast<int>(needBytes))};
+                        if(gotBytes < 0)
+                            mFlags.set(VoiceCallbackStopped);
+                        else if(static_cast<uint>(gotBytes) < needBytes)
+                        {
+                            mFlags.set(VoiceCallbackStopped);
+                            mNumCallbackBlocks += static_cast<uint>(gotBytes) / mBytesPerBlock;
+                        }
+                        else
+                            mNumCallbackBlocks = static_cast<uint>(needBlocks);
+                    }
+                    const size_t numSamples{uint{mNumCallbackBlocks} * mSamplesPerBlock};
+                    LoadBufferCallback(BufferListItem, bufferOffset, numSamples, mFmtType, chan,
+                        mFrameStep, srcSampleDelay, srcBufferSize, al::to_address(resampleBuffer));
+                }
+                else
+                    LoadBufferQueue(BufferListItem, BufferLoopItem, uintPos, mFmtType, chan,
+                        mFrameStep, srcSampleDelay, srcBufferSize, al::to_address(resampleBuffer));
+            }
+
+            Resample(&mResampleState, al::to_address(resampleBuffer), fracPos, increment,
+                {MixingSamples[chan]+samplesLoaded, dstBufferSize});
+
+            /* Store the last source samples used for next time. */
+            if(vstate == Playing) LIKELY
+            {
+                /* Only store samples for the end of the mix, excluding what
+                 * gets loaded for decoder padding.
+                 */
+                const uint loadEnd{samplesLoaded + dstBufferSize};
+                if(samplesToMix > samplesLoaded && samplesToMix <= loadEnd) LIKELY
+                {
+                    const size_t dstOffset{samplesToMix - samplesLoaded};
+                    const size_t srcOffset{(dstOffset*increment + fracPos) >> MixerFracBits};
+                    std::copy_n(resampleBuffer-MaxResamplerEdge+srcOffset, prevSamples.size(),
+                        prevSamples.begin());
+                }
+            }
+
+        skip_resample:
+            samplesLoaded += dstBufferSize;
+            if(samplesLoaded < samplesToLoad)
+            {
+                fracPos += dstBufferSize*increment;
+                const uint srcOffset{fracPos >> MixerFracBits};
+                fracPos &= MixerFracMask;
+                intPos += srcOffset;
+
+                /* If more samples need to be loaded, copy the back of the
+                 * resampleBuffer to the front to reuse it. prevSamples isn't
+                 * reliable since it's only updated for the end of the mix.
+                 */
+                std::copy(resampleBuffer-MaxResamplerEdge+srcOffset,
+                    resampleBuffer+MaxResamplerEdge+srcOffset, resampleBuffer-MaxResamplerEdge);
+            }
+        }
+    }
+    for(auto &samples : MixingSamples.subspan(realChannels))
+        std::fill_n(samples, samplesToLoad, 0.0f);
+
+    if(mDecoder)
+        mDecoder->decode(MixingSamples, samplesToMix, (vstate==Playing));
+
+    if(mFlags.test(VoiceIsAmbisonic))
+    {
+        auto voiceSamples = MixingSamples.begin();
+        for(auto &chandata : mChans)
+        {
+            chandata.mAmbiSplitter.processScale({*voiceSamples, samplesToMix},
+                chandata.mAmbiHFScale, chandata.mAmbiLFScale);
+            ++voiceSamples;
+        }
+    }
+
+    const uint Counter{mFlags.test(VoiceIsFading) ? minu(samplesToMix, 64u) : 0u};
+    if(!Counter)
+    {
+        /* No fading, just overwrite the old/current params. */
+        for(auto &chandata : mChans)
+        {
+            {
+                DirectParams &parms = chandata.mDryParams;
+                if(!mFlags.test(VoiceHasHrtf))
+                    parms.Gains.Current = parms.Gains.Target;
+                else
+                    parms.Hrtf.Old = parms.Hrtf.Target;
+            }
+            for(uint send{0};send < NumSends;++send)
+            {
+                if(mSend[send].Buffer.empty())
+                    continue;
+
+                SendParams &parms = chandata.mWetParams[send];
+                parms.Gains.Current = parms.Gains.Target;
+            }
+        }
+    }
+
+    auto voiceSamples = MixingSamples.begin();
+    for(auto &chandata : mChans)
+    {
+        /* Now filter and mix to the appropriate outputs. */
+        const al::span<float,BufferLineSize> FilterBuf{Device->FilteredData};
+        {
+            DirectParams &parms = chandata.mDryParams;
+            const float *samples{DoFilters(parms.LowPass, parms.HighPass, FilterBuf.data(),
+                {*voiceSamples, samplesToMix}, mDirect.FilterType)};
+
+            if(mFlags.test(VoiceHasHrtf))
+            {
+                const float TargetGain{parms.Hrtf.Target.Gain * (vstate == Playing)};
+                DoHrtfMix(samples, samplesToMix, parms, TargetGain, Counter, OutPos,
+                    (vstate == Playing), Device);
+            }
+            else
+            {
+                const float *TargetGains{(vstate == Playing) ? parms.Gains.Target.data()
+                    : SilentTarget.data()};
+                if(mFlags.test(VoiceHasNfc))
+                    DoNfcMix({samples, samplesToMix}, mDirect.Buffer.data(), parms,
+                        TargetGains, Counter, OutPos, Device);
+                else
+                    MixSamples({samples, samplesToMix}, mDirect.Buffer,
+                        parms.Gains.Current.data(), TargetGains, Counter, OutPos);
+            }
+        }
+
+        for(uint send{0};send < NumSends;++send)
+        {
+            if(mSend[send].Buffer.empty())
+                continue;
+
+            SendParams &parms = chandata.mWetParams[send];
+            const float *samples{DoFilters(parms.LowPass, parms.HighPass, FilterBuf.data(),
+                {*voiceSamples, samplesToMix}, mSend[send].FilterType)};
+
+            const float *TargetGains{(vstate == Playing) ? parms.Gains.Target.data()
+                : SilentTarget.data()};
+            MixSamples({samples, samplesToMix}, mSend[send].Buffer,
+                parms.Gains.Current.data(), TargetGains, Counter, OutPos);
+        }
+
+        ++voiceSamples;
+    }
+
+    mFlags.set(VoiceIsFading);
+
+    /* Don't update positions and buffers if we were stopping. */
+    if(vstate == Stopping) UNLIKELY
+    {
+        mPlayState.store(Stopped, std::memory_order_release);
+        return;
+    }
+
+    /* Update voice positions and buffers as needed. */
+    DataPosFrac += increment*samplesToMix;
+    const uint SrcSamplesDone{DataPosFrac>>MixerFracBits};
+    DataPosInt  += SrcSamplesDone;
+    DataPosFrac &= MixerFracMask;
+
+    uint buffers_done{0u};
+    if(BufferListItem && DataPosInt >= 0) LIKELY
+    {
+        if(mFlags.test(VoiceIsStatic))
+        {
+            if(BufferLoopItem)
+            {
+                /* Handle looping static source */
+                const uint LoopStart{BufferListItem->mLoopStart};
+                const uint LoopEnd{BufferListItem->mLoopEnd};
+                uint DataPosUInt{static_cast<uint>(DataPosInt)};
+                if(DataPosUInt >= LoopEnd)
+                {
+                    assert(LoopEnd > LoopStart);
+                    DataPosUInt = ((DataPosUInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
+                    DataPosInt = static_cast<int>(DataPosUInt);
+                }
+            }
+            else
+            {
+                /* Handle non-looping static source */
+                if(static_cast<uint>(DataPosInt) >= BufferListItem->mSampleLen)
+                    BufferListItem = nullptr;
+            }
+        }
+        else if(mFlags.test(VoiceIsCallback))
+        {
+            /* Handle callback buffer source */
+            const uint currentBlock{static_cast<uint>(DataPosInt) / mSamplesPerBlock};
+            const uint blocksDone{currentBlock - mCallbackBlockBase};
+            if(blocksDone < mNumCallbackBlocks)
+            {
+                const size_t byteOffset{blocksDone*mBytesPerBlock};
+                const size_t byteEnd{mNumCallbackBlocks*mBytesPerBlock};
+                al::byte *data{BufferListItem->mSamples};
+                std::copy(data+byteOffset, data+byteEnd, data);
+                mNumCallbackBlocks -= blocksDone;
+                mCallbackBlockBase += blocksDone;
+            }
+            else
+            {
+                BufferListItem = nullptr;
+                mNumCallbackBlocks = 0;
+                mCallbackBlockBase += blocksDone;
+            }
+        }
+        else
+        {
+            /* Handle streaming source */
+            do {
+                if(BufferListItem->mSampleLen > static_cast<uint>(DataPosInt))
+                    break;
+
+                DataPosInt -= BufferListItem->mSampleLen;
+
+                ++buffers_done;
+                BufferListItem = BufferListItem->mNext.load(std::memory_order_relaxed);
+                if(!BufferListItem) BufferListItem = BufferLoopItem;
+            } while(BufferListItem);
+        }
+    }
+
+    /* Capture the source ID in case it gets reset for stopping. */
+    const uint SourceID{mSourceID.load(std::memory_order_relaxed)};
+
+    /* Update voice info */
+    mPosition.store(DataPosInt, std::memory_order_relaxed);
+    mPositionFrac.store(DataPosFrac, std::memory_order_relaxed);
+    mCurrentBuffer.store(BufferListItem, std::memory_order_relaxed);
+    if(!BufferListItem)
+    {
+        mLoopBuffer.store(nullptr, std::memory_order_relaxed);
+        mSourceID.store(0u, std::memory_order_relaxed);
+    }
+    std::atomic_thread_fence(std::memory_order_release);
+
+    /* Send any events now, after the position/buffer info was updated. */
+    const auto enabledevt = Context->mEnabledEvts.load(std::memory_order_acquire);
+    if(buffers_done > 0 && enabledevt.test(AsyncEvent::BufferCompleted))
+    {
+        RingBuffer *ring{Context->mAsyncEvents.get()};
+        auto evt_vec = ring->getWriteVector();
+        if(evt_vec.first.len > 0)
+        {
+            AsyncEvent *evt{al::construct_at(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf),
+                AsyncEvent::BufferCompleted)};
+            evt->u.bufcomp.id = SourceID;
+            evt->u.bufcomp.count = buffers_done;
+            ring->writeAdvance(1);
+        }
+    }
+
+    if(!BufferListItem)
+    {
+        /* If the voice just ended, set it to Stopping so the next render
+         * ensures any residual noise fades to 0 amplitude.
+         */
+        mPlayState.store(Stopping, std::memory_order_release);
+        if(enabledevt.test(AsyncEvent::SourceStateChange))
+            SendSourceStoppedEvent(Context, SourceID);
+    }
+}
+
+void Voice::prepare(DeviceBase *device)
+{
+    /* Even if storing really high order ambisonics, we only mix channels for
+     * orders up to the device order. The rest are simply dropped.
+     */
+    uint num_channels{(mFmtChannels == FmtUHJ2 || mFmtChannels == FmtSuperStereo) ? 3 :
+        ChannelsFromFmt(mFmtChannels, minu(mAmbiOrder, device->mAmbiOrder))};
+    if(num_channels > device->mSampleData.size()) UNLIKELY
+    {
+        ERR("Unexpected channel count: %u (limit: %zu, %d:%d)\n", num_channels,
+            device->mSampleData.size(), mFmtChannels, mAmbiOrder);
+        num_channels = static_cast<uint>(device->mSampleData.size());
+    }
+    if(mChans.capacity() > 2 && num_channels < mChans.capacity())
+    {
+        decltype(mChans){}.swap(mChans);
+        decltype(mPrevSamples){}.swap(mPrevSamples);
+    }
+    mChans.reserve(maxu(2, num_channels));
+    mChans.resize(num_channels);
+    mPrevSamples.reserve(maxu(2, num_channels));
+    mPrevSamples.resize(num_channels);
+
+    mDecoder = nullptr;
+    mDecoderPadding = 0;
+    if(mFmtChannels == FmtSuperStereo)
+    {
+        switch(UhjDecodeQuality)
+        {
+        case UhjQualityType::IIR:
+            mDecoder = std::make_unique<UhjStereoDecoderIIR>();
+            mDecoderPadding = UhjStereoDecoderIIR::sInputPadding;
+            break;
+        case UhjQualityType::FIR256:
+            mDecoder = std::make_unique<UhjStereoDecoder<UhjLength256>>();
+            mDecoderPadding = UhjStereoDecoder<UhjLength256>::sInputPadding;
+            break;
+        case UhjQualityType::FIR512:
+            mDecoder = std::make_unique<UhjStereoDecoder<UhjLength512>>();
+            mDecoderPadding = UhjStereoDecoder<UhjLength512>::sInputPadding;
+            break;
+        }
+    }
+    else if(IsUHJ(mFmtChannels))
+    {
+        switch(UhjDecodeQuality)
+        {
+        case UhjQualityType::IIR:
+            mDecoder = std::make_unique<UhjDecoderIIR>();
+            mDecoderPadding = UhjDecoderIIR::sInputPadding;
+            break;
+        case UhjQualityType::FIR256:
+            mDecoder = std::make_unique<UhjDecoder<UhjLength256>>();
+            mDecoderPadding = UhjDecoder<UhjLength256>::sInputPadding;
+            break;
+        case UhjQualityType::FIR512:
+            mDecoder = std::make_unique<UhjDecoder<UhjLength512>>();
+            mDecoderPadding = UhjDecoder<UhjLength512>::sInputPadding;
+            break;
+        }
+    }
+
+    /* Clear the stepping value explicitly so the mixer knows not to mix this
+     * until the update gets applied.
+     */
+    mStep = 0;
+
+    /* Make sure the sample history is cleared. */
+    std::fill(mPrevSamples.begin(), mPrevSamples.end(), HistoryLine{});
+
+    if(mFmtChannels == FmtUHJ2 && !device->mUhjEncoder)
+    {
+        /* 2-channel UHJ needs different shelf filters. However, we can't just
+         * use different shelf filters after mixing it, given any old speaker
+         * setup the user has. To make this work, we apply the expected shelf
+         * filters for decoding UHJ2 to quad (only needs LF scaling), and act
+         * as if those 4 quad channels are encoded right back into B-Format.
+         *
+         * This isn't perfect, but without an entirely separate and limited
+         * UHJ2 path, it's better than nothing.
+         *
+         * Note this isn't needed with UHJ output (UHJ2->B-Format->UHJ2 is
+         * identity, so don't mess with it).
+         */
+        const BandSplitter splitter{device->mXOverFreq / static_cast<float>(device->Frequency)};
+        for(auto &chandata : mChans)
+        {
+            chandata.mAmbiHFScale = 1.0f;
+            chandata.mAmbiLFScale = 1.0f;
+            chandata.mAmbiSplitter = splitter;
+            chandata.mDryParams = DirectParams{};
+            chandata.mDryParams.NFCtrlFilter = device->mNFCtrlFilter;
+            std::fill_n(chandata.mWetParams.begin(), device->NumAuxSends, SendParams{});
+        }
+        mChans[0].mAmbiLFScale = DecoderBase::sWLFScale;
+        mChans[1].mAmbiLFScale = DecoderBase::sXYLFScale;
+        mChans[2].mAmbiLFScale = DecoderBase::sXYLFScale;
+        mFlags.set(VoiceIsAmbisonic);
+    }
+    /* Don't need to set the VoiceIsAmbisonic flag if the device is not higher
+     * order than the voice. No HF scaling is necessary to mix it.
+     */
+    else if(mAmbiOrder && device->mAmbiOrder > mAmbiOrder)
+    {
+        const uint8_t *OrderFromChan{Is2DAmbisonic(mFmtChannels) ?
+            AmbiIndex::OrderFrom2DChannel().data() : AmbiIndex::OrderFromChannel().data()};
+        const auto scales = AmbiScale::GetHFOrderScales(mAmbiOrder, device->mAmbiOrder,
+            device->m2DMixing);
+
+        const BandSplitter splitter{device->mXOverFreq / static_cast<float>(device->Frequency)};
+        for(auto &chandata : mChans)
+        {
+            chandata.mAmbiHFScale = scales[*(OrderFromChan++)];
+            chandata.mAmbiLFScale = 1.0f;
+            chandata.mAmbiSplitter = splitter;
+            chandata.mDryParams = DirectParams{};
+            chandata.mDryParams.NFCtrlFilter = device->mNFCtrlFilter;
+            std::fill_n(chandata.mWetParams.begin(), device->NumAuxSends, SendParams{});
+        }
+        mFlags.set(VoiceIsAmbisonic);
+    }
+    else
+    {
+        for(auto &chandata : mChans)
+        {
+            chandata.mDryParams = DirectParams{};
+            chandata.mDryParams.NFCtrlFilter = device->mNFCtrlFilter;
+            std::fill_n(chandata.mWetParams.begin(), device->NumAuxSends, SendParams{});
+        }
+        mFlags.reset(VoiceIsAmbisonic);
+    }
+}
diff --git a/core/voice.h b/core/voice.h
new file mode 100644
index 00000000..57ee7b01
--- /dev/null
+++ b/core/voice.h
@@ -0,0 +1,280 @@
+#ifndef CORE_VOICE_H
+#define CORE_VOICE_H
+
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <chrono>
+#include <memory>
+#include <stddef.h>
+#include <string>
+
+#include "albyte.h"
+#include "almalloc.h"
+#include "aloptional.h"
+#include "alspan.h"
+#include "bufferline.h"
+#include "buffer_storage.h"
+#include "devformat.h"
+#include "filters/biquad.h"
+#include "filters/nfc.h"
+#include "filters/splitter.h"
+#include "mixer/defs.h"
+#include "mixer/hrtfdefs.h"
+#include "resampler_limits.h"
+#include "uhjfilter.h"
+#include "vector.h"
+
+struct ContextBase;
+struct DeviceBase;
+struct EffectSlot;
+enum class DistanceModel : unsigned char;
+
+using uint = unsigned int;
+
+
+#define MAX_SENDS  6
+
+
+enum class SpatializeMode : unsigned char {
+    Off,
+    On,
+    Auto
+};
+
+enum class DirectMode : unsigned char {
+    Off,
+    DropMismatch,
+    RemixMismatch
+};
+
+
+constexpr uint MaxPitch{10};
+
+
+enum {
+    AF_None = 0,
+    AF_LowPass = 1,
+    AF_HighPass = 2,
+    AF_BandPass = AF_LowPass | AF_HighPass
+};
+
+
+struct DirectParams {
+    BiquadFilter LowPass;
+    BiquadFilter HighPass;
+
+    NfcFilter NFCtrlFilter;
+
+    struct {
+        HrtfFilter Old;
+        HrtfFilter Target;
+        alignas(16) std::array<float,HrtfHistoryLength> History;
+    } Hrtf;
+
+    struct {
+        std::array<float,MAX_OUTPUT_CHANNELS> Current;
+        std::array<float,MAX_OUTPUT_CHANNELS> Target;
+    } Gains;
+};
+
+struct SendParams {
+    BiquadFilter LowPass;
+    BiquadFilter HighPass;
+
+    struct {
+        std::array<float,MaxAmbiChannels> Current;
+        std::array<float,MaxAmbiChannels> Target;
+    } Gains;
+};
+
+
+struct VoiceBufferItem {
+    std::atomic<VoiceBufferItem*> mNext{nullptr};
+
+    CallbackType mCallback{nullptr};
+    void *mUserData{nullptr};
+
+    uint mBlockAlign{0u};
+    uint mSampleLen{0u};
+    uint mLoopStart{0u};
+    uint mLoopEnd{0u};
+
+    al::byte *mSamples{nullptr};
+};
+
+
+struct VoiceProps {
+    float Pitch;
+    float Gain;
+    float OuterGain;
+    float MinGain;
+    float MaxGain;
+    float InnerAngle;
+    float OuterAngle;
+    float RefDistance;
+    float MaxDistance;
+    float RolloffFactor;
+    std::array<float,3> Position;
+    std::array<float,3> Velocity;
+    std::array<float,3> Direction;
+    std::array<float,3> OrientAt;
+    std::array<float,3> OrientUp;
+    bool HeadRelative;
+    DistanceModel mDistanceModel;
+    Resampler mResampler;
+    DirectMode DirectChannels;
+    SpatializeMode mSpatializeMode;
+
+    bool DryGainHFAuto;
+    bool WetGainAuto;
+    bool WetGainHFAuto;
+    float OuterGainHF;
+
+    float AirAbsorptionFactor;
+    float RoomRolloffFactor;
+    float DopplerFactor;
+
+    std::array<float,2> StereoPan;
+
+    float Radius;
+    float EnhWidth;
+
+    /** Direct filter and auxiliary send info. */
+    struct {
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
+    } Direct;
+    struct SendData {
+        EffectSlot *Slot;
+        float Gain;
+        float GainHF;
+        float HFReference;
+        float GainLF;
+        float LFReference;
+    } Send[MAX_SENDS];
+};
+
+struct VoicePropsItem : public VoiceProps {
+    std::atomic<VoicePropsItem*> next{nullptr};
+
+    DEF_NEWDEL(VoicePropsItem)
+};
+
+enum : uint {
+    VoiceIsStatic,
+    VoiceIsCallback,
+    VoiceIsAmbisonic,
+    VoiceCallbackStopped,
+    VoiceIsFading,
+    VoiceHasHrtf,
+    VoiceHasNfc,
+
+    VoiceFlagCount
+};
+
+struct Voice {
+    enum State {
+        Stopped,
+        Playing,
+        Stopping,
+        Pending
+    };
+
+    std::atomic<VoicePropsItem*> mUpdate{nullptr};
+
+    VoiceProps mProps;
+
+    std::atomic<uint> mSourceID{0u};
+    std::atomic<State> mPlayState{Stopped};
+    std::atomic<bool> mPendingChange{false};
+
+    /**
+     * Source offset in samples, relative to the currently playing buffer, NOT
+     * the whole queue.
+     */
+    std::atomic<int> mPosition;
+    /** Fractional (fixed-point) offset to the next sample. */
+    std::atomic<uint> mPositionFrac;
+
+    /* Current buffer queue item being played. */
+    std::atomic<VoiceBufferItem*> mCurrentBuffer;
+
+    /* Buffer queue item to loop to at end of queue (will be NULL for non-
+     * looping voices).
+     */
+    std::atomic<VoiceBufferItem*> mLoopBuffer;
+
+    std::chrono::nanoseconds mStartTime{};
+
+    /* Properties for the attached buffer(s). */
+    FmtChannels mFmtChannels;
+    FmtType mFmtType;
+    uint mFrequency;
+    uint mFrameStep; /**< In steps of the sample type size. */
+    uint mBytesPerBlock; /**< Or for PCM formats, BytesPerFrame. */
+    uint mSamplesPerBlock; /**< Always 1 for PCM formats. */
+    AmbiLayout mAmbiLayout;
+    AmbiScaling mAmbiScaling;
+    uint mAmbiOrder;
+
+    std::unique_ptr<DecoderBase> mDecoder;
+    uint mDecoderPadding{};
+
+    /** Current target parameters used for mixing. */
+    uint mStep{0};
+
+    ResamplerFunc mResampler;
+
+    InterpState mResampleState;
+
+    std::bitset<VoiceFlagCount> mFlags{};
+    uint mNumCallbackBlocks{0};
+    uint mCallbackBlockBase{0};
+
+    struct TargetData {
+        int FilterType;
+        al::span<FloatBufferLine> Buffer;
+    };
+    TargetData mDirect;
+    std::array<TargetData,MAX_SENDS> mSend;
+
+    /* The first MaxResamplerPadding/2 elements are the sample history from the
+     * previous mix, with an additional MaxResamplerPadding/2 elements that are
+     * now current (which may be overwritten if the buffer data is still
+     * available).
+     */
+    using HistoryLine = std::array<float,MaxResamplerPadding>;
+    al::vector<HistoryLine,16> mPrevSamples{2};
+
+    struct ChannelData {
+        float mAmbiHFScale, mAmbiLFScale;
+        BandSplitter mAmbiSplitter;
+
+        DirectParams mDryParams;
+        std::array<SendParams,MAX_SENDS> mWetParams;
+    };
+    al::vector<ChannelData> mChans{2};
+
+    Voice() = default;
+    ~Voice() = default;
+
+    Voice(const Voice&) = delete;
+    Voice& operator=(const Voice&) = delete;
+
+    void mix(const State vstate, ContextBase *Context, const std::chrono::nanoseconds deviceTime,
+        const uint SamplesToDo);
+
+    void prepare(DeviceBase *device);
+
+    static void InitMixer(al::optional<std::string> resampler);
+
+    DEF_NEWDEL(Voice)
+};
+
+extern Resampler ResamplerDefault;
+
+#endif /* CORE_VOICE_H */
diff --git a/core/voice_change.h b/core/voice_change.h
new file mode 100644
index 00000000..ddc6186f
--- /dev/null
+++ b/core/voice_change.h
@@ -0,0 +1,31 @@
+#ifndef VOICE_CHANGE_H
+#define VOICE_CHANGE_H
+
+#include <atomic>
+
+#include "almalloc.h"
+
+struct Voice;
+
+using uint = unsigned int;
+
+
+enum class VChangeState {
+    Reset,
+    Stop,
+    Play,
+    Pause,
+    Restart
+};
+struct VoiceChange {
+    Voice *mOldVoice{nullptr};
+    Voice *mVoice{nullptr};
+    uint mSourceID{0};
+    VChangeState mState{};
+
+    std::atomic<VoiceChange*> mNext{nullptr};
+
+    DEF_NEWDEL(VoiceChange)
+};
+
+#endif /* VOICE_CHANGE_H */
diff --git a/docs/3D7.1.txt b/docs/3D7.1.txt
index 1d40bec6..b7249c22 100644
--- a/docs/3D7.1.txt
+++ b/docs/3D7.1.txt
@@ -58,17 +58,10 @@ Software Setup
 ==============
 
 To enable 3D7.1 on OpenAL Soft, first make sure the audio device is configured
-for 7.1 output. Then in the alsoft-config utility, under the Renderer tab,
-select the 3D7.1.ambdec preset for the 7.1 Surround decoder configuration. And
-that's it. Any applications using OpenAL Soft can take advantage of fully 3D
-audio, and multi-channel sounds will be properly remixed for the speaker
-layout.
-
-Playback can be improved by (copying and) modifying the 3D7.1.ambdec preset,
-changing the specified speaker distances to match the the real distance (in
-meters) from the center of the speaker array, then enable High Quality Mode in
-alsoft-config. That will improve the quality when the speakers are not all
-equidistant.
+for 7.1 output. Then in the alsoft-config utility, for the Channels setting
+choose "3D7.1 Surround" from the drop-down list. And that's it. Any application
+using OpenAL Soft can take advantage of fully 3D audio, and multi-channel
+sounds will be properly remixed for the speaker layout.
 
 Note that care must be taken that the audio device is not treated as a "true"
 7.1 device by non-3D7.1-capable applications. In particular, the audio server
diff --git a/docs/ambdec.txt b/docs/ambdec.txt
index 1f328937..a301004c 100644
--- a/docs/ambdec.txt
+++ b/docs/ambdec.txt
@@ -13,7 +13,7 @@ about ambisonics.
 
 Starting with OpenAL Soft 1.18, version 3 of the file format is supported as a
 means of specifying custom surround sound speaker layouts. These configuration
-files are also used to enable the high-quality ambisonic decoder.
+files are also used to enable per-speaker distance compensation.
 
 
 File Format
@@ -155,11 +155,14 @@ LB = Back left
 RB = Back right
 CE = Front center
 CB = Back center
+LFT = Top front left
+RFT = Top front right
+LBT = Top back left
+RBT = Top back right
 
 Additionally, configuration files for surround51 will acknowledge back speakers
-for side channels, and surround51rear will acknowledge side speakers for back
-channels, to avoid issues with a configuration expecting 5.1 to use the side
-channels when the device is configured for back, or vice-versa.
+for side channels, to avoid issues with a configuration expecting 5.1 to use
+the side channels when the device is configured for back, or vice-versa.
 
 Furthermore, OpenAL Soft does not require a speaker definition for each output
 channel the configuration is used with. So for example a 5.1 configuration may
diff --git a/docs/ambisonics.txt b/docs/ambisonics.txt
index b03e3bed..b1b111d6 100644
--- a/docs/ambisonics.txt
+++ b/docs/ambisonics.txt
@@ -72,19 +72,12 @@ How Is It Used?
 ===============
 
 As a 3D audio API, OpenAL is tasked with playing 3D sound as best it can with
-the speaker setup the user has. Since the OpenAL API does not explicitly handle
-the output channel configuration, it has a lot of leeway in how to deal with
-the audio before it's played back for the user to hear. Consequently, OpenAL
-Soft (or any other OpenAL implementation that wishes to) can render using
-Ambisonics and decode the ambisonic mix for a high level of accuracy over what
-simple pan-pot could provide.
-
-When given an appropriate decoder configuration for the channel layout, the
-ambisonic mix can be decoded utilizing the benefits available to ambisonic
-processing, including frequency-dependent processing and near-field effects.
-Without a decoder configuration, the ambisonic mix can still be decoded for
-good stereo or surround sound output, although without near-field effects as
-there's no speaker distance information.
+the speaker setup the user has. Since the OpenAL API doesn't expose discrete
+playback speaker feeds, an implementation has a lot of leeway with how to deal
+with the audio before it's played back for the user to hear. Consequently,
+OpenAL Soft (or any other OpenAL implementation that wishes to) can render
+using Ambisonics and decode the ambisonic mix for a high level of accuracy over
+what simple pan-pot could provide.
 
 In addition to surround sound output, Ambisonics also has benefits with stereo
 output. 2-channel UHJ is a stereo-compatible format that encodes some surround
diff --git a/docs/env-vars.txt b/docs/env-vars.txt
index fee9ffb0..815a3098 100644
--- a/docs/env-vars.txt
+++ b/docs/env-vars.txt
@@ -58,14 +58,25 @@ between 0 and 180 degrees, instead of the expected range of 0 to 360 degrees.
 Setting this to "true" or "1" restores the old buggy behavior, for apps that
 were written to expect the incorrect range.
 
+__ALSOFT_ENABLE_SUB_DATA_EXT
+The more widely used AL_EXT_SOURCE_RADIUS extension is incompatible with the
+now-defunct AL_SOFT_buffer_sub_data extension. Setting this to "true" or "1"
+restores the AL_SOFT_buffer_sub_data extension for apps that require it,
+disabling AL_EXT_SOURCE_RADIUS.
+
 __ALSOFT_REVERSE_Z
 Applications that don't natively use OpenAL's coordinate system have to convert
 to it before passing in 3D coordinates. Depending on how exactly this is done,
 it can cause correct output for stereo but incorrect Z panning for surround
 sound (i.e., sounds that are supposed to be behind you sound like they're in
 front, and vice-versa). Setting this to "true" or "1" will negate the localized
-Z coordinate to attempt to fix output for apps that have incorrect front/back
-panning.
+Z coordinate to flip front/back panning for 3D sources.
+
+__ALSOFT_REVERSE_Y
+Same as for __ALSOFT_REVERSE_Z, but for Y (up/down) panning.
+
+__ALSOFT_REVERSE_X
+Same as for __ALSOFT_REVERSE_Z, but for X (left/right) panning.
 
 __ALSOFT_SUSPEND_CONTEXT
 Due to the OpenAL spec not being very clear about them, behavior of the
diff --git a/docs/hrtf.txt b/docs/hrtf.txt
index ba8cd8fa..0ea27caa 100644
--- a/docs/hrtf.txt
+++ b/docs/hrtf.txt
@@ -13,25 +13,22 @@ including above and below the listener, instead of just to the front, back, and
 sides.
 
 The default data set is based on the KEMAR HRTF data provided by MIT, which can
-be found at <http://sound.media.mit.edu/resources/KEMAR.html>. It's only
-available when using 44100hz or 48000hz playback.
+be found at <http://sound.media.mit.edu/resources/KEMAR.html>.
 
 
 Custom HRTF Data Sets
 =====================
 
 OpenAL Soft also provides an option to use user-specified data sets, in
-addition to or in place of the default set. This allows users to provide their
-own data sets, which could be better suited for their heads, or to work with
-stereo speakers instead of headphones, or to support more playback sample
-rates, for example.
+addition to or in place of the default set. This allows users to provide data
+sets that could be better suited for their heads, or to work with stereo
+speakers instead of headphones, for example.
 
 The file format is specified below. It uses little-endian byte order.
 
 ==
-ALchar   magic[8] = "MinPHR02";
+ALchar   magic[8] = "MinPHR03";
 ALuint   sampleRate;
-ALubyte  sampleType;  /* Can be 0 (16-bit) or 1 (24-bit). */
 ALubyte  channelType; /* Can be 0 (mono) or 1 (stereo). */
 ALubyte  hrirSize;    /* Can be 8 to 128 in steps of 8. */
 ALubyte  fdCount;     /* Can be 1 to 16. */
@@ -42,28 +39,30 @@ struct {
     ALubyte azCount[evCount]; /* Each can be 1 to 128. */
 } fields[fdCount];
 
-/* NOTE: ALtype can be ALshort (16-bit) or ALbyte[3] (24-bit) depending on
- * sampleType,
+/* NOTE: ALbyte3 is a packed 24-bit sample type,
  * hrirCount is the sum of all azCounts.
  * channels can be 1 (mono) or 2 (stereo) depending on channelType.
  */
-ALtype coefficients[hrirCount][hrirSize][channels];
+ALbyte3 coefficients[hrirCount][hrirSize][channels];
 ALubyte delays[hrirCount][channels]; /* Each can be 0 to 63. */
 ==
 
-The data is described as thus:
+The data layout is as follows:
 
-The file first starts with the 8-byte marker, "MinPHR02", to identify it as an
+The file first starts with the 8-byte marker, "MinPHR03", to identify it as an
 HRTF data set. This is followed by an unsigned 32-bit integer, specifying the
-sample rate the data set is designed for (OpenAL Soft will not use it if the
-output device's playback rate doesn't match).
+sample rate the data set is designed for (OpenAL Soft will resample the HRIRs
+if the output device's playback rate doesn't match).
 
-Afterward, an unsigned 8-bit integer specifies how many sample points (or
-finite impulse response filter coefficients) make up each HRIR.
+Afterward, an unsigned 8-bit integer specifies the channel type, which can be 0
+(mono, single-channel) or 1 (stereo, dual-channel). After this is another 8-bit
+integer which specifies how many sample points (or finite impulse response
+filter coefficients) make up each HRIR.
 
 The following unsigned 8-bit integer specifies the number of fields used by the
-data set.  Then for each field an unsigned 16-bit short specifies the distance
-for that field (in millimeters), followed by an 8-bit integer for the number of
+data set, which must be in descending order (farthest first, closest last).
+Then for each field an unsigned 16-bit short specifies the distance for that
+field in millimeters, followed by an 8-bit integer for the number of
 elevations.  These elevations start at the bottom (-90 degrees), and increment
 upwards.  Following this is an array of unsigned 8-bit integers, one for each
 elevation which specifies the number of azimuths (and thus HRIRs) that make up
@@ -71,14 +70,12 @@ each elevation.  Azimuths start clockwise from the front, constructing a full
 circle.  Mono HRTFs use the same HRIRs for both ears by reversing the azimuth
 calculation (ie. left = angle, right = 360-angle).
 
-The actual coefficients follow. Each coefficient is a signed 16-bit or 24-bit
-sample.  Stereo HRTFs interleave left/right ear coefficients.  The HRIRs must
-be minimum-phase.  This allows the use of a smaller filter length, reducing
-computation.  For reference, the default data set uses a 32-point filter while
-even the smallest data set provided by MIT used a 128-sample filter (a 4x
-reduction by applying minimum-phase reconstruction).
-
-After the coefficients is an array of unsigned 8-bit delay values, one for
-each HRIR (with stereo HRTFs interleaving left/right ear delays). This is the
-propagation delay (in samples) a signal must wait before being convolved with
-the corresponding minimum-phase HRIR filter.
+The actual coefficients follow. Each coefficient is a signed 24-bit sample.
+Stereo HRTFs interleave left/right ear coefficients.  The HRIRs must be
+minimum-phase.  This allows the use of a smaller filter length, reducing
+computation.
+
+After the coefficients is an array of unsigned 8-bit delay values as 6.2 fixed-
+point integers, one for each HRIR (with stereo HRTFs interleaving left/right
+ear delays). This is the propagation delay in samples a signal must wait before
+being convolved with the corresponding minimum-phase HRIR filter.
diff --git a/examples/alconvolve.c b/examples/alconvolve.c
new file mode 100644
index 00000000..93fd2eb4
--- /dev/null
+++ b/examples/alconvolve.c
@@ -0,0 +1,594 @@
+/*
+ * OpenAL Convolution Reverb Example
+ *
+ * Copyright (c) 2020 by Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* This file contains an example for applying convolution reverb to a source. */
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sndfile.h"
+
+#include "AL/al.h"
+#include "AL/alext.h"
+
+#include "common/alhelpers.h"
+
+
+#ifndef AL_SOFT_convolution_reverb
+#define AL_SOFT_convolution_reverb
+#define AL_EFFECT_CONVOLUTION_REVERB_SOFT        0xA000
+#endif
+
+
+/* Filter object functions */
+static LPALGENFILTERS alGenFilters;
+static LPALDELETEFILTERS alDeleteFilters;
+static LPALISFILTER alIsFilter;
+static LPALFILTERI alFilteri;
+static LPALFILTERIV alFilteriv;
+static LPALFILTERF alFilterf;
+static LPALFILTERFV alFilterfv;
+static LPALGETFILTERI alGetFilteri;
+static LPALGETFILTERIV alGetFilteriv;
+static LPALGETFILTERF alGetFilterf;
+static LPALGETFILTERFV alGetFilterfv;
+
+/* Effect object functions */
+static LPALGENEFFECTS alGenEffects;
+static LPALDELETEEFFECTS alDeleteEffects;
+static LPALISEFFECT alIsEffect;
+static LPALEFFECTI alEffecti;
+static LPALEFFECTIV alEffectiv;
+static LPALEFFECTF alEffectf;
+static LPALEFFECTFV alEffectfv;
+static LPALGETEFFECTI alGetEffecti;
+static LPALGETEFFECTIV alGetEffectiv;
+static LPALGETEFFECTF alGetEffectf;
+static LPALGETEFFECTFV alGetEffectfv;
+
+/* Auxiliary Effect Slot object functions */
+static LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
+static LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
+static LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot;
+static LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
+static LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv;
+static LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
+static LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv;
+static LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti;
+static LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv;
+static LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf;
+static LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv;
+
+
+/* This stuff defines a simple streaming player object, the same as alstream.c.
+ * Comments are removed for brevity, see alstream.c for more details.
+ */
+#define NUM_BUFFERS 4
+#define BUFFER_SAMPLES 8192
+
+typedef struct StreamPlayer {
+    ALuint buffers[NUM_BUFFERS];
+    ALuint source;
+
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    float *membuf;
+
+    ALenum format;
+} StreamPlayer;
+
+static StreamPlayer *NewPlayer(void)
+{
+    StreamPlayer *player;
+
+    player = calloc(1, sizeof(*player));
+    assert(player != NULL);
+
+    alGenBuffers(NUM_BUFFERS, player->buffers);
+    assert(alGetError() == AL_NO_ERROR && "Could not create buffers");
+
+    alGenSources(1, &player->source);
+    assert(alGetError() == AL_NO_ERROR && "Could not create source");
+
+    alSource3i(player->source, AL_POSITION, 0, 0, -1);
+    alSourcei(player->source, AL_SOURCE_RELATIVE, AL_TRUE);
+    alSourcei(player->source, AL_ROLLOFF_FACTOR, 0);
+    assert(alGetError() == AL_NO_ERROR && "Could not set source parameters");
+
+    return player;
+}
+
+static void ClosePlayerFile(StreamPlayer *player)
+{
+    if(player->sndfile)
+        sf_close(player->sndfile);
+    player->sndfile = NULL;
+
+    free(player->membuf);
+    player->membuf = NULL;
+}
+
+static void DeletePlayer(StreamPlayer *player)
+{
+    ClosePlayerFile(player);
+
+    alDeleteSources(1, &player->source);
+    alDeleteBuffers(NUM_BUFFERS, player->buffers);
+    if(alGetError() != AL_NO_ERROR)
+        fprintf(stderr, "Failed to delete object IDs\n");
+
+    memset(player, 0, sizeof(*player));
+    free(player);
+}
+
+static int OpenPlayerFile(StreamPlayer *player, const char *filename)
+{
+    size_t frame_size;
+
+    ClosePlayerFile(player);
+
+    player->sndfile = sf_open(filename, SFM_READ, &player->sfinfo);
+    if(!player->sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(NULL));
+        return 0;
+    }
+
+    player->format = AL_NONE;
+    if(player->sfinfo.channels == 1)
+        player->format = AL_FORMAT_MONO_FLOAT32;
+    else if(player->sfinfo.channels == 2)
+        player->format = AL_FORMAT_STEREO_FLOAT32;
+    else if(player->sfinfo.channels == 6)
+        player->format = AL_FORMAT_51CHN32;
+    else if(player->sfinfo.channels == 3)
+    {
+        if(sf_command(player->sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            player->format = AL_FORMAT_BFORMAT2D_FLOAT32;
+    }
+    else if(player->sfinfo.channels == 4)
+    {
+        if(sf_command(player->sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            player->format = AL_FORMAT_BFORMAT3D_FLOAT32;
+    }
+    if(!player->format)
+    {
+        fprintf(stderr, "Unsupported channel count: %d\n", player->sfinfo.channels);
+        sf_close(player->sndfile);
+        player->sndfile = NULL;
+        return 0;
+    }
+
+    frame_size = (size_t)(BUFFER_SAMPLES * player->sfinfo.channels) * sizeof(float);
+    player->membuf = malloc(frame_size);
+
+    return 1;
+}
+
+static int StartPlayer(StreamPlayer *player)
+{
+    ALsizei i;
+
+    alSourceRewind(player->source);
+    alSourcei(player->source, AL_BUFFER, 0);
+
+    for(i = 0;i < NUM_BUFFERS;i++)
+    {
+        sf_count_t slen = sf_readf_float(player->sndfile, player->membuf, BUFFER_SAMPLES);
+        if(slen < 1) break;
+
+        slen *= player->sfinfo.channels * (sf_count_t)sizeof(float);
+        alBufferData(player->buffers[i], player->format, player->membuf, (ALsizei)slen,
+            player->sfinfo.samplerate);
+    }
+    if(alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Error buffering for playback\n");
+        return 0;
+    }
+
+    alSourceQueueBuffers(player->source, i, player->buffers);
+    alSourcePlay(player->source);
+    if(alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Error starting playback\n");
+        return 0;
+    }
+
+    return 1;
+}
+
+static int UpdatePlayer(StreamPlayer *player)
+{
+    ALint processed, state;
+
+    alGetSourcei(player->source, AL_SOURCE_STATE, &state);
+    alGetSourcei(player->source, AL_BUFFERS_PROCESSED, &processed);
+    if(alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Error checking source state\n");
+        return 0;
+    }
+
+    while(processed > 0)
+    {
+        ALuint bufid;
+        sf_count_t slen;
+
+        alSourceUnqueueBuffers(player->source, 1, &bufid);
+        processed--;
+
+        slen = sf_readf_float(player->sndfile, player->membuf, BUFFER_SAMPLES);
+        if(slen > 0)
+        {
+            slen *= player->sfinfo.channels * (sf_count_t)sizeof(float);
+            alBufferData(bufid, player->format, player->membuf, (ALsizei)slen,
+                player->sfinfo.samplerate);
+            alSourceQueueBuffers(player->source, 1, &bufid);
+        }
+        if(alGetError() != AL_NO_ERROR)
+        {
+            fprintf(stderr, "Error buffering data\n");
+            return 0;
+        }
+    }
+
+    if(state != AL_PLAYING && state != AL_PAUSED)
+    {
+        ALint queued;
+
+        alGetSourcei(player->source, AL_BUFFERS_QUEUED, &queued);
+        if(queued == 0)
+            return 0;
+
+        alSourcePlay(player->source);
+        if(alGetError() != AL_NO_ERROR)
+        {
+            fprintf(stderr, "Error restarting playback\n");
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+
+/* CreateEffect creates a new OpenAL effect object with a convolution reverb
+ * type, and returns the new effect ID.
+ */
+static ALuint CreateEffect(void)
+{
+    ALuint effect = 0;
+    ALenum err;
+
+    printf("Using Convolution Reverb\n");
+
+    /* Create the effect object and set the convolution reverb effect type. */
+    alGenEffects(1, &effect);
+    alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_CONVOLUTION_REVERB_SOFT);
+
+    /* Check if an error occured, and clean up if so. */
+    err = alGetError();
+    if(err != AL_NO_ERROR)
+    {
+        fprintf(stderr, "OpenAL error: %s\n", alGetString(err));
+        if(alIsEffect(effect))
+            alDeleteEffects(1, &effect);
+        return 0;
+    }
+
+    return effect;
+}
+
+/* LoadBuffer loads the named audio file into an OpenAL buffer object, and
+ * returns the new buffer ID.
+ */
+static ALuint LoadSound(const char *filename)
+{
+    const char *namepart;
+    ALenum err, format;
+    ALuint buffer;
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    float *membuf;
+    sf_count_t num_frames;
+    ALsizei num_bytes;
+
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
+        return 0;
+    }
+    if(sfinfo.frames < 1 || sfinfo.frames > (sf_count_t)(INT_MAX/sizeof(float))/sfinfo.channels)
+    {
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
+        return 0;
+    }
+
+    /* Get the sound format, and figure out the OpenAL format. Use floats since
+     * impulse responses will usually have more than 16-bit precision.
+     */
+    format = AL_NONE;
+    if(sfinfo.channels == 1)
+        format = AL_FORMAT_MONO_FLOAT32;
+    else if(sfinfo.channels == 2)
+        format = AL_FORMAT_STEREO_FLOAT32;
+    else if(sfinfo.channels == 3)
+    {
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT2D_FLOAT32;
+    }
+    else if(sfinfo.channels == 4)
+    {
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT3D_FLOAT32;
+    }
+    if(!format)
+    {
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
+        return 0;
+    }
+
+    namepart = strrchr(filename, '/');
+    if(namepart || (namepart=strrchr(filename, '\\')))
+        namepart++;
+    else
+        namepart = filename;
+    printf("Loading: %s (%s, %dhz, %" PRId64 " samples / %.2f seconds)\n", namepart,
+        FormatName(format), sfinfo.samplerate, sfinfo.frames,
+        (double)sfinfo.frames / sfinfo.samplerate);
+    fflush(stdout);
+
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames * sfinfo.channels) * sizeof(float));
+
+    num_frames = sf_readf_float(sndfile, membuf, sfinfo.frames);
+    if(num_frames < 1)
+    {
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
+        return 0;
+    }
+    num_bytes = (ALsizei)(num_frames * sfinfo.channels) * (ALsizei)sizeof(float);
+
+    /* Buffer the audio data into a new buffer object, then free the data and
+     * close the file.
+     */
+    buffer = 0;
+    alGenBuffers(1, &buffer);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
+
+    /* Check if an error occured, and clean up if so. */
+    err = alGetError();
+    if(err != AL_NO_ERROR)
+    {
+        fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
+        if(buffer && alIsBuffer(buffer))
+            alDeleteBuffers(1, &buffer);
+        return 0;
+    }
+
+    return buffer;
+}
+
+
+int main(int argc, char **argv)
+{
+    ALuint ir_buffer, filter, effect, slot;
+    StreamPlayer *player;
+    int i;
+
+    /* Print out usage if no arguments were specified */
+    if(argc < 2)
+    {
+        fprintf(stderr, "Usage: %s [-device <name>] <impulse response file> "
+            "<[-dry | -nodry] filename>...\n", argv[0]);
+        return 1;
+    }
+
+    argv++; argc--;
+    if(InitAL(&argv, &argc) != 0)
+        return 1;
+
+    if(!alIsExtensionPresent("AL_SOFTX_convolution_reverb"))
+    {
+        CloseAL();
+        fprintf(stderr, "Error: Convolution revern not supported\n");
+        return 1;
+    }
+
+    if(argc < 2)
+    {
+        CloseAL();
+        fprintf(stderr, "Error: Missing impulse response or sound files\n");
+        return 1;
+    }
+
+    /* Define a macro to help load the function pointers. */
+#define LOAD_PROC(T, x)  ((x) = FUNCTION_CAST(T, alGetProcAddress(#x)))
+    LOAD_PROC(LPALGENFILTERS, alGenFilters);
+    LOAD_PROC(LPALDELETEFILTERS, alDeleteFilters);
+    LOAD_PROC(LPALISFILTER, alIsFilter);
+    LOAD_PROC(LPALFILTERI, alFilteri);
+    LOAD_PROC(LPALFILTERIV, alFilteriv);
+    LOAD_PROC(LPALFILTERF, alFilterf);
+    LOAD_PROC(LPALFILTERFV, alFilterfv);
+    LOAD_PROC(LPALGETFILTERI, alGetFilteri);
+    LOAD_PROC(LPALGETFILTERIV, alGetFilteriv);
+    LOAD_PROC(LPALGETFILTERF, alGetFilterf);
+    LOAD_PROC(LPALGETFILTERFV, alGetFilterfv);
+
+    LOAD_PROC(LPALGENEFFECTS, alGenEffects);
+    LOAD_PROC(LPALDELETEEFFECTS, alDeleteEffects);
+    LOAD_PROC(LPALISEFFECT, alIsEffect);
+    LOAD_PROC(LPALEFFECTI, alEffecti);
+    LOAD_PROC(LPALEFFECTIV, alEffectiv);
+    LOAD_PROC(LPALEFFECTF, alEffectf);
+    LOAD_PROC(LPALEFFECTFV, alEffectfv);
+    LOAD_PROC(LPALGETEFFECTI, alGetEffecti);
+    LOAD_PROC(LPALGETEFFECTIV, alGetEffectiv);
+    LOAD_PROC(LPALGETEFFECTF, alGetEffectf);
+    LOAD_PROC(LPALGETEFFECTFV, alGetEffectfv);
+
+    LOAD_PROC(LPALGENAUXILIARYEFFECTSLOTS, alGenAuxiliaryEffectSlots);
+    LOAD_PROC(LPALDELETEAUXILIARYEFFECTSLOTS, alDeleteAuxiliaryEffectSlots);
+    LOAD_PROC(LPALISAUXILIARYEFFECTSLOT, alIsAuxiliaryEffectSlot);
+    LOAD_PROC(LPALAUXILIARYEFFECTSLOTI, alAuxiliaryEffectSloti);
+    LOAD_PROC(LPALAUXILIARYEFFECTSLOTIV, alAuxiliaryEffectSlotiv);
+    LOAD_PROC(LPALAUXILIARYEFFECTSLOTF, alAuxiliaryEffectSlotf);
+    LOAD_PROC(LPALAUXILIARYEFFECTSLOTFV, alAuxiliaryEffectSlotfv);
+    LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTI, alGetAuxiliaryEffectSloti);
+    LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTIV, alGetAuxiliaryEffectSlotiv);
+    LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTF, alGetAuxiliaryEffectSlotf);
+    LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTFV, alGetAuxiliaryEffectSlotfv);
+#undef LOAD_PROC
+
+    /* Load the reverb into an effect. */
+    effect = CreateEffect();
+    if(!effect)
+    {
+        CloseAL();
+        return 1;
+    }
+
+    /* Load the impulse response sound into a buffer. */
+    ir_buffer = LoadSound(argv[0]);
+    if(!ir_buffer)
+    {
+        alDeleteEffects(1, &effect);
+        CloseAL();
+        return 1;
+    }
+
+    /* Create the effect slot object. This is what "plays" an effect on sources
+     * that connect to it.
+     */
+    slot = 0;
+    alGenAuxiliaryEffectSlots(1, &slot);
+
+    /* Set the impulse response sound buffer on the effect slot. This allows
+     * effects to access it as needed. In this case, convolution reverb uses it
+     * as the filter source. NOTE: Unlike the effect object, the buffer *is*
+     * kept referenced and may not be changed or deleted as long as it's set,
+     * just like with a source. When another buffer is set, or the effect slot
+     * is deleted, the buffer reference is released.
+     *
+     * The effect slot's gain is reduced because the impulse responses I've
+     * tested with result in excessively loud reverb. Is that normal? Even with
+     * this, it seems a bit on the loud side.
+     *
+     * Also note: unlike standard or EAX reverb, there is no automatic
+     * attenuation of a source's reverb response with distance, so the reverb
+     * will remain full volume regardless of a given sound's distance from the
+     * listener. You can use a send filter to alter a given source's
+     * contribution to reverb.
+     */
+    alAuxiliaryEffectSloti(slot, AL_BUFFER, (ALint)ir_buffer);
+    alAuxiliaryEffectSlotf(slot, AL_EFFECTSLOT_GAIN, 1.0f / 16.0f);
+    alAuxiliaryEffectSloti(slot, AL_EFFECTSLOT_EFFECT, (ALint)effect);
+    assert(alGetError()==AL_NO_ERROR && "Failed to set effect slot");
+
+    /* Create a filter that can silence the dry path. */
+    filter = 0;
+    alGenFilters(1, &filter);
+    alFilteri(filter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
+    alFilterf(filter, AL_LOWPASS_GAIN, 0.0f);
+
+    player = NewPlayer();
+    /* Connect the player's source to the effect slot. */
+    alSource3i(player->source, AL_AUXILIARY_SEND_FILTER, (ALint)slot, 0, AL_FILTER_NULL);
+    assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
+
+    /* Play each file listed on the command line */
+    for(i = 1;i < argc;i++)
+    {
+        const char *namepart;
+
+        if(argc-i > 1)
+        {
+            if(strcasecmp(argv[i], "-nodry") == 0)
+            {
+                alSourcei(player->source, AL_DIRECT_FILTER, (ALint)filter);
+                ++i;
+            }
+            else if(strcasecmp(argv[i], "-dry") == 0)
+            {
+                alSourcei(player->source, AL_DIRECT_FILTER, AL_FILTER_NULL);
+                ++i;
+            }
+        }
+
+        if(!OpenPlayerFile(player, argv[i]))
+            continue;
+
+        namepart = strrchr(argv[i], '/');
+        if(namepart || (namepart=strrchr(argv[i], '\\')))
+            namepart++;
+        else
+            namepart = argv[i];
+
+        printf("Playing: %s (%s, %dhz)\n", namepart, FormatName(player->format),
+            player->sfinfo.samplerate);
+        fflush(stdout);
+
+        if(!StartPlayer(player))
+        {
+            ClosePlayerFile(player);
+            continue;
+        }
+
+        while(UpdatePlayer(player))
+            al_nssleep(10000000);
+
+        ClosePlayerFile(player);
+    }
+    printf("Done.\n");
+
+    /* All files done. Delete the player and effect resources, and close down
+     * OpenAL.
+     */
+    DeletePlayer(player);
+    player = NULL;
+
+    alDeleteAuxiliaryEffectSlots(1, &slot);
+    alDeleteEffects(1, &effect);
+    alDeleteFilters(1, &filter);
+    alDeleteBuffers(1, &ir_buffer);
+
+    CloseAL();
+
+    return 0;
+}
diff --git a/examples/alffplay.cpp b/examples/alffplay.cpp
index 655ffc96..ae40a51a 100644
--- a/examples/alffplay.cpp
+++ b/examples/alffplay.cpp
@@ -1,7 +1,7 @@
 /*
  * An example showing how to play a stream sync'd to video, using ffmpeg.
  *
- * Requires C++11.
+ * Requires C++14.
  */
 
 #include <condition_variable>
@@ -17,6 +17,7 @@
 #include <cerrno>
 #include <chrono>
 #include <cstdio>
+#include <future>
 #include <memory>
 #include <string>
 #include <thread>
@@ -27,6 +28,11 @@
 #include <mutex>
 #include <ratio>
 
+#ifdef __GNUC__
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wconversion\"")
+_Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")
+#endif
 extern "C" {
 #include "libavcodec/avcodec.h"
 #include "libavformat/avformat.h"
@@ -45,10 +51,17 @@ extern "C" {
 #include "libswscale/swscale.h"
 #include "libswresample/swresample.h"
 
+constexpr auto AVNoPtsValue = AV_NOPTS_VALUE;
+constexpr auto AVErrorEOF = AVERROR_EOF;
+
 struct SwsContext;
 }
 
+#define SDL_MAIN_HANDLED
 #include "SDL.h"
+#ifdef __GNUC__
+_Pragma("GCC diagnostic pop")
+#endif
 
 #include "AL/alc.h"
 #include "AL/al.h"
@@ -56,47 +69,6 @@ struct SwsContext;
 
 #include "common/alhelpers.h"
 
-extern "C" {
-/* Undefine this to disable use of experimental extensions. Don't use for
- * production code! Interfaces and behavior may change prior to being
- * finalized.
- */
-#define ALLOW_EXPERIMENTAL_EXTS
-
-#ifdef ALLOW_EXPERIMENTAL_EXTS
-#ifndef AL_SOFT_map_buffer
-#define AL_SOFT_map_buffer 1
-typedef unsigned int ALbitfieldSOFT;
-#define AL_MAP_READ_BIT_SOFT                     0x00000001
-#define AL_MAP_WRITE_BIT_SOFT                    0x00000002
-#define AL_MAP_PERSISTENT_BIT_SOFT               0x00000004
-#define AL_PRESERVE_DATA_BIT_SOFT                0x00000008
-typedef void (AL_APIENTRY*LPALBUFFERSTORAGESOFT)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq, ALbitfieldSOFT flags);
-typedef void* (AL_APIENTRY*LPALMAPBUFFERSOFT)(ALuint buffer, ALsizei offset, ALsizei length, ALbitfieldSOFT access);
-typedef void (AL_APIENTRY*LPALUNMAPBUFFERSOFT)(ALuint buffer);
-typedef void (AL_APIENTRY*LPALFLUSHMAPPEDBUFFERSOFT)(ALuint buffer, ALsizei offset, ALsizei length);
-#endif
-
-#ifndef AL_SOFT_events
-#define AL_SOFT_events 1
-#define AL_EVENT_CALLBACK_FUNCTION_SOFT          0x1220
-#define AL_EVENT_CALLBACK_USER_PARAM_SOFT        0x1221
-#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT      0x1222
-#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT  0x1223
-#define AL_EVENT_TYPE_ERROR_SOFT                 0x1224
-#define AL_EVENT_TYPE_PERFORMANCE_SOFT           0x1225
-#define AL_EVENT_TYPE_DEPRECATED_SOFT            0x1226
-#define AL_EVENT_TYPE_DISCONNECTED_SOFT          0x1227
-typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param,
-                                           ALsizei length, const ALchar *message,
-                                           void *userParam);
-typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable);
-typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam);
-typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname);
-typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values);
-#endif
-#endif /* ALLOW_EXPERIMENTAL_EXTS */
-}
 
 namespace {
 
@@ -112,29 +84,24 @@ using microseconds = std::chrono::microseconds;
 using milliseconds = std::chrono::milliseconds;
 using seconds = std::chrono::seconds;
 using seconds_d64 = std::chrono::duration<double>;
+using std::chrono::duration_cast;
 
 const std::string AppName{"alffplay"};
 
-bool EnableDirectOut{false};
+ALenum DirectOutMode{AL_FALSE};
 bool EnableWideStereo{false};
+bool EnableUhj{false};
+bool EnableSuperStereo{false};
 bool DisableVideo{false};
 LPALGETSOURCEI64VSOFT alGetSourcei64vSOFT;
 LPALCGETINTEGER64VSOFT alcGetInteger64vSOFT;
-
-#ifdef AL_SOFT_map_buffer
-LPALBUFFERSTORAGESOFT alBufferStorageSOFT;
-LPALMAPBUFFERSOFT alMapBufferSOFT;
-LPALUNMAPBUFFERSOFT alUnmapBufferSOFT;
-#endif
-
-#ifdef AL_SOFT_events
 LPALEVENTCONTROLSOFT alEventControlSOFT;
 LPALEVENTCALLBACKSOFT alEventCallbackSOFT;
-#endif
+
+LPALBUFFERCALLBACKSOFT alBufferCallbackSOFT;
 
 const seconds AVNoSyncThreshold{10};
 
-const milliseconds VideoSyncThreshold{10};
 #define VIDEO_PICTURE_QUEUE_SIZE 24
 
 const seconds_d64 AudioSyncThreshold{0.03};
@@ -143,9 +110,10 @@ const milliseconds AudioSampleCorrectionMax{50};
 #define AUDIO_DIFF_AVG_NB 20
 const double AudioAvgFilterCoeff{std::pow(0.01, 1.0/AUDIO_DIFF_AVG_NB)};
 /* Per-buffer size, in time */
-const milliseconds AudioBufferTime{20};
+constexpr milliseconds AudioBufferTime{20};
 /* Buffer total size, in time (should be divisible by the buffer time) */
-const milliseconds AudioBufferTotalTime{800};
+constexpr milliseconds AudioBufferTotalTime{800};
+constexpr auto AudioBufferCount = AudioBufferTotalTime / AudioBufferTime;
 
 enum {
     FF_MOVIE_DONE_EVENT = SDL_USEREVENT
@@ -156,7 +124,7 @@ enum class SyncMaster {
     Video,
     External,
 
-    Default = External
+    Default = Audio
 };
 
 
@@ -179,6 +147,11 @@ struct AVCodecCtxDeleter {
 };
 using AVCodecCtxPtr = std::unique_ptr<AVCodecContext,AVCodecCtxDeleter>;
 
+struct AVPacketDeleter {
+    void operator()(AVPacket *pkt) { av_packet_free(&pkt); }
+};
+using AVPacketPtr = std::unique_ptr<AVPacket,AVPacketDeleter>;
+
 struct AVFrameDeleter {
     void operator()(AVFrame *ptr) { av_frame_free(&ptr); }
 };
@@ -195,81 +168,110 @@ struct SwsContextDeleter {
 using SwsContextPtr = std::unique_ptr<SwsContext,SwsContextDeleter>;
 
 
+struct ChannelLayout : public AVChannelLayout {
+    ChannelLayout() : AVChannelLayout{} { }
+    ~ChannelLayout() { av_channel_layout_uninit(this); }
+};
+
+
 template<size_t SizeLimit>
-class PacketQueue {
-    std::mutex mMutex;
-    std::condition_variable mCondVar;
-    std::deque<AVPacket> mPackets;
+class DataQueue {
+    std::mutex mPacketMutex, mFrameMutex;
+    std::condition_variable mPacketCond;
+    std::condition_variable mInFrameCond, mOutFrameCond;
+
+    std::deque<AVPacketPtr> mPackets;
     size_t mTotalSize{0};
     bool mFinished{false};
 
-    AVPacket *getPacket(std::unique_lock<std::mutex> &lock)
+    AVPacketPtr getPacket()
     {
+        std::unique_lock<std::mutex> plock{mPacketMutex};
         while(mPackets.empty() && !mFinished)
-            mCondVar.wait(lock);
-        return mPackets.empty() ? nullptr : &mPackets.front();
-    }
+            mPacketCond.wait(plock);
+        if(mPackets.empty())
+            return nullptr;
 
-    void pop()
-    {
-        AVPacket *pkt = &mPackets.front();
-        mTotalSize -= static_cast<unsigned int>(pkt->size);
-        av_packet_unref(pkt);
+        auto ret = std::move(mPackets.front());
         mPackets.pop_front();
+        mTotalSize -= static_cast<unsigned int>(ret->size);
+        return ret;
     }
 
 public:
-    ~PacketQueue()
+    int sendPacket(AVCodecContext *codecctx)
     {
-        for(AVPacket &pkt : mPackets)
-            av_packet_unref(&pkt);
-        mPackets.clear();
-        mTotalSize = 0;
-    }
+        AVPacketPtr packet{getPacket()};
 
-    int sendTo(AVCodecContext *codecctx)
-    {
-        std::unique_lock<std::mutex> lock{mMutex};
+        int ret{};
+        {
+            std::unique_lock<std::mutex> flock{mFrameMutex};
+            while((ret=avcodec_send_packet(codecctx, packet.get())) == AVERROR(EAGAIN))
+                mInFrameCond.wait_for(flock, milliseconds{50});
+        }
+        mOutFrameCond.notify_one();
 
-        AVPacket *pkt{getPacket(lock)};
-        if(!pkt) return avcodec_send_packet(codecctx, nullptr);
+        if(!packet)
+        {
+            if(!ret) return AVErrorEOF;
+            std::cerr<< "Failed to send flush packet: "<<ret <<std::endl;
+            return ret;
+        }
+        if(ret < 0)
+            std::cerr<< "Failed to send packet: "<<ret <<std::endl;
+        return ret;
+    }
 
-        const int ret{avcodec_send_packet(codecctx, pkt)};
-        if(ret != AVERROR(EAGAIN))
+    int receiveFrame(AVCodecContext *codecctx, AVFrame *frame)
+    {
+        int ret{};
         {
-            if(ret < 0)
-                std::cerr<< "Failed to send packet: "<<ret <<std::endl;
-            pop();
+            std::unique_lock<std::mutex> flock{mFrameMutex};
+            while((ret=avcodec_receive_frame(codecctx, frame)) == AVERROR(EAGAIN))
+                mOutFrameCond.wait_for(flock, milliseconds{50});
         }
+        mInFrameCond.notify_one();
         return ret;
     }
 
     void setFinished()
     {
         {
-            std::lock_guard<std::mutex> _{mMutex};
+            std::lock_guard<std::mutex> _{mPacketMutex};
             mFinished = true;
         }
-        mCondVar.notify_one();
+        mPacketCond.notify_one();
+    }
+
+    void flush()
+    {
+        {
+            std::lock_guard<std::mutex> _{mPacketMutex};
+            mFinished = true;
+
+            mPackets.clear();
+            mTotalSize = 0;
+        }
+        mPacketCond.notify_one();
     }
 
     bool put(const AVPacket *pkt)
     {
         {
-            std::unique_lock<std::mutex> lock{mMutex};
-            if(mTotalSize >= SizeLimit)
+            std::unique_lock<std::mutex> lock{mPacketMutex};
+            if(mTotalSize >= SizeLimit || mFinished)
                 return false;
 
-            mPackets.push_back(AVPacket{});
-            if(av_packet_ref(&mPackets.back(), pkt) != 0)
+            mPackets.push_back(AVPacketPtr{av_packet_alloc()});
+            if(av_packet_ref(mPackets.back().get(), pkt) != 0)
             {
                 mPackets.pop_back();
                 return true;
             }
 
-            mTotalSize += static_cast<unsigned int>(mPackets.back().size);
+            mTotalSize += static_cast<unsigned int>(mPackets.back()->size);
         }
-        mCondVar.notify_one();
+        mPacketCond.notify_one();
         return true;
     }
 };
@@ -283,7 +285,7 @@ struct AudioState {
     AVStream *mStream{nullptr};
     AVCodecCtxPtr mCodecCtx;
 
-    PacketQueue<2*1024*1024> mPackets;
+    DataQueue<2*1024*1024> mQueue;
 
     /* Used for clock difference average computation */
     seconds_d64 mClockDiffAvg{0};
@@ -308,6 +310,11 @@ struct AudioState {
     int mSamplesPos{0};
     int mSamplesMax{0};
 
+    std::unique_ptr<uint8_t[]> mBufferData;
+    size_t mBufferDataSize{0};
+    std::atomic<size_t> mReadPos{0};
+    std::atomic<size_t> mWritePos{0};
+
     /* OpenAL format */
     ALenum mFormat{AL_NONE};
     ALuint mFrameSize{0};
@@ -316,7 +323,7 @@ struct AudioState {
     std::condition_variable mSrcCond;
     std::atomic_flag mConnected;
     ALuint mSource{0};
-    std::vector<ALuint> mBuffers;
+    std::array<ALuint,AudioBufferCount> mBuffers{};
     ALuint mBufferIdx{0};
 
     AudioState(MovieState &movie) : mMovie(movie)
@@ -325,17 +332,21 @@ struct AudioState {
     {
         if(mSource)
             alDeleteSources(1, &mSource);
-        if(!mBuffers.empty())
+        if(mBuffers[0])
             alDeleteBuffers(static_cast<ALsizei>(mBuffers.size()), mBuffers.data());
 
         av_freep(&mSamples);
     }
 
-#ifdef AL_SOFT_events
-    static void AL_APIENTRY EventCallback(ALenum eventType, ALuint object, ALuint param,
-                                          ALsizei length, const ALchar *message,
-                                          void *userParam);
-#endif
+    static void AL_APIENTRY eventCallbackC(ALenum eventType, ALuint object, ALuint param,
+        ALsizei length, const ALchar *message, void *userParam)
+    { static_cast<AudioState*>(userParam)->eventCallback(eventType, object, param, length, message); }
+    void eventCallback(ALenum eventType, ALuint object, ALuint param, ALsizei length,
+        const ALchar *message);
+
+    static ALsizei AL_APIENTRY bufferCallbackC(void *userptr, void *data, ALsizei size)
+    { return static_cast<AudioState*>(userptr)->bufferCallback(data, size); }
+    ALsizei bufferCallback(void *data, ALsizei size);
 
     nanoseconds getClockNoLock();
     nanoseconds getClock()
@@ -344,11 +355,12 @@ struct AudioState {
         return getClockNoLock();
     }
 
-    void startPlayback();
+    bool startPlayback();
 
     int getSync();
     int decodeFrame();
-    bool readAudio(uint8_t *samples, unsigned int length);
+    bool readAudio(uint8_t *samples, unsigned int length, int &sample_skip);
+    bool readAudio(int sample_skip);
 
     int handler();
 };
@@ -359,7 +371,7 @@ struct VideoState {
     AVStream *mStream{nullptr};
     AVCodecCtxPtr mCodecCtx;
 
-    PacketQueue<14*1024*1024> mPackets;
+    DataQueue<14*1024*1024> mQueue;
 
     /* The pts of the currently displayed frame, and the time (av_gettime) it
      * was last updated - used to have running video pts
@@ -381,7 +393,7 @@ struct VideoState {
     std::condition_variable mPictQCond;
 
     SDL_Texture *mImage{nullptr};
-    int mWidth{0}, mHeight{0}; /* Logical image size (actual size may be larger) */
+    int mWidth{0}, mHeight{0}; /* Full texture size */
     bool mFirstUpdate{true};
 
     std::atomic<bool> mEOS{false};
@@ -397,7 +409,7 @@ struct VideoState {
 
     nanoseconds getClock();
 
-    void display(SDL_Window *screen, SDL_Renderer *renderer);
+    void display(SDL_Window *screen, SDL_Renderer *renderer, AVFrame *frame);
     void updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool redraw);
     int handler();
 };
@@ -415,6 +427,10 @@ struct MovieState {
     AudioState mAudio;
     VideoState mVideo;
 
+    std::mutex mStartupMutex;
+    std::condition_variable mStartupCond;
+    bool mStartupDone{false};
+
     std::thread mParseThread;
     std::thread mAudioThread;
     std::thread mVideoThread;
@@ -426,7 +442,7 @@ struct MovieState {
     { }
     ~MovieState()
     {
-        mQuit = true;
+        stop();
         if(mParseThread.joinable())
             mParseThread.join();
     }
@@ -434,6 +450,7 @@ struct MovieState {
     static int decode_interrupt_cb(void *ctx);
     bool prepare();
     void setTitle(SDL_Window *window);
+    void stop();
 
     nanoseconds getClock();
 
@@ -468,6 +485,53 @@ nanoseconds AudioState::getClockNoLock()
         return device_time - mDeviceStartTime - latency;
     }
 
+    if(mBufferDataSize > 0)
+    {
+        if(mDeviceStartTime == nanoseconds::min())
+            return nanoseconds::zero();
+
+        /* With a callback buffer and no device clock, mDeviceStartTime is
+         * actually the timestamp of the first sample frame played. The audio
+         * clock, then, is that plus the current source offset.
+         */
+        ALint64SOFT offset[2];
+        if(alGetSourcei64vSOFT)
+            alGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset);
+        else
+        {
+            ALint ioffset;
+            alGetSourcei(mSource, AL_SAMPLE_OFFSET, &ioffset);
+            offset[0] = ALint64SOFT{ioffset} << 32;
+            offset[1] = 0;
+        }
+        /* NOTE: The source state must be checked last, in case an underrun
+         * occurs and the source stops between getting the state and retrieving
+         * the offset+latency.
+         */
+        ALint status;
+        alGetSourcei(mSource, AL_SOURCE_STATE, &status);
+
+        nanoseconds pts{};
+        if(status == AL_PLAYING || status == AL_PAUSED)
+            pts = mDeviceStartTime - nanoseconds{offset[1]} +
+                duration_cast<nanoseconds>(fixed32{offset[0] / mCodecCtx->sample_rate});
+        else
+        {
+            /* If the source is stopped, the pts of the next sample to be heard
+             * is the pts of the next sample to be buffered, minus the amount
+             * already in the buffer ready to play.
+             */
+            const size_t woffset{mWritePos.load(std::memory_order_acquire)};
+            const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+            const size_t readable{((woffset >= roffset) ? woffset : (mBufferDataSize+woffset)) -
+                roffset};
+
+            pts = mCurrentPts - nanoseconds{seconds{readable/mFrameSize}}/mCodecCtx->sample_rate;
+        }
+
+        return pts;
+    }
+
     /* The source-based clock is based on 4 components:
      * 1 - The timestamp of the next sample to buffer (mCurrentPts)
      * 2 - The length of the source's buffer queue
@@ -487,10 +551,6 @@ nanoseconds AudioState::getClockNoLock()
     if(mSource)
     {
         ALint64SOFT offset[2];
-
-        /* NOTE: The source state must be checked last, in case an underrun
-         * occurs and the source stops between retrieving the offset+latency
-         * and getting the state. */
         if(alGetSourcei64vSOFT)
             alGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset);
         else
@@ -507,12 +567,12 @@ nanoseconds AudioState::getClockNoLock()
         /* If the source is AL_STOPPED, then there was an underrun and all
          * buffers are processed, so ignore the source queue. The audio thread
          * will put the source into an AL_INITIAL state and clear the queue
-         * when it starts recovery. */
+         * when it starts recovery.
+         */
         if(status != AL_STOPPED)
         {
             pts -= AudioBufferTime*queued;
-            pts += std::chrono::duration_cast<nanoseconds>(
-                fixed32{offset[0] / mCodecCtx->sample_rate});
+            pts += duration_cast<nanoseconds>(fixed32{offset[0] / mCodecCtx->sample_rate});
         }
         /* Don't offset by the latency if the source isn't playing. */
         if(status == AL_PLAYING)
@@ -522,27 +582,59 @@ nanoseconds AudioState::getClockNoLock()
     return std::max(pts, nanoseconds::zero());
 }
 
-void AudioState::startPlayback()
+bool AudioState::startPlayback()
 {
+    const size_t woffset{mWritePos.load(std::memory_order_acquire)};
+    const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+    const size_t readable{((woffset >= roffset) ? woffset : (mBufferDataSize+woffset)) -
+        roffset};
+
+    if(mBufferDataSize > 0)
+    {
+        if(readable == 0)
+            return false;
+        if(!alcGetInteger64vSOFT)
+            mDeviceStartTime = mCurrentPts -
+                nanoseconds{seconds{readable/mFrameSize}}/mCodecCtx->sample_rate;
+    }
+    else
+    {
+        ALint queued{};
+        alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
+        if(queued == 0) return false;
+    }
+
     alSourcePlay(mSource);
     if(alcGetInteger64vSOFT)
     {
-        // Subtract the total buffer queue time from the current pts to get the
-        // pts of the start of the queue.
-        nanoseconds startpts{mCurrentPts - AudioBufferTotalTime};
+        /* Subtract the total buffer queue time from the current pts to get the
+         * pts of the start of the queue.
+         */
         int64_t srctimes[2]{0,0};
         alGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_CLOCK_SOFT, srctimes);
         auto device_time = nanoseconds{srctimes[1]};
-        auto src_offset = std::chrono::duration_cast<nanoseconds>(fixed32{srctimes[0]}) /
+        auto src_offset = duration_cast<nanoseconds>(fixed32{srctimes[0]}) /
             mCodecCtx->sample_rate;
 
-        // The mixer may have ticked and incremented the device time and sample
-        // offset, so subtract the source offset from the device time to get
-        // the device time the source started at. Also subtract startpts to get
-        // the device time the stream would have started at to reach where it
-        // is now.
-        mDeviceStartTime = device_time - src_offset - startpts;
+        /* The mixer may have ticked and incremented the device time and sample
+         * offset, so subtract the source offset from the device time to get
+         * the device time the source started at. Also subtract startpts to get
+         * the device time the stream would have started at to reach where it
+         * is now.
+         */
+        if(mBufferDataSize > 0)
+        {
+            nanoseconds startpts{mCurrentPts -
+                nanoseconds{seconds{readable/mFrameSize}}/mCodecCtx->sample_rate};
+            mDeviceStartTime = device_time - src_offset - startpts;
+        }
+        else
+        {
+            nanoseconds startpts{mCurrentPts - AudioBufferTotalTime};
+            mDeviceStartTime = device_time - src_offset - startpts;
+        }
     }
+    return true;
 }
 
 int AudioState::getSync()
@@ -568,107 +660,80 @@ int AudioState::getSync()
 
     /* Constrain the per-update difference to avoid exceedingly large skips */
     diff = std::min<nanoseconds>(diff, AudioSampleCorrectionMax);
-    return static_cast<int>(std::chrono::duration_cast<seconds>(diff*mCodecCtx->sample_rate).count());
+    return static_cast<int>(duration_cast<seconds>(diff*mCodecCtx->sample_rate).count());
 }
 
 int AudioState::decodeFrame()
 {
-    while(!mMovie.mQuit.load(std::memory_order_relaxed))
-    {
-        int ret;
-        while((ret=avcodec_receive_frame(mCodecCtx.get(), mDecodedFrame.get())) == AVERROR(EAGAIN))
-            mPackets.sendTo(mCodecCtx.get());
-        if(ret != 0)
+    do {
+        while(int ret{mQueue.receiveFrame(mCodecCtx.get(), mDecodedFrame.get())})
         {
-            if(ret == AVERROR_EOF) break;
+            if(ret == AVErrorEOF) return 0;
             std::cerr<< "Failed to receive frame: "<<ret <<std::endl;
-            continue;
         }
+    } while(mDecodedFrame->nb_samples <= 0);
 
-        if(mDecodedFrame->nb_samples <= 0)
-            continue;
-
-        /* If provided, update w/ pts */
-        if(mDecodedFrame->best_effort_timestamp != AV_NOPTS_VALUE)
-            mCurrentPts = std::chrono::duration_cast<nanoseconds>(
-                seconds_d64{av_q2d(mStream->time_base)*mDecodedFrame->best_effort_timestamp}
-            );
-
-        if(mDecodedFrame->nb_samples > mSamplesMax)
-        {
-            av_freep(&mSamples);
-            av_samples_alloc(
-                &mSamples, nullptr, mCodecCtx->channels,
-                mDecodedFrame->nb_samples, mDstSampleFmt, 0
-            );
-            mSamplesMax = mDecodedFrame->nb_samples;
-        }
-        /* Return the amount of sample frames converted */
-        int data_size{swr_convert(mSwresCtx.get(), &mSamples, mDecodedFrame->nb_samples,
-            const_cast<const uint8_t**>(mDecodedFrame->data), mDecodedFrame->nb_samples)};
+    /* If provided, update w/ pts */
+    if(mDecodedFrame->best_effort_timestamp != AVNoPtsValue)
+        mCurrentPts = duration_cast<nanoseconds>(seconds_d64{av_q2d(mStream->time_base) *
+            static_cast<double>(mDecodedFrame->best_effort_timestamp)});
 
-        av_frame_unref(mDecodedFrame.get());
-        return data_size;
+    if(mDecodedFrame->nb_samples > mSamplesMax)
+    {
+        av_freep(&mSamples);
+        av_samples_alloc(&mSamples, nullptr, mCodecCtx->ch_layout.nb_channels,
+            mDecodedFrame->nb_samples, mDstSampleFmt, 0);
+        mSamplesMax = mDecodedFrame->nb_samples;
     }
+    /* Return the amount of sample frames converted */
+    int data_size{swr_convert(mSwresCtx.get(), &mSamples, mDecodedFrame->nb_samples,
+        const_cast<const uint8_t**>(mDecodedFrame->data), mDecodedFrame->nb_samples)};
 
-    return 0;
+    av_frame_unref(mDecodedFrame.get());
+    return data_size;
 }
 
 /* Duplicates the sample at in to out, count times. The frame size is a
  * multiple of the template type size.
  */
 template<typename T>
-static void sample_dup(uint8_t *out, const uint8_t *in, unsigned int count, size_t frame_size)
+static void sample_dup(uint8_t *out, const uint8_t *in, size_t count, size_t frame_size)
 {
     auto *sample = reinterpret_cast<const T*>(in);
     auto *dst = reinterpret_cast<T*>(out);
-    if(frame_size == sizeof(T))
+
+    /* NOTE: frame_size is a multiple of sizeof(T). */
+    size_t type_mult{frame_size / sizeof(T)};
+    if(type_mult == 1)
         std::fill_n(dst, count, *sample);
-    else
+    else for(size_t i{0};i < count;++i)
     {
-        /* NOTE: frame_size is a multiple of sizeof(T). */
-        size_t type_mult{frame_size / sizeof(T)};
-        size_t i{0};
-        std::generate_n(dst, count*type_mult,
-            [sample,type_mult,&i]() -> T
-            {
-                T ret = sample[i];
-                i = (i+1)%type_mult;
-                return ret;
-            }
-        );
+        for(size_t j{0};j < type_mult;++j)
+            dst[i*type_mult + j] = sample[j];
     }
 }
 
+static void sample_dup(uint8_t *out, const uint8_t *in, size_t count, size_t frame_size)
+{
+    if((frame_size&7) == 0)
+        sample_dup<uint64_t>(out, in, count, frame_size);
+    else if((frame_size&3) == 0)
+        sample_dup<uint32_t>(out, in, count, frame_size);
+    else if((frame_size&1) == 0)
+        sample_dup<uint16_t>(out, in, count, frame_size);
+    else
+        sample_dup<uint8_t>(out, in, count, frame_size);
+}
 
-bool AudioState::readAudio(uint8_t *samples, unsigned int length)
+bool AudioState::readAudio(uint8_t *samples, unsigned int length, int &sample_skip)
 {
-    int sample_skip{getSync()};
     unsigned int audio_size{0};
 
     /* Read the next chunk of data, refill the buffer, and queue it
      * on the source */
     length /= mFrameSize;
-    while(audio_size < length)
+    while(mSamplesLen > 0 && audio_size < length)
     {
-        if(mSamplesLen <= 0 || mSamplesPos >= mSamplesLen)
-        {
-            int frame_len = decodeFrame();
-            if(frame_len <= 0) break;
-
-            mSamplesLen = frame_len;
-            mSamplesPos = std::min(mSamplesLen, sample_skip);
-            sample_skip -= mSamplesPos;
-
-            // Adjust the device start time and current pts by the amount we're
-            // skipping/duplicating, so that the clock remains correct for the
-            // current stream position.
-            auto skip = nanoseconds{seconds{mSamplesPos}} / mCodecCtx->sample_rate;
-            mDeviceStartTime -= skip;
-            mCurrentPts += skip;
-            continue;
-        }
-
         unsigned int rem{length - audio_size};
         if(mSamplesPos >= 0)
         {
@@ -682,20 +747,29 @@ bool AudioState::readAudio(uint8_t *samples, unsigned int length)
             rem = std::min(rem, static_cast<unsigned int>(-mSamplesPos));
 
             /* Add samples by copying the first sample */
-            if((mFrameSize&7) == 0)
-                sample_dup<uint64_t>(samples, mSamples, rem, mFrameSize);
-            else if((mFrameSize&3) == 0)
-                sample_dup<uint32_t>(samples, mSamples, rem, mFrameSize);
-            else if((mFrameSize&1) == 0)
-                sample_dup<uint16_t>(samples, mSamples, rem, mFrameSize);
-            else
-                sample_dup<uint8_t>(samples, mSamples, rem, mFrameSize);
+            sample_dup(samples, mSamples, rem, mFrameSize);
         }
 
         mSamplesPos += rem;
         mCurrentPts += nanoseconds{seconds{rem}} / mCodecCtx->sample_rate;
         samples += rem*mFrameSize;
         audio_size += rem;
+
+        while(mSamplesPos >= mSamplesLen)
+        {
+            mSamplesLen = decodeFrame();
+            mSamplesPos = std::min(mSamplesLen, sample_skip);
+            if(mSamplesLen <= 0) break;
+
+            sample_skip -= mSamplesPos;
+
+            // Adjust the device start time and current pts by the amount we're
+            // skipping/duplicating, so that the clock remains correct for the
+            // current stream position.
+            auto skip = nanoseconds{seconds{mSamplesPos}} / mCodecCtx->sample_rate;
+            mDeviceStartTime -= skip;
+            mCurrentPts += skip;
+        }
     }
     if(audio_size <= 0)
         return false;
@@ -704,42 +778,89 @@ bool AudioState::readAudio(uint8_t *samples, unsigned int length)
     {
         const unsigned int rem{length - audio_size};
         std::fill_n(samples, rem*mFrameSize,
-                    (mDstSampleFmt == AV_SAMPLE_FMT_U8) ? 0x80 : 0x00);
+            (mDstSampleFmt == AV_SAMPLE_FMT_U8) ? 0x80 : 0x00);
         mCurrentPts += nanoseconds{seconds{rem}} / mCodecCtx->sample_rate;
-        audio_size += rem;
     }
     return true;
 }
 
-
-#ifdef AL_SOFT_events
-void AL_APIENTRY AudioState::EventCallback(ALenum eventType, ALuint object, ALuint param,
-                                           ALsizei length, const ALchar *message,
-                                           void *userParam)
+bool AudioState::readAudio(int sample_skip)
 {
-    auto self = static_cast<AudioState*>(userParam);
+    size_t woffset{mWritePos.load(std::memory_order_acquire)};
+    const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+    while(mSamplesLen > 0)
+    {
+        const size_t nsamples{((roffset > woffset) ? roffset-woffset-1
+            : (roffset == 0) ? (mBufferDataSize-woffset-1)
+            : (mBufferDataSize-woffset)) / mFrameSize};
+        if(!nsamples) break;
+
+        if(mSamplesPos < 0)
+        {
+            const size_t rem{std::min<size_t>(nsamples, static_cast<ALuint>(-mSamplesPos))};
+
+            sample_dup(&mBufferData[woffset], mSamples, rem, mFrameSize);
+            woffset += rem * mFrameSize;
+            if(woffset == mBufferDataSize) woffset = 0;
+            mWritePos.store(woffset, std::memory_order_release);
+
+            mCurrentPts += nanoseconds{seconds{rem}} / mCodecCtx->sample_rate;
+            mSamplesPos += static_cast<int>(rem);
+            continue;
+        }
+
+        const size_t rem{std::min<size_t>(nsamples, static_cast<ALuint>(mSamplesLen-mSamplesPos))};
+        const size_t boffset{static_cast<ALuint>(mSamplesPos) * size_t{mFrameSize}};
+        const size_t nbytes{rem * mFrameSize};
+
+        memcpy(&mBufferData[woffset], mSamples + boffset, nbytes);
+        woffset += nbytes;
+        if(woffset == mBufferDataSize) woffset = 0;
+        mWritePos.store(woffset, std::memory_order_release);
 
+        mCurrentPts += nanoseconds{seconds{rem}} / mCodecCtx->sample_rate;
+        mSamplesPos += static_cast<int>(rem);
+
+        while(mSamplesPos >= mSamplesLen)
+        {
+            mSamplesLen = decodeFrame();
+            mSamplesPos = std::min(mSamplesLen, sample_skip);
+            if(mSamplesLen <= 0) return false;
+
+            sample_skip -= mSamplesPos;
+
+            auto skip = nanoseconds{seconds{mSamplesPos}} / mCodecCtx->sample_rate;
+            mDeviceStartTime -= skip;
+            mCurrentPts += skip;
+        }
+    }
+
+    return true;
+}
+
+
+void AL_APIENTRY AudioState::eventCallback(ALenum eventType, ALuint object, ALuint param,
+    ALsizei length, const ALchar *message)
+{
     if(eventType == AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT)
     {
         /* Temporarily lock the source mutex to ensure it's not between
          * checking the processed count and going to sleep.
          */
-        std::unique_lock<std::mutex>{self->mSrcMutex}.unlock();
-        self->mSrcCond.notify_one();
+        std::unique_lock<std::mutex>{mSrcMutex}.unlock();
+        mSrcCond.notify_one();
         return;
     }
 
-    std::cout<< "\n---- AL Event on AudioState "<<self<<" ----\nEvent: ";
+    std::cout<< "\n---- AL Event on AudioState "<<this<<" ----\nEvent: ";
     switch(eventType)
     {
-        case AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT: std::cout<< "Buffer completed"; break;
-        case AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT: std::cout<< "Source state changed"; break;
-        case AL_EVENT_TYPE_ERROR_SOFT: std::cout<< "API error"; break;
-        case AL_EVENT_TYPE_PERFORMANCE_SOFT: std::cout<< "Performance"; break;
-        case AL_EVENT_TYPE_DEPRECATED_SOFT: std::cout<< "Deprecated"; break;
-        case AL_EVENT_TYPE_DISCONNECTED_SOFT: std::cout<< "Disconnected"; break;
-        default: std::cout<< "0x"<<std::hex<<std::setw(4)<<std::setfill('0')<<eventType<<
-                             std::dec<<std::setw(0)<<std::setfill(' '); break;
+    case AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT: std::cout<< "Buffer completed"; break;
+    case AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT: std::cout<< "Source state changed"; break;
+    case AL_EVENT_TYPE_DISCONNECTED_SOFT: std::cout<< "Disconnected"; break;
+    default:
+        std::cout<< "0x"<<std::hex<<std::setw(4)<<std::setfill('0')<<eventType<<std::dec<<
+            std::setw(0)<<std::setfill(' '); break;
     }
     std::cout<< "\n"
         "Object ID: "<<object<<"\n"
@@ -750,187 +871,254 @@ void AL_APIENTRY AudioState::EventCallback(ALenum eventType, ALuint object, ALui
     if(eventType == AL_EVENT_TYPE_DISCONNECTED_SOFT)
     {
         {
-            std::lock_guard<std::mutex> lock{self->mSrcMutex};
-            self->mConnected.clear(std::memory_order_release);
+            std::lock_guard<std::mutex> lock{mSrcMutex};
+            mConnected.clear(std::memory_order_release);
         }
-        self->mSrcCond.notify_one();
+        mSrcCond.notify_one();
     }
 }
-#endif
+
+ALsizei AudioState::bufferCallback(void *data, ALsizei size)
+{
+    ALsizei got{0};
+
+    size_t roffset{mReadPos.load(std::memory_order_acquire)};
+    while(got < size)
+    {
+        const size_t woffset{mWritePos.load(std::memory_order_relaxed)};
+        if(woffset == roffset) break;
+
+        size_t todo{((woffset < roffset) ? mBufferDataSize : woffset) - roffset};
+        todo = std::min<size_t>(todo, static_cast<ALuint>(size-got));
+
+        memcpy(data, &mBufferData[roffset], todo);
+        data = static_cast<ALbyte*>(data) + todo;
+        got += static_cast<ALsizei>(todo);
+
+        roffset += todo;
+        if(roffset == mBufferDataSize)
+            roffset = 0;
+    }
+    mReadPos.store(roffset, std::memory_order_release);
+
+    return got;
+}
 
 int AudioState::handler()
 {
     std::unique_lock<std::mutex> srclock{mSrcMutex, std::defer_lock};
     milliseconds sleep_time{AudioBufferTime / 3};
-    ALenum fmt;
 
-#ifdef AL_SOFT_events
-    const std::array<ALenum,6> evt_types{{
-        AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT, AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT,
-        AL_EVENT_TYPE_ERROR_SOFT, AL_EVENT_TYPE_PERFORMANCE_SOFT, AL_EVENT_TYPE_DEPRECATED_SOFT,
-        AL_EVENT_TYPE_DISCONNECTED_SOFT
-    }};
-    if(alEventControlSOFT)
-    {
-        alEventControlSOFT(evt_types.size(), evt_types.data(), AL_TRUE);
-        alEventCallbackSOFT(EventCallback, this);
-        sleep_time = AudioBufferTotalTime;
-    }
-#endif
+    struct EventControlManager {
+        const std::array<ALenum,3> evt_types{{
+            AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT, AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT,
+            AL_EVENT_TYPE_DISCONNECTED_SOFT}};
+
+        EventControlManager(milliseconds &sleep_time)
+        {
+            if(alEventControlSOFT)
+            {
+                alEventControlSOFT(static_cast<ALsizei>(evt_types.size()), evt_types.data(),
+                    AL_TRUE);
+                alEventCallbackSOFT(&AudioState::eventCallbackC, this);
+                sleep_time = AudioBufferTotalTime;
+            }
+        }
+        ~EventControlManager()
+        {
+            if(alEventControlSOFT)
+            {
+                alEventControlSOFT(static_cast<ALsizei>(evt_types.size()), evt_types.data(),
+                    AL_FALSE);
+                alEventCallbackSOFT(nullptr, nullptr);
+            }
+        }
+    };
+    EventControlManager event_controller{sleep_time};
+
+    std::unique_ptr<uint8_t[]> samples;
+    ALsizei buffer_len{0};
 
     /* Find a suitable format for OpenAL. */
     mDstChanLayout = 0;
     mFormat = AL_NONE;
-    if((mCodecCtx->sample_fmt == AV_SAMPLE_FMT_FLT || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_FLTP) &&
-       alIsExtensionPresent("AL_EXT_FLOAT32"))
+    if((mCodecCtx->sample_fmt == AV_SAMPLE_FMT_FLT || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_FLTP
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_DBL
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_DBLP
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_S32
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_S32P
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_S64
+            || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_S64P)
+        && alIsExtensionPresent("AL_EXT_FLOAT32"))
     {
         mDstSampleFmt = AV_SAMPLE_FMT_FLT;
         mFrameSize = 4;
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN32")) != AL_NONE && fmt != -1)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 8;
-            mFormat = fmt;
-        }
-        if((mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN32")) != AL_NONE && fmt != -1)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 6;
-            mFormat = fmt;
-        }
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
+        if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE)
         {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 1;
-            mFormat = AL_FORMAT_MONO_FLOAT32;
+            if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+            {
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_7POINT1)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 8;
+                    mFormat = alGetEnumValue("AL_FORMAT_71CHN32");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1
+                    || mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1_BACK)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 6;
+                    mFormat = alGetEnumValue("AL_FORMAT_51CHN32");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_QUAD)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 4;
+                    mFormat = alGetEnumValue("AL_FORMAT_QUAD32");
+                }
+            }
+            if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_MONO)
+            {
+                mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                mFrameSize *= 1;
+                mFormat = AL_FORMAT_MONO_FLOAT32;
+            }
         }
-        /* Assume 3D B-Format (ambisonics) if the channel layout is blank and
-         * there's 4 or more channels. FFmpeg/libavcodec otherwise seems to
-         * have no way to specify if the source is actually B-Format (let alone
-         * if it's 2D or 3D).
-         */
-        if(mCodecCtx->channel_layout == 0 && mCodecCtx->channels >= 4 &&
-           alIsExtensionPresent("AL_EXT_BFORMAT") &&
-           (fmt=alGetEnumValue("AL_FORMAT_BFORMAT3D_FLOAT32")) != AL_NONE && fmt != -1)
+        else if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_AMBISONIC
+            && alIsExtensionPresent("AL_EXT_BFORMAT"))
         {
-            int order{static_cast<int>(std::sqrt(mCodecCtx->channels)) - 1};
-            if((order+1)*(order+1) == mCodecCtx->channels ||
-               (order+1)*(order+1) + 2 == mCodecCtx->channels)
+            /* Calculate what should be the ambisonic order from the number of
+             * channels, and confirm that's the number of channels. Opus allows
+             * an optional non-diegetic stereo stream with the B-Format stream,
+             * which we can ignore, so check for that too.
+             */
+            auto order = static_cast<int>(std::sqrt(mCodecCtx->ch_layout.nb_channels)) - 1;
+            int channels{(order+1) * (order+1)};
+            if(channels == mCodecCtx->ch_layout.nb_channels
+                || channels+2 == mCodecCtx->ch_layout.nb_channels)
             {
                 /* OpenAL only supports first-order with AL_EXT_BFORMAT, which
                  * is 4 channels for 3D buffers.
                  */
                 mFrameSize *= 4;
-                mFormat = fmt;
+                mFormat = alGetEnumValue("AL_FORMAT_BFORMAT3D_FLOAT32");
             }
         }
-        if(!mFormat)
+        if(!mFormat || mFormat == -1)
         {
             mDstChanLayout = AV_CH_LAYOUT_STEREO;
             mFrameSize *= 2;
-            mFormat = AL_FORMAT_STEREO_FLOAT32;
+            mFormat = EnableUhj ? AL_FORMAT_UHJ2CHN_FLOAT32_SOFT : AL_FORMAT_STEREO_FLOAT32;
         }
     }
     if(mCodecCtx->sample_fmt == AV_SAMPLE_FMT_U8 || mCodecCtx->sample_fmt == AV_SAMPLE_FMT_U8P)
     {
         mDstSampleFmt = AV_SAMPLE_FMT_U8;
         mFrameSize = 1;
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN8")) != AL_NONE && fmt != -1)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 8;
-            mFormat = fmt;
-        }
-        if((mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN8")) != AL_NONE && fmt != -1)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 6;
-            mFormat = fmt;
-        }
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
+        if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE)
         {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 1;
-            mFormat = AL_FORMAT_MONO8;
+            if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+            {
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_7POINT1)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 8;
+                    mFormat = alGetEnumValue("AL_FORMAT_71CHN8");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1
+                    || mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1_BACK)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 6;
+                    mFormat = alGetEnumValue("AL_FORMAT_51CHN8");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_QUAD)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 4;
+                    mFormat = alGetEnumValue("AL_FORMAT_QUAD8");
+                }
+            }
+            if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_MONO)
+            {
+                mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                mFrameSize *= 1;
+                mFormat = AL_FORMAT_MONO8;
+            }
         }
-        if(mCodecCtx->channel_layout == 0 && mCodecCtx->channels >= 4 &&
-           alIsExtensionPresent("AL_EXT_BFORMAT") &&
-           (fmt=alGetEnumValue("AL_FORMAT_BFORMAT3D8")) != AL_NONE && fmt != -1)
+        else if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_AMBISONIC
+            && alIsExtensionPresent("AL_EXT_BFORMAT"))
         {
-            int order{static_cast<int>(std::sqrt(mCodecCtx->channels)) - 1};
-            if((order+1)*(order+1) == mCodecCtx->channels ||
-               (order+1)*(order+1) + 2 == mCodecCtx->channels)
+            auto order = static_cast<int>(std::sqrt(mCodecCtx->ch_layout.nb_channels)) - 1;
+            int channels{(order+1) * (order+1)};
+            if(channels == mCodecCtx->ch_layout.nb_channels
+                || channels+2 == mCodecCtx->ch_layout.nb_channels)
             {
                 mFrameSize *= 4;
-                mFormat = fmt;
+                mFormat = alGetEnumValue("AL_FORMAT_BFORMAT3D_8");
             }
         }
-        if(!mFormat)
+        if(!mFormat || mFormat == -1)
         {
             mDstChanLayout = AV_CH_LAYOUT_STEREO;
             mFrameSize *= 2;
-            mFormat = AL_FORMAT_STEREO8;
+            mFormat = EnableUhj ? AL_FORMAT_UHJ2CHN8_SOFT : AL_FORMAT_STEREO8;
         }
     }
-    if(!mFormat)
+    if(!mFormat || mFormat == -1)
     {
         mDstSampleFmt = AV_SAMPLE_FMT_S16;
         mFrameSize = 2;
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN16")) != AL_NONE && fmt != -1)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 8;
-            mFormat = fmt;
-        }
-        if((mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            mCodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN16")) != AL_NONE && fmt != -1)
+        if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE)
         {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 6;
-            mFormat = fmt;
-        }
-        if(mCodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
-        {
-            mDstChanLayout = mCodecCtx->channel_layout;
-            mFrameSize *= 1;
-            mFormat = AL_FORMAT_MONO16;
+            if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
+            {
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_7POINT1)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 8;
+                    mFormat = alGetEnumValue("AL_FORMAT_71CHN16");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1
+                    || mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_5POINT1_BACK)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 6;
+                    mFormat = alGetEnumValue("AL_FORMAT_51CHN16");
+                }
+                if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_QUAD)
+                {
+                    mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                    mFrameSize *= 4;
+                    mFormat = alGetEnumValue("AL_FORMAT_QUAD16");
+                }
+            }
+            if(mCodecCtx->ch_layout.u.mask == AV_CH_LAYOUT_MONO)
+            {
+                mDstChanLayout = mCodecCtx->ch_layout.u.mask;
+                mFrameSize *= 1;
+                mFormat = AL_FORMAT_MONO16;
+            }
         }
-        if(mCodecCtx->channel_layout == 0 && mCodecCtx->channels >= 4 &&
-           alIsExtensionPresent("AL_EXT_BFORMAT") &&
-           (fmt=alGetEnumValue("AL_FORMAT_BFORMAT3D16")) != AL_NONE && fmt != -1)
+        else if(mCodecCtx->ch_layout.order == AV_CHANNEL_ORDER_AMBISONIC
+            && alIsExtensionPresent("AL_EXT_BFORMAT"))
         {
-            int order{static_cast<int>(std::sqrt(mCodecCtx->channels)) - 1};
-            if((order+1)*(order+1) == mCodecCtx->channels ||
-               (order+1)*(order+1) + 2 == mCodecCtx->channels)
+            auto order = static_cast<int>(std::sqrt(mCodecCtx->ch_layout.nb_channels)) - 1;
+            int channels{(order+1) * (order+1)};
+            if(channels == mCodecCtx->ch_layout.nb_channels
+                || channels+2 == mCodecCtx->ch_layout.nb_channels)
             {
                 mFrameSize *= 4;
-                mFormat = fmt;
+                mFormat = alGetEnumValue("AL_FORMAT_BFORMAT3D_16");
             }
         }
-        if(!mFormat)
+        if(!mFormat || mFormat == -1)
         {
             mDstChanLayout = AV_CH_LAYOUT_STEREO;
             mFrameSize *= 2;
-            mFormat = AL_FORMAT_STEREO16;
+            mFormat = EnableUhj ? AL_FORMAT_UHJ2CHN16_SOFT : AL_FORMAT_STEREO16;
         }
     }
-    void *samples{nullptr};
-    ALsizei buffer_len = static_cast<int>(std::chrono::duration_cast<seconds>(
-        mCodecCtx->sample_rate * AudioBufferTime).count() * mFrameSize);
 
     mSamples = nullptr;
     mSamplesMax = 0;
@@ -941,82 +1129,144 @@ int AudioState::handler()
     if(!mDecodedFrame)
     {
         std::cerr<< "Failed to allocate audio frame" <<std::endl;
-        goto finish;
+        return 0;
     }
 
+    /* Note that ffmpeg assumes AmbiX (ACN layout, SN3D normalization). */
+    const bool has_bfmt_ex{alIsExtensionPresent("AL_SOFT_bformat_ex") != AL_FALSE};
+    const ALenum ambi_layout{AL_ACN_SOFT};
+    const ALenum ambi_scale{AL_SN3D_SOFT};
+
     if(!mDstChanLayout)
     {
         /* OpenAL only supports first-order ambisonics with AL_EXT_BFORMAT, so
-         * we have to drop any extra channels. It also only supports FuMa
-         * channel ordering and normalization, so a custom matrix is needed to
-         * scale and reorder the source from AmbiX.
-         */
-        mSwresCtx.reset(swr_alloc_set_opts(nullptr,
-            (1_i64<<4)-1, mDstSampleFmt, mCodecCtx->sample_rate,
-            (1_i64<<mCodecCtx->channels)-1, mCodecCtx->sample_fmt, mCodecCtx->sample_rate,
-            0, nullptr));
-
-        /* Note that ffmpeg/libavcodec has no method to check the ambisonic
-         * channel order and normalization, so we can only assume AmbiX as the
-         * defacto-standard. This is not true for .amb files, which use FuMa.
+         * we have to drop any extra channels.
          */
-        std::vector<double> mtx(64*64, 0.0);
-        mtx[0 + 0*64] = std::sqrt(0.5);
-        mtx[3 + 1*64] = 1.0;
-        mtx[1 + 2*64] = 1.0;
-        mtx[2 + 3*64] = 1.0;
-        swr_set_matrix(mSwresCtx.get(), mtx.data(), 64);
+        ChannelLayout layout{};
+        av_channel_layout_from_string(&layout, "ambisonic 1");
+
+        SwrContext *ps{};
+        int err{swr_alloc_set_opts2(&ps, &layout, mDstSampleFmt, mCodecCtx->sample_rate,
+            &mCodecCtx->ch_layout, mCodecCtx->sample_fmt, mCodecCtx->sample_rate, 0, nullptr)};
+        mSwresCtx.reset(ps);
+        if(err != 0)
+        {
+            char errstr[AV_ERROR_MAX_STRING_SIZE]{};
+            std::cerr<< "Failed to allocate SwrContext: "
+                <<av_make_error_string(errstr, AV_ERROR_MAX_STRING_SIZE, err) <<std::endl;
+            return 0;
+        }
+
+        if(has_bfmt_ex)
+            std::cout<< "Found AL_SOFT_bformat_ex" <<std::endl;
+        else
+        {
+            std::cout<< "Found AL_EXT_BFORMAT" <<std::endl;
+            /* Without AL_SOFT_bformat_ex, OpenAL only supports FuMa channel
+             * ordering and normalization, so a custom matrix is needed to
+             * scale and reorder the source from AmbiX.
+             */
+            std::vector<double> mtx(64*64, 0.0);
+            mtx[0 + 0*64] = std::sqrt(0.5);
+            mtx[3 + 1*64] = 1.0;
+            mtx[1 + 2*64] = 1.0;
+            mtx[2 + 3*64] = 1.0;
+            swr_set_matrix(mSwresCtx.get(), mtx.data(), 64);
+        }
     }
     else
-        mSwresCtx.reset(swr_alloc_set_opts(nullptr,
-            static_cast<int64_t>(mDstChanLayout), mDstSampleFmt, mCodecCtx->sample_rate,
-            mCodecCtx->channel_layout ? static_cast<int64_t>(mCodecCtx->channel_layout) :
-                av_get_default_channel_layout(mCodecCtx->channels),
-            mCodecCtx->sample_fmt, mCodecCtx->sample_rate,
-            0, nullptr));
-    if(!mSwresCtx || swr_init(mSwresCtx.get()) != 0)
     {
-        std::cerr<< "Failed to initialize audio converter" <<std::endl;
-        goto finish;
+        ChannelLayout layout{};
+        av_channel_layout_from_mask(&layout, mDstChanLayout);
+
+        SwrContext *ps{};
+        int err{swr_alloc_set_opts2(&ps, &layout, mDstSampleFmt, mCodecCtx->sample_rate,
+            &mCodecCtx->ch_layout, mCodecCtx->sample_fmt, mCodecCtx->sample_rate, 0, nullptr)};
+        mSwresCtx.reset(ps);
+        if(err != 0)
+        {
+            char errstr[AV_ERROR_MAX_STRING_SIZE]{};
+            std::cerr<< "Failed to allocate SwrContext: "
+                <<av_make_error_string(errstr, AV_ERROR_MAX_STRING_SIZE, err) <<std::endl;
+            return 0;
+        }
+    }
+    if(int err{swr_init(mSwresCtx.get())})
+    {
+        char errstr[AV_ERROR_MAX_STRING_SIZE]{};
+        std::cerr<< "Failed to initialize audio converter: "
+            <<av_make_error_string(errstr, AV_ERROR_MAX_STRING_SIZE, err) <<std::endl;
+        return 0;
     }
 
-    mBuffers.assign(AudioBufferTotalTime / AudioBufferTime, 0);
     alGenBuffers(static_cast<ALsizei>(mBuffers.size()), mBuffers.data());
     alGenSources(1, &mSource);
 
-    if(EnableDirectOut)
-        alSourcei(mSource, AL_DIRECT_CHANNELS_SOFT, AL_TRUE);
-    if (EnableWideStereo) {
-        ALfloat angles[2] = {static_cast<ALfloat>(M_PI / 3.0),
-                             static_cast<ALfloat>(-M_PI / 3.0)};
+    if(DirectOutMode)
+        alSourcei(mSource, AL_DIRECT_CHANNELS_SOFT, DirectOutMode);
+    if(EnableWideStereo)
+    {
+        const float angles[2]{static_cast<float>(M_PI / 3.0), static_cast<float>(-M_PI / 3.0)};
         alSourcefv(mSource, AL_STEREO_ANGLES, angles);
     }
+    if(has_bfmt_ex)
+    {
+        for(ALuint bufid : mBuffers)
+        {
+            alBufferi(bufid, AL_AMBISONIC_LAYOUT_SOFT, ambi_layout);
+            alBufferi(bufid, AL_AMBISONIC_SCALING_SOFT, ambi_scale);
+        }
+    }
+#ifdef AL_SOFT_UHJ
+    if(EnableSuperStereo)
+        alSourcei(mSource, AL_STEREO_MODE_SOFT, AL_SUPER_STEREO_SOFT);
+#endif
 
     if(alGetError() != AL_NO_ERROR)
-        goto finish;
+        return 0;
 
-#ifdef AL_SOFT_map_buffer
-    if(alBufferStorageSOFT)
+    bool callback_ok{false};
+    if(alBufferCallbackSOFT)
     {
-        for(ALuint bufid : mBuffers)
-            alBufferStorageSOFT(bufid, mFormat, nullptr, buffer_len, mCodecCtx->sample_rate,
-                                AL_MAP_WRITE_BIT_SOFT);
+        alBufferCallbackSOFT(mBuffers[0], mFormat, mCodecCtx->sample_rate, bufferCallbackC, this);
+        alSourcei(mSource, AL_BUFFER, static_cast<ALint>(mBuffers[0]));
         if(alGetError() != AL_NO_ERROR)
         {
-            fprintf(stderr, "Failed to use mapped buffers\n");
-            samples = av_malloc(static_cast<ALuint>(buffer_len));
+            fprintf(stderr, "Failed to set buffer callback\n");
+            alSourcei(mSource, AL_BUFFER, 0);
+        }
+        else
+        {
+            mBufferDataSize = static_cast<size_t>(duration_cast<seconds>(mCodecCtx->sample_rate *
+                AudioBufferTotalTime).count()) * mFrameSize;
+            mBufferData = std::make_unique<uint8_t[]>(mBufferDataSize);
+            std::fill_n(mBufferData.get(), mBufferDataSize, uint8_t{});
+
+            mReadPos.store(0, std::memory_order_relaxed);
+            mWritePos.store(mBufferDataSize/mFrameSize/2*mFrameSize, std::memory_order_relaxed);
+
+            ALCint refresh{};
+            alcGetIntegerv(alcGetContextsDevice(alcGetCurrentContext()), ALC_REFRESH, 1, &refresh);
+            sleep_time = milliseconds{seconds{1}} / refresh;
+            callback_ok = true;
         }
     }
-    else
-#endif
-        samples = av_malloc(static_cast<ALuint>(buffer_len));
+    if(!callback_ok)
+        buffer_len = static_cast<int>(duration_cast<seconds>(mCodecCtx->sample_rate *
+            AudioBufferTime).count() * mFrameSize);
+    if(buffer_len > 0)
+        samples = std::make_unique<uint8_t[]>(static_cast<ALuint>(buffer_len));
 
     /* Prefill the codec buffer. */
-    do {
-        const int ret{mPackets.sendTo(mCodecCtx.get())};
-        if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
-            break;
-    } while(1);
+    auto packet_sender = [this]()
+    {
+        while(1)
+        {
+            const int ret{mQueue.sendPacket(mCodecCtx.get())};
+            if(ret == AVErrorEOF) break;
+        }
+    };
+    auto sender = std::async(std::launch::async, packet_sender);
 
     srclock.lock();
     if(alcGetInteger64vSOFT)
@@ -1026,100 +1276,116 @@ int AudioState::handler()
             1, &devtime);
         mDeviceStartTime = nanoseconds{devtime} - mCurrentPts;
     }
-    while(alGetError() == AL_NO_ERROR && !mMovie.mQuit.load(std::memory_order_relaxed) &&
-          mConnected.test_and_set(std::memory_order_relaxed))
+
+    mSamplesLen = decodeFrame();
+    if(mSamplesLen > 0)
+    {
+        mSamplesPos = std::min(mSamplesLen, getSync());
+
+        auto skip = nanoseconds{seconds{mSamplesPos}} / mCodecCtx->sample_rate;
+        mDeviceStartTime -= skip;
+        mCurrentPts += skip;
+    }
+
+    while(1)
     {
-        /* First remove any processed buffers. */
-        ALint processed;
-        alGetSourcei(mSource, AL_BUFFERS_PROCESSED, &processed);
-        while(processed > 0)
+        if(mMovie.mQuit.load(std::memory_order_relaxed))
         {
-            std::array<ALuint,4> bids;
-            const ALsizei todq{std::min<ALsizei>(bids.size(), processed)};
-            alSourceUnqueueBuffers(mSource, todq, bids.data());
-            processed -= todq;
+            /* If mQuit is set, drain frames until we can't get more audio,
+             * indicating we've reached the flush packet and the packet sender
+             * will also quit.
+             */
+            do {
+                mSamplesLen = decodeFrame();
+                mSamplesPos = mSamplesLen;
+            } while(mSamplesLen > 0);
+            goto finish;
         }
 
-        /* Refill the buffer queue. */
-        ALint queued;
-        alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
-        while(static_cast<ALuint>(queued) < mBuffers.size())
+        ALenum state;
+        if(mBufferDataSize > 0)
         {
-            const ALuint bufid{mBuffers[mBufferIdx]};
-            /* Read the next chunk of data, filling the buffer, and queue it on
-             * the source.
+            alGetSourcei(mSource, AL_SOURCE_STATE, &state);
+
+            /* If mQuit is not set, don't quit even if there's no more audio,
+             * so what's buffered has a chance to play to the real end.
              */
-#ifdef AL_SOFT_map_buffer
-            if(!samples)
+            readAudio(getSync());
+        }
+        else
+        {
+            ALint processed, queued;
+
+            /* First remove any processed buffers. */
+            alGetSourcei(mSource, AL_BUFFERS_PROCESSED, &processed);
+            while(processed > 0)
             {
-                auto ptr = static_cast<uint8_t*>(alMapBufferSOFT(bufid, 0, buffer_len,
-                    AL_MAP_WRITE_BIT_SOFT));
-                bool got_audio{readAudio(ptr, static_cast<unsigned int>(buffer_len))};
-                alUnmapBufferSOFT(bufid);
-                if(!got_audio) break;
+                ALuint bid;
+                alSourceUnqueueBuffers(mSource, 1, &bid);
+                --processed;
             }
-            else
-#endif
+
+            /* Refill the buffer queue. */
+            int sync_skip{getSync()};
+            alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
+            while(static_cast<ALuint>(queued) < mBuffers.size())
             {
-                auto ptr = static_cast<uint8_t*>(samples);
-                if(!readAudio(ptr, static_cast<unsigned int>(buffer_len)))
+                /* Read the next chunk of data, filling the buffer, and queue
+                 * it on the source.
+                 */
+                if(!readAudio(samples.get(), static_cast<ALuint>(buffer_len), sync_skip))
                     break;
-                alBufferData(bufid, mFormat, samples, buffer_len, mCodecCtx->sample_rate);
-            }
 
-            alSourceQueueBuffers(mSource, 1, &bufid);
-            mBufferIdx = (mBufferIdx+1) % mBuffers.size();
-            ++queued;
-        }
-        if(queued == 0)
-            break;
+                const ALuint bufid{mBuffers[mBufferIdx]};
+                mBufferIdx = static_cast<ALuint>((mBufferIdx+1) % mBuffers.size());
 
-        /* Check that the source is playing. */
-        ALint state;
-        alGetSourcei(mSource, AL_SOURCE_STATE, &state);
-        if(state == AL_STOPPED)
-        {
-            /* AL_STOPPED means there was an underrun. Clear the buffer queue
-             * since this likely means we're late, and rewind the source to get
-             * it back into an AL_INITIAL state.
-             */
-            alSourceRewind(mSource);
-            alSourcei(mSource, AL_BUFFER, 0);
-            if(alcGetInteger64vSOFT)
+                alBufferData(bufid, mFormat, samples.get(), buffer_len, mCodecCtx->sample_rate);
+                alSourceQueueBuffers(mSource, 1, &bufid);
+                ++queued;
+            }
+
+            /* Check that the source is playing. */
+            alGetSourcei(mSource, AL_SOURCE_STATE, &state);
+            if(state == AL_STOPPED)
             {
-                /* Also update the device start time with the current device
-                 * clock, so the decoder knows we're running behind.
+                /* AL_STOPPED means there was an underrun. Clear the buffer
+                 * queue since this likely means we're late, and rewind the
+                 * source to get it back into an AL_INITIAL state.
                  */
-                int64_t devtime{};
-                alcGetInteger64vSOFT(alcGetContextsDevice(alcGetCurrentContext()),
-                    ALC_DEVICE_CLOCK_SOFT, 1, &devtime);
-                mDeviceStartTime = nanoseconds{devtime} - mCurrentPts;
+                alSourceRewind(mSource);
+                alSourcei(mSource, AL_BUFFER, 0);
+                if(alcGetInteger64vSOFT)
+                {
+                    /* Also update the device start time with the current
+                     * device clock, so the decoder knows we're running behind.
+                     */
+                    int64_t devtime{};
+                    alcGetInteger64vSOFT(alcGetContextsDevice(alcGetCurrentContext()),
+                        ALC_DEVICE_CLOCK_SOFT, 1, &devtime);
+                    mDeviceStartTime = nanoseconds{devtime} - mCurrentPts;
+                }
+                continue;
             }
-            continue;
         }
 
         /* (re)start the source if needed, and wait for a buffer to finish */
         if(state != AL_PLAYING && state != AL_PAUSED)
-            startPlayback();
+        {
+            if(!startPlayback())
+                break;
+        }
+        if(ALenum err{alGetError()})
+            std::cerr<< "Got AL error: 0x"<<std::hex<<err<<std::dec
+                << " ("<<alGetString(err)<<")" <<std::endl;
 
         mSrcCond.wait_for(srclock, sleep_time);
     }
+finish:
 
     alSourceRewind(mSource);
     alSourcei(mSource, AL_BUFFER, 0);
     srclock.unlock();
 
-finish:
-    av_freep(&samples);
-
-#ifdef AL_SOFT_events
-    if(alEventControlSOFT)
-    {
-        alEventControlSOFT(evt_types.size(), evt_types.data(), AL_FALSE);
-        alEventCallbackSOFT(nullptr, nullptr);
-    }
-#endif
-
     return 0;
 }
 
@@ -1135,7 +1401,7 @@ nanoseconds VideoState::getClock()
 }
 
 /* Called by VideoState::updateVideo to display the next video frame. */
-void VideoState::display(SDL_Window *screen, SDL_Renderer *renderer)
+void VideoState::display(SDL_Window *screen, SDL_Renderer *renderer, AVFrame *frame)
 {
     if(!mImage)
         return;
@@ -1144,15 +1410,17 @@ void VideoState::display(SDL_Window *screen, SDL_Renderer *renderer)
     int win_w, win_h;
     int w, h, x, y;
 
-    if(mCodecCtx->sample_aspect_ratio.num == 0)
+    int frame_width{frame->width - static_cast<int>(frame->crop_left + frame->crop_right)};
+    int frame_height{frame->height - static_cast<int>(frame->crop_top + frame->crop_bottom)};
+    if(frame->sample_aspect_ratio.num == 0)
         aspect_ratio = 0.0;
     else
     {
-        aspect_ratio = av_q2d(mCodecCtx->sample_aspect_ratio) * mCodecCtx->width /
-                       mCodecCtx->height;
+        aspect_ratio = av_q2d(frame->sample_aspect_ratio) * frame_width /
+            frame_height;
     }
     if(aspect_ratio <= 0.0)
-        aspect_ratio = static_cast<double>(mCodecCtx->width) / mCodecCtx->height;
+        aspect_ratio = static_cast<double>(frame_width) / frame_height;
 
     SDL_GetWindowSize(screen, &win_w, &win_h);
     h = win_h;
@@ -1165,7 +1433,8 @@ void VideoState::display(SDL_Window *screen, SDL_Renderer *renderer)
     x = (win_w - w) / 2;
     y = (win_h - h) / 2;
 
-    SDL_Rect src_rect{ 0, 0, mWidth, mHeight };
+    SDL_Rect src_rect{ static_cast<int>(frame->crop_left), static_cast<int>(frame->crop_top),
+        frame_width, frame_height };
     SDL_Rect dst_rect{ x, y, w, h };
     SDL_RenderCopy(renderer, mImage, &src_rect, &dst_rect);
     SDL_RenderPresent(renderer);
@@ -1188,8 +1457,12 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
         if(next_idx == mPictQWrite.load(std::memory_order_acquire))
             break;
         Picture *nextvp{&mPictQ[next_idx]};
-        if(clocktime < nextvp->mPts)
-            break;
+        if(clocktime < nextvp->mPts && !mMovie.mQuit.load(std::memory_order_relaxed))
+        {
+            /* For the first update, ensure the first frame gets shown.  */
+            if(!mFirstUpdate || updated)
+                break;
+        }
 
         vp = nextvp;
         updated = true;
@@ -1205,6 +1478,7 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
         return;
     }
 
+    AVFrame *frame{vp->mFrame.get()};
     if(updated)
     {
         mPictQRead.store(read_idx, std::memory_order_release);
@@ -1213,40 +1487,39 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
 
         /* allocate or resize the buffer! */
         bool fmt_updated{false};
-        if(!mImage || mWidth != mCodecCtx->width || mHeight != mCodecCtx->height)
+        if(!mImage || mWidth != frame->width || mHeight != frame->height)
         {
             fmt_updated = true;
             if(mImage)
                 SDL_DestroyTexture(mImage);
             mImage = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING,
-                mCodecCtx->coded_width, mCodecCtx->coded_height);
+                frame->width, frame->height);
             if(!mImage)
                 std::cerr<< "Failed to create YV12 texture!" <<std::endl;
-            mWidth = mCodecCtx->width;
-            mHeight = mCodecCtx->height;
+            mWidth = frame->width;
+            mHeight = frame->height;
+        }
 
-            if(mFirstUpdate && mWidth > 0 && mHeight > 0)
-            {
-                /* For the first update, set the window size to the video size. */
-                mFirstUpdate = false;
+        int frame_width{frame->width - static_cast<int>(frame->crop_left + frame->crop_right)};
+        int frame_height{frame->height - static_cast<int>(frame->crop_top + frame->crop_bottom)};
+        if(mFirstUpdate && frame_width > 0 && frame_height > 0)
+        {
+            /* For the first update, set the window size to the video size. */
+            mFirstUpdate = false;
 
-                int w{mWidth};
-                int h{mHeight};
-                if(mCodecCtx->sample_aspect_ratio.den != 0)
-                {
-                    double aspect_ratio = av_q2d(mCodecCtx->sample_aspect_ratio);
-                    if(aspect_ratio >= 1.0)
-                        w = static_cast<int>(w*aspect_ratio + 0.5);
-                    else if(aspect_ratio > 0.0)
-                        h = static_cast<int>(h/aspect_ratio + 0.5);
-                }
-                SDL_SetWindowSize(screen, w, h);
+            if(frame->sample_aspect_ratio.den != 0)
+            {
+                double aspect_ratio = av_q2d(frame->sample_aspect_ratio);
+                if(aspect_ratio >= 1.0)
+                    frame_width = static_cast<int>(frame_width*aspect_ratio + 0.5);
+                else if(aspect_ratio > 0.0)
+                    frame_height = static_cast<int>(frame_height/aspect_ratio + 0.5);
             }
+            SDL_SetWindowSize(screen, frame_width, frame_height);
         }
 
         if(mImage)
         {
-            AVFrame *frame{vp->mFrame.get()};
             void *pixels{nullptr};
             int pitch{0};
 
@@ -1261,10 +1534,8 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
             else
             {
                 // Convert the image into YUV format that SDL uses
-                int coded_w{mCodecCtx->coded_width};
-                int coded_h{mCodecCtx->coded_height};
-                int w{mCodecCtx->width};
-                int h{mCodecCtx->height};
+                int w{frame->width};
+                int h{frame->height};
                 if(!mSwscaleCtx || fmt_updated)
                 {
                     mSwscaleCtx.reset(sws_getContext(
@@ -1277,8 +1548,8 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
                 /* point pict at the queue */
                 uint8_t *pict_data[3];
                 pict_data[0] = static_cast<uint8_t*>(pixels);
-                pict_data[1] = pict_data[0] + coded_w*coded_h;
-                pict_data[2] = pict_data[1] + coded_w*coded_h/4;
+                pict_data[1] = pict_data[0] + w*h;
+                pict_data[2] = pict_data[1] + w*h/4;
 
                 int pict_linesize[3];
                 pict_linesize[0] = pitch;
@@ -1289,15 +1560,15 @@ void VideoState::updateVideo(SDL_Window *screen, SDL_Renderer *renderer, bool re
                     0, h, pict_data, pict_linesize);
                 SDL_UnlockTexture(mImage);
             }
-        }
 
-        redraw = true;
+            redraw = true;
+        }
     }
 
     if(redraw)
     {
         /* Show the picture! */
-        display(screen, renderer);
+        display(screen, renderer, frame);
     }
 
     if(updated)
@@ -1326,11 +1597,15 @@ int VideoState::handler()
         { pict.mFrame = AVFramePtr{av_frame_alloc()}; });
 
     /* Prefill the codec buffer. */
-    do {
-        const int ret{mPackets.sendTo(mCodecCtx.get())};
-        if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
-            break;
-    } while(1);
+    auto packet_sender = [this]()
+    {
+        while(1)
+        {
+            const int ret{mQueue.sendPacket(mCodecCtx.get())};
+            if(ret == AVErrorEOF) break;
+        }
+    };
+    auto sender = std::async(std::launch::async, packet_sender);
 
     {
         std::lock_guard<std::mutex> _{mDispPtsMutex};
@@ -1338,33 +1613,29 @@ int VideoState::handler()
     }
 
     auto current_pts = nanoseconds::zero();
-    while(!mMovie.mQuit.load(std::memory_order_relaxed))
+    while(1)
     {
         size_t write_idx{mPictQWrite.load(std::memory_order_relaxed)};
         Picture *vp{&mPictQ[write_idx]};
 
         /* Retrieve video frame. */
         AVFrame *decoded_frame{vp->mFrame.get()};
-        int ret;
-        while((ret=avcodec_receive_frame(mCodecCtx.get(), decoded_frame)) == AVERROR(EAGAIN))
-            mPackets.sendTo(mCodecCtx.get());
-        if(ret != 0)
+        while(int ret{mQueue.receiveFrame(mCodecCtx.get(), decoded_frame)})
         {
-            if(ret == AVERROR_EOF) break;
+            if(ret == AVErrorEOF) goto finish;
             std::cerr<< "Failed to receive frame: "<<ret <<std::endl;
-            continue;
         }
 
         /* Get the PTS for this frame. */
-        if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
-            current_pts = std::chrono::duration_cast<nanoseconds>(
-                seconds_d64{av_q2d(mStream->time_base)*decoded_frame->best_effort_timestamp});
+        if(decoded_frame->best_effort_timestamp != AVNoPtsValue)
+            current_pts = duration_cast<nanoseconds>(seconds_d64{av_q2d(mStream->time_base) *
+                static_cast<double>(decoded_frame->best_effort_timestamp)});
         vp->mPts = current_pts;
 
         /* Update the video clock to the next expected PTS. */
         auto frame_delay = av_q2d(mCodecCtx->time_base);
         frame_delay += decoded_frame->repeat_pict * (frame_delay * 0.5);
-        current_pts += std::chrono::duration_cast<nanoseconds>(seconds_d64{frame_delay});
+        current_pts += duration_cast<nanoseconds>(seconds_d64{frame_delay});
 
         /* Put the frame in the queue to be loaded into a texture and displayed
          * by the rendering thread.
@@ -1372,18 +1643,15 @@ int VideoState::handler()
         write_idx = (write_idx+1)%mPictQ.size();
         mPictQWrite.store(write_idx, std::memory_order_release);
 
-        /* Send a packet now so it's hopefully ready by the time it's needed. */
-        mPackets.sendTo(mCodecCtx.get());
-
         if(write_idx == mPictQRead.load(std::memory_order_acquire))
         {
             /* Wait until we have space for a new pic */
             std::unique_lock<std::mutex> lock{mPictQMutex};
-            while(write_idx == mPictQRead.load(std::memory_order_acquire) &&
-                !mMovie.mQuit.load(std::memory_order_relaxed))
+            while(write_idx == mPictQRead.load(std::memory_order_acquire))
                 mPictQCond.wait(lock);
         }
     }
+finish:
     mEOS = true;
 
     std::unique_lock<std::mutex> lock{mPictQMutex};
@@ -1429,7 +1697,13 @@ bool MovieState::prepare()
         return false;
     }
 
+    /* Dump information about file onto standard error */
+    av_dump_format(mFormatCtx.get(), 0, mFilename.c_str(), 0);
+
     mParseThread = std::thread{std::mem_fn(&MovieState::parse_handler), this};
+
+    std::unique_lock<std::mutex> slock{mStartupMutex};
+    while(!mStartupDone) mStartupCond.wait(slock);
     return true;
 }
 
@@ -1452,9 +1726,9 @@ nanoseconds MovieState::getClock()
 
 nanoseconds MovieState::getMasterClock()
 {
-    if(mAVSyncType == SyncMaster::Video)
+    if(mAVSyncType == SyncMaster::Video && mVideo.mStream)
         return mVideo.getClock();
-    if(mAVSyncType == SyncMaster::Audio)
+    if(mAVSyncType == SyncMaster::Audio && mAudio.mStream)
         return mAudio.getClock();
     return getClock();
 }
@@ -1476,7 +1750,7 @@ int MovieState::streamComponentOpen(unsigned int stream_index)
     if(avcodec_parameters_to_context(avctx.get(), mFormatCtx->streams[stream_index]->codecpar))
         return -1;
 
-    AVCodec *codec{avcodec_find_decoder(avctx->codec_id)};
+    const AVCodec *codec{avcodec_find_decoder(avctx->codec_id)};
     if(!codec || avcodec_open2(avctx.get(), codec, nullptr) < 0)
     {
         std::cerr<< "Unsupported codec: "<<avcodec_get_name(avctx->codec_id)
@@ -1506,15 +1780,12 @@ int MovieState::streamComponentOpen(unsigned int stream_index)
 
 int MovieState::parse_handler()
 {
-    auto &audio_queue = mAudio.mPackets;
-    auto &video_queue = mVideo.mPackets;
+    auto &audio_queue = mAudio.mQueue;
+    auto &video_queue = mVideo.mQueue;
 
     int video_index{-1};
     int audio_index{-1};
 
-    /* Dump information about file onto standard error */
-    av_dump_format(mFormatCtx.get(), 0, mFilename.c_str(), 0);
-
     /* Find the first video and audio streams */
     for(unsigned int i{0u};i < mFormatCtx->nb_streams;i++)
     {
@@ -1525,6 +1796,12 @@ int MovieState::parse_handler()
             audio_index = streamComponentOpen(i);
     }
 
+    {
+        std::unique_lock<std::mutex> slock{mStartupMutex};
+        mStartupDone = true;
+    }
+    mStartupCond.notify_all();
+
     if(video_index < 0 && audio_index < 0)
     {
         std::cerr<< mFilename<<": could not open codecs" <<std::endl;
@@ -1540,29 +1817,29 @@ int MovieState::parse_handler()
         mVideoThread = std::thread{std::mem_fn(&VideoState::handler), &mVideo};
 
     /* Main packet reading/dispatching loop */
+    AVPacketPtr packet{av_packet_alloc()};
     while(!mQuit.load(std::memory_order_relaxed))
     {
-        AVPacket packet;
-        if(av_read_frame(mFormatCtx.get(), &packet) < 0)
+        if(av_read_frame(mFormatCtx.get(), packet.get()) < 0)
             break;
 
         /* Copy the packet into the queue it's meant for. */
-        if(packet.stream_index == video_index)
+        if(packet->stream_index == video_index)
         {
-            while(!mQuit.load(std::memory_order_acquire) && !video_queue.put(&packet))
+            while(!mQuit.load(std::memory_order_acquire) && !video_queue.put(packet.get()))
                 std::this_thread::sleep_for(milliseconds{100});
         }
-        else if(packet.stream_index == audio_index)
+        else if(packet->stream_index == audio_index)
         {
-            while(!mQuit.load(std::memory_order_acquire) && !audio_queue.put(&packet))
+            while(!mQuit.load(std::memory_order_acquire) && !audio_queue.put(packet.get()))
                 std::this_thread::sleep_for(milliseconds{100});
         }
 
-        av_packet_unref(&packet);
+        av_packet_unref(packet.get());
     }
     /* Finish the queues so the receivers know nothing more is coming. */
-    if(mVideo.mCodecCtx) video_queue.setFinished();
-    if(mAudio.mCodecCtx) audio_queue.setFinished();
+    video_queue.setFinished();
+    audio_queue.setFinished();
 
     /* all done - wait for it */
     if(mVideoThread.joinable())
@@ -1583,6 +1860,13 @@ int MovieState::parse_handler()
     return 0;
 }
 
+void MovieState::stop()
+{
+    mQuit = true;
+    mAudio.mQueue.flush();
+    mVideo.mQueue.flush();
+}
+
 
 // Helper class+method to print the time with human-readable formatting.
 struct PrettyTime {
@@ -1592,7 +1876,6 @@ std::ostream &operator<<(std::ostream &os, const PrettyTime &rhs)
 {
     using hours = std::chrono::hours;
     using minutes = std::chrono::minutes;
-    using std::chrono::duration_cast;
 
     seconds t{rhs.mTime};
     if(t.count() < 0)
@@ -1617,6 +1900,8 @@ std::ostream &operator<<(std::ostream &os, const PrettyTime &rhs)
 
 int main(int argc, char *argv[])
 {
+    SDL_SetMainReady();
+
     std::unique_ptr<MovieState> movState;
 
     if(argc < 2)
@@ -1706,20 +1991,7 @@ int main(int argc, char *argv[])
             alGetProcAddress("alGetSourcei64vSOFT")
         );
     }
-#ifdef AL_SOFT_map_buffer
-    if(alIsExtensionPresent("AL_SOFTX_map_buffer"))
-    {
-        std::cout<< "Found AL_SOFT_map_buffer" <<std::endl;
-        alBufferStorageSOFT = reinterpret_cast<LPALBUFFERSTORAGESOFT>(
-            alGetProcAddress("alBufferStorageSOFT"));
-        alMapBufferSOFT = reinterpret_cast<LPALMAPBUFFERSOFT>(
-            alGetProcAddress("alMapBufferSOFT"));
-        alUnmapBufferSOFT = reinterpret_cast<LPALUNMAPBUFFERSOFT>(
-            alGetProcAddress("alUnmapBufferSOFT"));
-    }
-#endif
-#ifdef AL_SOFT_events
-    if(alIsExtensionPresent("AL_SOFTX_events"))
+    if(alIsExtensionPresent("AL_SOFT_events"))
     {
         std::cout<< "Found AL_SOFT_events" <<std::endl;
         alEventControlSOFT = reinterpret_cast<LPALEVENTCONTROLSOFT>(
@@ -1727,20 +1999,30 @@ int main(int argc, char *argv[])
         alEventCallbackSOFT = reinterpret_cast<LPALEVENTCALLBACKSOFT>(
             alGetProcAddress("alEventCallbackSOFT"));
     }
-#endif
+    if(alIsExtensionPresent("AL_SOFT_callback_buffer"))
+    {
+        std::cout<< "Found AL_SOFT_callback_buffer" <<std::endl;
+        alBufferCallbackSOFT = reinterpret_cast<LPALBUFFERCALLBACKSOFT>(
+            alGetProcAddress("alBufferCallbackSOFT"));
+    }
 
     int fileidx{0};
     for(;fileidx < argc;++fileidx)
     {
         if(strcmp(argv[fileidx], "-direct") == 0)
         {
-            if(!alIsExtensionPresent("AL_SOFT_direct_channels"))
-                std::cerr<< "AL_SOFT_direct_channels not supported for direct output" <<std::endl;
-            else
+            if(alIsExtensionPresent("AL_SOFT_direct_channels_remix"))
+            {
+                std::cout<< "Found AL_SOFT_direct_channels_remix" <<std::endl;
+                DirectOutMode = AL_REMIX_UNMATCHED_SOFT;
+            }
+            else if(alIsExtensionPresent("AL_SOFT_direct_channels"))
             {
                 std::cout<< "Found AL_SOFT_direct_channels" <<std::endl;
-                EnableDirectOut = true;
+                DirectOutMode = AL_DROP_UNMATCHED_SOFT;
             }
+            else
+                std::cerr<< "AL_SOFT_direct_channels not supported for direct output" <<std::endl;
         }
         else if(strcmp(argv[fileidx], "-wide") == 0)
         {
@@ -1752,6 +2034,26 @@ int main(int argc, char *argv[])
                 EnableWideStereo = true;
             }
         }
+        else if(strcmp(argv[fileidx], "-uhj") == 0)
+        {
+            if(!alIsExtensionPresent("AL_SOFT_UHJ"))
+                std::cerr<< "AL_SOFT_UHJ not supported for UHJ decoding" <<std::endl;
+            else
+            {
+                std::cout<< "Found AL_SOFT_UHJ" <<std::endl;
+                EnableUhj = true;
+            }
+        }
+        else if(strcmp(argv[fileidx], "-superstereo") == 0)
+        {
+            if(!alIsExtensionPresent("AL_SOFT_UHJ"))
+                std::cerr<< "AL_SOFT_UHJ not supported for Super Stereo decoding" <<std::endl;
+            else
+            {
+                std::cout<< "Found AL_SOFT_UHJ (Super Stereo)" <<std::endl;
+                EnableSuperStereo = true;
+            }
+        }
         else if(strcmp(argv[fileidx], "-novideo") == 0)
             DisableVideo = true;
         else
@@ -1777,8 +2079,8 @@ int main(int argc, char *argv[])
     seconds last_time{seconds::min()};
     while(1)
     {
-        SDL_Event event{};
-        int have_evt{SDL_WaitEventTimeout(&event, 10)};
+        /* SDL_WaitEventTimeout is broken, just force a 10ms sleep. */
+        std::this_thread::sleep_for(milliseconds{10});
 
         auto cur_time = std::chrono::duration_cast<seconds>(movState->getMasterClock());
         if(cur_time != last_time)
@@ -1789,85 +2091,87 @@ int main(int argc, char *argv[])
         }
 
         bool force_redraw{false};
-        if(have_evt) do {
+        SDL_Event event{};
+        while(SDL_PollEvent(&event) != 0)
+        {
             switch(event.type)
             {
-                case SDL_KEYDOWN:
-                    switch(event.key.keysym.sym)
-                    {
-                        case SDLK_ESCAPE:
-                            movState->mQuit = true;
-                            eom_action = EomAction::Quit;
-                            break;
-
-                        case SDLK_n:
-                            movState->mQuit = true;
-                            eom_action = EomAction::Next;
-                            break;
-
-                        default:
-                            break;
-                    }
+            case SDL_KEYDOWN:
+                switch(event.key.keysym.sym)
+                {
+                case SDLK_ESCAPE:
+                    movState->stop();
+                    eom_action = EomAction::Quit;
                     break;
 
-                case SDL_WINDOWEVENT:
-                    switch(event.window.event)
-                    {
-                        case SDL_WINDOWEVENT_RESIZED:
-                            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-                            SDL_RenderFillRect(renderer, nullptr);
-                            force_redraw = true;
-                            break;
-
-                        case SDL_WINDOWEVENT_EXPOSED:
-                            force_redraw = true;
-                            break;
-
-                        default:
-                            break;
-                    }
+                case SDLK_n:
+                    movState->stop();
+                    eom_action = EomAction::Next;
                     break;
 
-                case SDL_QUIT:
-                    movState->mQuit = true;
-                    eom_action = EomAction::Quit;
+                default:
+                    break;
+                }
+                break;
+
+            case SDL_WINDOWEVENT:
+                switch(event.window.event)
+                {
+                case SDL_WINDOWEVENT_RESIZED:
+                    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+                    SDL_RenderFillRect(renderer, nullptr);
+                    force_redraw = true;
+                    break;
+
+                case SDL_WINDOWEVENT_EXPOSED:
+                    force_redraw = true;
+                    break;
+
+                default:
                     break;
+                }
+                break;
+
+            case SDL_QUIT:
+                movState->stop();
+                eom_action = EomAction::Quit;
+                break;
 
-                case FF_MOVIE_DONE_EVENT:
-                    std::cout<<'\n';
-                    last_time = seconds::min();
-                    if(eom_action != EomAction::Quit)
+            case FF_MOVIE_DONE_EVENT:
+                std::cout<<'\n';
+                last_time = seconds::min();
+                if(eom_action != EomAction::Quit)
+                {
+                    movState = nullptr;
+                    while(fileidx < argc && !movState)
+                    {
+                        movState = std::unique_ptr<MovieState>{new MovieState{argv[fileidx++]}};
+                        if(!movState->prepare()) movState = nullptr;
+                    }
+                    if(movState)
                     {
-                        movState = nullptr;
-                        while(fileidx < argc && !movState)
-                        {
-                            movState = std::unique_ptr<MovieState>{new MovieState{argv[fileidx++]}};
-                            if(!movState->prepare()) movState = nullptr;
-                        }
-                        if(movState)
-                        {
-                            movState->setTitle(screen);
-                            break;
-                        }
+                        movState->setTitle(screen);
+                        break;
                     }
+                }
 
-                    /* Nothing more to play. Shut everything down and quit. */
-                    movState = nullptr;
+                /* Nothing more to play. Shut everything down and quit. */
+                movState = nullptr;
 
-                    CloseAL();
+                CloseAL();
 
-                    SDL_DestroyRenderer(renderer);
-                    renderer = nullptr;
-                    SDL_DestroyWindow(screen);
-                    screen = nullptr;
+                SDL_DestroyRenderer(renderer);
+                renderer = nullptr;
+                SDL_DestroyWindow(screen);
+                screen = nullptr;
 
-                    SDL_Quit();
-                    exit(0);
+                SDL_Quit();
+                exit(0);
 
-                default:
-                    break;
+            default:
+                break;
             }
-        } while(SDL_PollEvent(&event));
+        }
 
         movState->mVideo.updateVideo(screen, renderer, force_redraw);
     }
diff --git a/examples/alhrtf.c b/examples/alhrtf.c
index 2be28a91..d878870e 100644
--- a/examples/alhrtf.c
+++ b/examples/alhrtf.c
@@ -25,13 +25,14 @@
 /* This file contains an example for selecting an HRTF. */
 
 #include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
 #include <math.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
 #include "AL/alc.h"
@@ -52,68 +53,73 @@ static LPALCRESETDEVICESOFT alcResetDeviceSOFT;
  */
 static ALuint LoadSound(const char *filename)
 {
-    Sound_Sample *sample;
     ALenum err, format;
     ALuint buffer;
-    Uint32 slen;
-
-    /* Open the audio file */
-    sample = Sound_NewSampleFromFile(filename, NULL, 65536);
-    if(!sample)
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    short *membuf;
+    sf_count_t num_frames;
+    ALsizei num_bytes;
+
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
+        return 0;
+    }
+    if(sfinfo.frames < 1 || sfinfo.frames > (sf_count_t)(INT_MAX/sizeof(short))/sfinfo.channels)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
         return 0;
     }
 
     /* Get the sound format, and figure out the OpenAL format */
-    if(sample->actual.channels == 1)
+    format = AL_NONE;
+    if(sfinfo.channels == 1)
+        format = AL_FORMAT_MONO16;
+    else if(sfinfo.channels == 2)
+        format = AL_FORMAT_STEREO16;
+    else if(sfinfo.channels == 3)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_MONO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_MONO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT2D_16;
     }
-    else if(sample->actual.channels == 2)
+    else if(sfinfo.channels == 4)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_STEREO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_STEREO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT3D_16;
     }
-    else
+    if(!format)
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Decode the whole audio stream to a buffer. */
-    slen = Sound_DecodeAll(sample);
-    if(!sample->buffer || slen == 0)
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames * sfinfo.channels) * sizeof(short));
+
+    num_frames = sf_readf_short(sndfile, membuf, sfinfo.frames);
+    if(num_frames < 1)
     {
-        fprintf(stderr, "Failed to read audio from %s\n", filename);
-        Sound_FreeSample(sample);
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
         return 0;
     }
+    num_bytes = (ALsizei)(num_frames * sfinfo.channels) * (ALsizei)sizeof(short);
 
     /* Buffer the audio data into a new buffer object, then free the data and
-     * close the file. */
+     * close the file.
+     */
     buffer = 0;
     alGenBuffers(1, &buffer);
-    alBufferData(buffer, format, sample->buffer, (ALsizei)slen, (ALsizei)sample->actual.rate);
-    Sound_FreeSample(sample);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
 
     /* Check if an error occured, and clean up if so. */
     err = alGetError();
@@ -164,7 +170,7 @@ int main(int argc, char **argv)
     }
 
     /* Define a macro to help load the function pointers. */
-#define LOAD_PROC(d, T, x)  ((x) = (T)alcGetProcAddress((d), #x))
+#define LOAD_PROC(d, T, x)  ((x) = FUNCTION_CAST(T, alcGetProcAddress((d), #x)))
     LOAD_PROC(device, LPALCGETSTRINGISOFT, alcGetStringiSOFT);
     LOAD_PROC(device, LPALCRESETDEVICESOFT, alcResetDeviceSOFT);
 #undef LOAD_PROC
@@ -240,14 +246,10 @@ int main(int argc, char **argv)
     }
     fflush(stdout);
 
-    /* Initialize SDL_sound. */
-    Sound_Init();
-
     /* Load the sound into a buffer. */
     buffer = LoadSound(soundname);
     if(!buffer)
     {
-        Sound_Quit();
         CloseAL();
         return 1;
     }
@@ -291,11 +293,9 @@ int main(int argc, char **argv)
         alGetSourcei(source, AL_SOURCE_STATE, &state);
     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
 
-    /* All done. Delete resources, and close down SDL_sound and OpenAL. */
+    /* All done. Delete resources, and close down OpenAL. */
     alDeleteSources(1, &source);
     alDeleteBuffers(1, &buffer);
-
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/allatency.c b/examples/allatency.c
index a61fb820..ab4a4ebc 100644
--- a/examples/allatency.c
+++ b/examples/allatency.c
@@ -24,12 +24,13 @@
 
 /* This file contains an example for checking the latency of a sound. */
 
-#include <stdio.h>
 #include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
 #include "AL/alext.h"
@@ -55,68 +56,73 @@ static LPALGETSOURCEI64VSOFT alGetSourcei64vSOFT;
  */
 static ALuint LoadSound(const char *filename)
 {
-    Sound_Sample *sample;
     ALenum err, format;
     ALuint buffer;
-    Uint32 slen;
-
-    /* Open the audio file */
-    sample = Sound_NewSampleFromFile(filename, NULL, 65536);
-    if(!sample)
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    short *membuf;
+    sf_count_t num_frames;
+    ALsizei num_bytes;
+
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
+        return 0;
+    }
+    if(sfinfo.frames < 1 || sfinfo.frames > (sf_count_t)(INT_MAX/sizeof(short))/sfinfo.channels)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
         return 0;
     }
 
     /* Get the sound format, and figure out the OpenAL format */
-    if(sample->actual.channels == 1)
+    format = AL_NONE;
+    if(sfinfo.channels == 1)
+        format = AL_FORMAT_MONO16;
+    else if(sfinfo.channels == 2)
+        format = AL_FORMAT_STEREO16;
+    else if(sfinfo.channels == 3)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_MONO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_MONO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT2D_16;
     }
-    else if(sample->actual.channels == 2)
+    else if(sfinfo.channels == 4)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_STEREO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_STEREO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT3D_16;
     }
-    else
+    if(!format)
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Decode the whole audio stream to a buffer. */
-    slen = Sound_DecodeAll(sample);
-    if(!sample->buffer || slen == 0)
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames * sfinfo.channels) * sizeof(short));
+
+    num_frames = sf_readf_short(sndfile, membuf, sfinfo.frames);
+    if(num_frames < 1)
     {
-        fprintf(stderr, "Failed to read audio from %s\n", filename);
-        Sound_FreeSample(sample);
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
         return 0;
     }
+    num_bytes = (ALsizei)(num_frames * sfinfo.channels) * (ALsizei)sizeof(short);
 
     /* Buffer the audio data into a new buffer object, then free the data and
-     * close the file. */
+     * close the file.
+     */
     buffer = 0;
     alGenBuffers(1, &buffer);
-    alBufferData(buffer, format, sample->buffer, (ALsizei)slen, (ALsizei)sample->actual.rate);
-    Sound_FreeSample(sample);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
 
     /* Check if an error occured, and clean up if so. */
     err = alGetError();
@@ -158,7 +164,7 @@ int main(int argc, char **argv)
     }
 
     /* Define a macro to help load the function pointers. */
-#define LOAD_PROC(T, x)  ((x) = (T)alGetProcAddress(#x))
+#define LOAD_PROC(T, x)  ((x) = FUNCTION_CAST(T, alGetProcAddress(#x)))
     LOAD_PROC(LPALSOURCEDSOFT, alSourcedSOFT);
     LOAD_PROC(LPALSOURCE3DSOFT, alSource3dSOFT);
     LOAD_PROC(LPALSOURCEDVSOFT, alSourcedvSOFT);
@@ -173,14 +179,10 @@ int main(int argc, char **argv)
     LOAD_PROC(LPALGETSOURCEI64VSOFT, alGetSourcei64vSOFT);
 #undef LOAD_PROC
 
-    /* Initialize SDL_sound. */
-    Sound_Init();
-
     /* Load the sound into a buffer. */
     buffer = LoadSound(argv[0]);
     if(!buffer)
     {
-        Sound_Quit();
         CloseAL();
         return 1;
     }
@@ -206,11 +208,9 @@ int main(int argc, char **argv)
     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
     printf("\n");
 
-    /* All done. Delete resources, and close down SDL_sound and OpenAL. */
+    /* All done. Delete resources, and close down OpenAL. */
     alDeleteSources(1, &source);
     alDeleteBuffers(1, &buffer);
-
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/alloopback.c b/examples/alloopback.c
index 844efa74..56cd420f 100644
--- a/examples/alloopback.c
+++ b/examples/alloopback.c
@@ -30,6 +30,7 @@
 #include <math.h>
 #include <stdio.h>
 
+#define SDL_MAIN_HANDLED
 #include "SDL.h"
 #include "SDL_audio.h"
 #include "SDL_error.h"
@@ -141,6 +142,8 @@ int main(int argc, char *argv[])
     (void)argc;
     (void)argv;
 
+    SDL_SetMainReady();
+
     /* Print out error if extension is missing. */
     if(!alcIsExtensionPresent(NULL, "ALC_SOFT_loopback"))
     {
@@ -149,7 +152,7 @@ int main(int argc, char *argv[])
     }
 
     /* Define a macro to help load the function pointers. */
-#define LOAD_PROC(T, x)  ((x) = (T)alcGetProcAddress(NULL, #x))
+#define LOAD_PROC(T, x)  ((x) = FUNCTION_CAST(T, alcGetProcAddress(NULL, #x)))
     LOAD_PROC(LPALCLOOPBACKOPENDEVICESOFT, alcLoopbackOpenDeviceSOFT);
     LOAD_PROC(LPALCISRENDERFORMATSUPPORTEDSOFT, alcIsRenderFormatSupportedSOFT);
     LOAD_PROC(LPALCRENDERSAMPLESSOFT, alcRenderSamplesSOFT);
@@ -197,6 +200,10 @@ int main(int argc, char *argv[])
         attrs[3] = ALC_UNSIGNED_SHORT_SOFT;
     else if(obtained.format == AUDIO_S16SYS)
         attrs[3] = ALC_SHORT_SOFT;
+    else if(obtained.format == AUDIO_S32SYS)
+        attrs[3] = ALC_INT_SOFT;
+    else if(obtained.format == AUDIO_F32SYS)
+        attrs[3] = ALC_FLOAT_SOFT;
     else
     {
         fprintf(stderr, "Unhandled SDL format: 0x%04x\n", obtained.format);
diff --git a/examples/almultireverb.c b/examples/almultireverb.c
index a90b3368..a77cc59e 100644
--- a/examples/almultireverb.c
+++ b/examples/almultireverb.c
@@ -29,14 +29,16 @@
  * listener.
  */
 
+
 #include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
 #include <math.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
 #include "AL/alc.h"
@@ -151,68 +153,62 @@ static int LoadEffect(ALuint effect, const EFXEAXREVERBPROPERTIES *reverb)
  */
 static ALuint LoadSound(const char *filename)
 {
-    Sound_Sample *sample;
     ALenum err, format;
     ALuint buffer;
-    Uint32 slen;
-
-    /* Open the audio file */
-    sample = Sound_NewSampleFromFile(filename, NULL, 65536);
-    if(!sample)
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    short *membuf;
+    sf_count_t num_frames;
+    ALsizei num_bytes;
+
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
         return 0;
     }
-
-    /* Get the sound format, and figure out the OpenAL format */
-    if(sample->actual.channels == 1)
-    {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_MONO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_MONO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
-    }
-    else if(sample->actual.channels == 2)
+    if(sfinfo.frames < 1 || sfinfo.frames > (sf_count_t)(INT_MAX/sizeof(short))/sfinfo.channels)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_STEREO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_STEREO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
+        return 0;
     }
+
+    /* Get the sound format, and figure out the OpenAL format */
+    if(sfinfo.channels == 1)
+        format = AL_FORMAT_MONO16;
+    else if(sfinfo.channels == 2)
+        format = AL_FORMAT_STEREO16;
     else
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Decode the whole audio stream to a buffer. */
-    slen = Sound_DecodeAll(sample);
-    if(!sample->buffer || slen == 0)
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames * sfinfo.channels) * sizeof(short));
+
+    num_frames = sf_readf_short(sndfile, membuf, sfinfo.frames);
+    if(num_frames < 1)
     {
-        fprintf(stderr, "Failed to read audio from %s\n", filename);
-        Sound_FreeSample(sample);
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
         return 0;
     }
+    num_bytes = (ALsizei)(num_frames * sfinfo.channels) * (ALsizei)sizeof(short);
 
     /* Buffer the audio data into a new buffer object, then free the data and
-     * close the file. */
+     * close the file.
+     */
     buffer = 0;
     alGenBuffers(1, &buffer);
-    alBufferData(buffer, format, sample->buffer, (ALsizei)slen, (ALsizei)sample->actual.rate);
-    Sound_FreeSample(sample);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
 
     /* Check if an error occured, and clean up if so. */
     err = alGetError();
@@ -523,7 +519,7 @@ int main(int argc, char **argv)
     }
 
     /* Define a macro to help load the function pointers. */
-#define LOAD_PROC(T, x)  ((x) = (T)alGetProcAddress(#x))
+#define LOAD_PROC(T, x)  ((x) = FUNCTION_CAST(T, alGetProcAddress(#x)))
     LOAD_PROC(LPALGENFILTERS, alGenFilters);
     LOAD_PROC(LPALDELETEFILTERS, alDeleteFilters);
     LOAD_PROC(LPALISFILTER, alIsFilter);
@@ -561,15 +557,11 @@ int main(int argc, char **argv)
     LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTFV, alGetAuxiliaryEffectSlotfv);
 #undef LOAD_PROC
 
-    /* Initialize SDL_sound. */
-    Sound_Init();
-
     /* Load the sound into a buffer. */
     buffer = LoadSound(argv[0]);
     if(!buffer)
     {
         CloseAL();
-        Sound_Quit();
         return 1;
     }
 
@@ -585,7 +577,6 @@ int main(int argc, char **argv)
     {
         alDeleteEffects(2, effects);
         alDeleteBuffers(1, &buffer);
-        Sound_Quit();
         CloseAL();
         return 1;
     }
@@ -684,14 +675,13 @@ int main(int argc, char **argv)
         alGetSourcei(source, AL_SOURCE_STATE, &state);
     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING && loops < MaxTransitions);
 
-    /* All done. Delete resources, and close down SDL_sound and OpenAL. */
+    /* All done. Delete resources, and close down OpenAL. */
     alDeleteSources(1, &source);
     alDeleteAuxiliaryEffectSlots(2, slots);
     alDeleteEffects(2, effects);
     alDeleteFilters(1, &direct_filter);
     alDeleteBuffers(1, &buffer);
 
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/alplay.c b/examples/alplay.c
index 09ad96b4..4291cb47 100644
--- a/examples/alplay.c
+++ b/examples/alplay.c
@@ -24,85 +24,247 @@
 
 /* This file contains an example for playing a sound buffer. */
 
-#include <stdio.h>
 #include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
+#include "AL/alext.h"
 
 #include "common/alhelpers.h"
 
 
+enum FormatType {
+    Int16,
+    Float,
+    IMA4,
+    MSADPCM
+};
+
 /* LoadBuffer loads the named audio file into an OpenAL buffer object, and
  * returns the new buffer ID.
  */
 static ALuint LoadSound(const char *filename)
 {
-    Sound_Sample *sample;
+    enum FormatType sample_format = Int16;
+    ALint byteblockalign = 0;
+    ALint splblockalign = 0;
+    sf_count_t num_frames;
     ALenum err, format;
+    ALsizei num_bytes;
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
     ALuint buffer;
-    Uint32 slen;
+    void *membuf;
 
-    /* Open the audio file */
-    sample = Sound_NewSampleFromFile(filename, NULL, 65536);
-    if(!sample)
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
+        return 0;
+    }
+    if(sfinfo.frames < 1)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Get the sound format, and figure out the OpenAL format */
-    if(sample->actual.channels == 1)
+    /* Detect a suitable format to load. Formats like Vorbis and Opus use float
+     * natively, so load as float to avoid clipping when possible. Formats
+     * larger than 16-bit can also use float to preserve a bit more precision.
+     */
+    switch((sfinfo.format&SF_FORMAT_SUBMASK))
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_MONO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_MONO16;
+    case SF_FORMAT_PCM_24:
+    case SF_FORMAT_PCM_32:
+    case SF_FORMAT_FLOAT:
+    case SF_FORMAT_DOUBLE:
+    case SF_FORMAT_VORBIS:
+    case SF_FORMAT_OPUS:
+    case SF_FORMAT_ALAC_20:
+    case SF_FORMAT_ALAC_24:
+    case SF_FORMAT_ALAC_32:
+    case 0x0080/*SF_FORMAT_MPEG_LAYER_I*/:
+    case 0x0081/*SF_FORMAT_MPEG_LAYER_II*/:
+    case 0x0082/*SF_FORMAT_MPEG_LAYER_III*/:
+        if(alIsExtensionPresent("AL_EXT_FLOAT32"))
+            sample_format = Float;
+        break;
+    case SF_FORMAT_IMA_ADPCM:
+        /* ADPCM formats require setting a block alignment as specified in the
+         * file, which needs to be read from the wave 'fmt ' chunk manually
+         * since libsndfile doesn't provide it in a format-agnostic way.
+         */
+        if(sfinfo.channels <= 2 && (sfinfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+            && alIsExtensionPresent("AL_EXT_IMA4")
+            && alIsExtensionPresent("AL_SOFT_block_alignment"))
+            sample_format = IMA4;
+        break;
+    case SF_FORMAT_MS_ADPCM:
+        if(sfinfo.channels <= 2 && (sfinfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+            && alIsExtensionPresent("AL_SOFT_MSADPCM")
+            && alIsExtensionPresent("AL_SOFT_block_alignment"))
+            sample_format = MSADPCM;
+        break;
+    }
+
+    if(sample_format == IMA4 || sample_format == MSADPCM)
+    {
+        /* For ADPCM, lookup the wave file's "fmt " chunk, which is a
+         * WAVEFORMATEX-based structure for the audio format.
+         */
+        SF_CHUNK_INFO inf = { "fmt ", 4, 0, NULL };
+        SF_CHUNK_ITERATOR *iter = sf_get_chunk_iterator(sndfile, &inf);
+
+        /* If there's an issue getting the chunk or block alignment, load as
+         * 16-bit and have libsndfile do the conversion.
+         */
+        if(!iter || sf_get_chunk_size(iter, &inf) != SF_ERR_NO_ERROR || inf.datalen < 14)
+            sample_format = Int16;
         else
         {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
+            ALubyte *fmtbuf = calloc(inf.datalen, 1);
+            inf.data = fmtbuf;
+            if(sf_get_chunk_data(iter, &inf) != SF_ERR_NO_ERROR)
+                sample_format = Int16;
+            else
+            {
+                /* Read the nBlockAlign field, and convert from bytes- to
+                 * samples-per-block (verifying it's valid by converting back
+                 * and comparing to the original value).
+                 */
+                byteblockalign = fmtbuf[12] | (fmtbuf[13]<<8);
+                if(sample_format == IMA4)
+                {
+                    splblockalign = (byteblockalign/sfinfo.channels - 4)/4*8 + 1;
+                    if(splblockalign < 1
+                        || ((splblockalign-1)/2 + 4)*sfinfo.channels != byteblockalign)
+                        sample_format = Int16;
+                }
+                else
+                {
+                    splblockalign = (byteblockalign/sfinfo.channels - 7)*2 + 2;
+                    if(splblockalign < 2
+                        || ((splblockalign-2)/2 + 7)*sfinfo.channels != byteblockalign)
+                        sample_format = Int16;
+                }
+            }
+            free(fmtbuf);
         }
     }
-    else if(sample->actual.channels == 2)
+
+    if(sample_format == Int16)
+    {
+        splblockalign = 1;
+        byteblockalign = sfinfo.channels * 2;
+    }
+    else if(sample_format == Float)
+    {
+        splblockalign = 1;
+        byteblockalign = sfinfo.channels * 4;
+    }
+
+    /* Figure out the OpenAL format from the file and desired sample type. */
+    format = AL_NONE;
+    if(sfinfo.channels == 1)
+    {
+        if(sample_format == Int16)
+            format = AL_FORMAT_MONO16;
+        else if(sample_format == Float)
+            format = AL_FORMAT_MONO_FLOAT32;
+        else if(sample_format == IMA4)
+            format = AL_FORMAT_MONO_IMA4;
+        else if(sample_format == MSADPCM)
+            format = AL_FORMAT_MONO_MSADPCM_SOFT;
+    }
+    else if(sfinfo.channels == 2)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_STEREO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
+        if(sample_format == Int16)
             format = AL_FORMAT_STEREO16;
-        else
+        else if(sample_format == Float)
+            format = AL_FORMAT_STEREO_FLOAT32;
+        else if(sample_format == IMA4)
+            format = AL_FORMAT_STEREO_IMA4;
+        else if(sample_format == MSADPCM)
+            format = AL_FORMAT_STEREO_MSADPCM_SOFT;
+    }
+    else if(sfinfo.channels == 3)
+    {
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
         {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
+            if(sample_format == Int16)
+                format = AL_FORMAT_BFORMAT2D_16;
+            else if(sample_format == Float)
+                format = AL_FORMAT_BFORMAT2D_FLOAT32;
         }
     }
-    else
+    else if(sfinfo.channels == 4)
+    {
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+        {
+            if(sample_format == Int16)
+                format = AL_FORMAT_BFORMAT3D_16;
+            else if(sample_format == Float)
+                format = AL_FORMAT_BFORMAT3D_FLOAT32;
+        }
+    }
+    if(!format)
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Decode the whole audio stream to a buffer. */
-    slen = Sound_DecodeAll(sample);
-    if(!sample->buffer || slen == 0)
+    if(sfinfo.frames/splblockalign > (sf_count_t)(INT_MAX/byteblockalign))
     {
-        fprintf(stderr, "Failed to read audio from %s\n", filename);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Too many samples in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
         return 0;
     }
 
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames / splblockalign * byteblockalign));
+
+    if(sample_format == Int16)
+        num_frames = sf_readf_short(sndfile, membuf, sfinfo.frames);
+    else if(sample_format == Float)
+        num_frames = sf_readf_float(sndfile, membuf, sfinfo.frames);
+    else
+    {
+        sf_count_t count = sfinfo.frames / splblockalign * byteblockalign;
+        num_frames = sf_read_raw(sndfile, membuf, count);
+        if(num_frames > 0)
+            num_frames = num_frames / byteblockalign * splblockalign;
+    }
+    if(num_frames < 1)
+    {
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
+        return 0;
+    }
+    num_bytes = (ALsizei)(num_frames / splblockalign * byteblockalign);
+
+    printf("Loading: %s (%s, %dhz)\n", filename, FormatName(format), sfinfo.samplerate);
+    fflush(stdout);
+
     /* Buffer the audio data into a new buffer object, then free the data and
-     * close the file. */
+     * close the file.
+     */
     buffer = 0;
     alGenBuffers(1, &buffer);
-    alBufferData(buffer, format, sample->buffer, (ALsizei)slen, (ALsizei)sample->actual.rate);
-    Sound_FreeSample(sample);
+    if(splblockalign > 1)
+        alBufferi(buffer, AL_UNPACK_BLOCK_ALIGNMENT_SOFT, splblockalign);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
 
     /* Check if an error occured, and clean up if so. */
     err = alGetError();
@@ -136,14 +298,10 @@ int main(int argc, char **argv)
     if(InitAL(&argv, &argc) != 0)
         return 1;
 
-    /* Initialize SDL_sound. */
-    Sound_Init();
-
     /* Load the sound into a buffer. */
     buffer = LoadSound(argv[0]);
     if(!buffer)
     {
-        Sound_Quit();
         CloseAL();
         return 1;
     }
@@ -167,11 +325,10 @@ int main(int argc, char **argv)
     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
     printf("\n");
 
-    /* All done. Delete resources, and close down SDL_sound and OpenAL. */
+    /* All done. Delete resources, and close down OpenAL. */
     alDeleteSources(1, &source);
     alDeleteBuffers(1, &buffer);
 
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/alrecord.c b/examples/alrecord.c
index a66e5471..03894493 100644
--- a/examples/alrecord.c
+++ b/examples/alrecord.c
@@ -35,6 +35,8 @@
 
 #include "common/alhelpers.h"
 
+#include "win_main_utf8.h"
+
 
 #if defined(_WIN64)
 #define SZFMT "%I64u"
@@ -54,14 +56,19 @@ static float msvc_strtof(const char *str, char **end)
 
 static void fwrite16le(ALushort val, FILE *f)
 {
-    ALubyte data[2] = { (ALubyte)(val&0xff), (ALubyte)((val>>8)&0xff) };
+    ALubyte data[2];
+    data[0] = (ALubyte)(val&0xff);
+    data[1] = (ALubyte)(val>>8);
     fwrite(data, 1, 2, f);
 }
 
 static void fwrite32le(ALuint val, FILE *f)
 {
-    ALubyte data[4] = { (ALubyte)(val&0xff), (ALubyte)((val>>8)&0xff), (ALubyte)((val>>16)&0xff),
-        (ALubyte)((val>>24)&0xff) };
+    ALubyte data[4];
+    data[0] = (ALubyte)(val&0xff);
+    data[1] = (ALubyte)((val>>8)&0xff);
+    data[2] = (ALubyte)((val>>16)&0xff);
+    data[3] = (ALubyte)(val>>24);
     fwrite(data, 1, 4, f);
 }
 
diff --git a/examples/alreverb.c b/examples/alreverb.c
index d789dffe..11a3ac6b 100644
--- a/examples/alreverb.c
+++ b/examples/alreverb.c
@@ -24,15 +24,17 @@
 
 /* This file contains an example for applying reverb to a sound. */
 
-#include <stdio.h>
 #include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
 #include "AL/alc.h"
+#include "AL/alext.h"
 #include "AL/efx.h"
 #include "AL/efx-presets.h"
 
@@ -149,68 +151,73 @@ static ALuint LoadEffect(const EFXEAXREVERBPROPERTIES *reverb)
  */
 static ALuint LoadSound(const char *filename)
 {
-    Sound_Sample *sample;
     ALenum err, format;
     ALuint buffer;
-    Uint32 slen;
-
-    /* Open the audio file */
-    sample = Sound_NewSampleFromFile(filename, NULL, 65536);
-    if(!sample)
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    short *membuf;
+    sf_count_t num_frames;
+    ALsizei num_bytes;
+
+    /* Open the audio file and check that it's usable. */
+    sndfile = sf_open(filename, SFM_READ, &sfinfo);
+    if(!sndfile)
+    {
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(sndfile));
+        return 0;
+    }
+    if(sfinfo.frames < 1 || sfinfo.frames > (sf_count_t)(INT_MAX/sizeof(short))/sfinfo.channels)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
+        fprintf(stderr, "Bad sample count in %s (%" PRId64 ")\n", filename, sfinfo.frames);
+        sf_close(sndfile);
         return 0;
     }
 
     /* Get the sound format, and figure out the OpenAL format */
-    if(sample->actual.channels == 1)
+    format = AL_NONE;
+    if(sfinfo.channels == 1)
+        format = AL_FORMAT_MONO16;
+    else if(sfinfo.channels == 2)
+        format = AL_FORMAT_STEREO16;
+    else if(sfinfo.channels == 3)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_MONO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_MONO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT2D_16;
     }
-    else if(sample->actual.channels == 2)
+    else if(sfinfo.channels == 4)
     {
-        if(sample->actual.format == AUDIO_U8)
-            format = AL_FORMAT_STEREO8;
-        else if(sample->actual.format == AUDIO_S16SYS)
-            format = AL_FORMAT_STEREO16;
-        else
-        {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
-            Sound_FreeSample(sample);
-            return 0;
-        }
+        if(sf_command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            format = AL_FORMAT_BFORMAT3D_16;
     }
-    else
+    if(!format)
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
-        Sound_FreeSample(sample);
+        fprintf(stderr, "Unsupported channel count: %d\n", sfinfo.channels);
+        sf_close(sndfile);
         return 0;
     }
 
-    /* Decode the whole audio stream to a buffer. */
-    slen = Sound_DecodeAll(sample);
-    if(!sample->buffer || slen == 0)
+    /* Decode the whole audio file to a buffer. */
+    membuf = malloc((size_t)(sfinfo.frames * sfinfo.channels) * sizeof(short));
+
+    num_frames = sf_readf_short(sndfile, membuf, sfinfo.frames);
+    if(num_frames < 1)
     {
-        fprintf(stderr, "Failed to read audio from %s\n", filename);
-        Sound_FreeSample(sample);
+        free(membuf);
+        sf_close(sndfile);
+        fprintf(stderr, "Failed to read samples in %s (%" PRId64 ")\n", filename, num_frames);
         return 0;
     }
+    num_bytes = (ALsizei)(num_frames * sfinfo.channels) * (ALsizei)sizeof(short);
 
     /* Buffer the audio data into a new buffer object, then free the data and
-     * close the file. */
+     * close the file.
+     */
     buffer = 0;
     alGenBuffers(1, &buffer);
-    alBufferData(buffer, format, sample->buffer, (ALsizei)slen, (ALsizei)sample->actual.rate);
-    Sound_FreeSample(sample);
+    alBufferData(buffer, format, membuf, num_bytes, sfinfo.samplerate);
+
+    free(membuf);
+    sf_close(sndfile);
 
     /* Check if an error occured, and clean up if so. */
     err = alGetError();
@@ -252,7 +259,7 @@ int main(int argc, char **argv)
     }
 
     /* Define a macro to help load the function pointers. */
-#define LOAD_PROC(T, x)  ((x) = (T)alGetProcAddress(#x))
+#define LOAD_PROC(T, x)  ((x) = FUNCTION_CAST(T, alGetProcAddress(#x)))
     LOAD_PROC(LPALGENEFFECTS, alGenEffects);
     LOAD_PROC(LPALDELETEEFFECTS, alDeleteEffects);
     LOAD_PROC(LPALISEFFECT, alIsEffect);
@@ -278,15 +285,11 @@ int main(int argc, char **argv)
     LOAD_PROC(LPALGETAUXILIARYEFFECTSLOTFV, alGetAuxiliaryEffectSlotfv);
 #undef LOAD_PROC
 
-    /* Initialize SDL_sound. */
-    Sound_Init();
-
     /* Load the sound into a buffer. */
     buffer = LoadSound(argv[0]);
     if(!buffer)
     {
         CloseAL();
-        Sound_Quit();
         return 1;
     }
 
@@ -295,7 +298,6 @@ int main(int argc, char **argv)
     if(!effect)
     {
         alDeleteBuffers(1, &buffer);
-        Sound_Quit();
         CloseAL();
         return 1;
     }
@@ -330,13 +332,12 @@ int main(int argc, char **argv)
         alGetSourcei(source, AL_SOURCE_STATE, &state);
     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
 
-    /* All done. Delete resources, and close down SDL_sound and OpenAL. */
+    /* All done. Delete resources, and close down OpenAL. */
     alDeleteSources(1, &source);
     alDeleteAuxiliaryEffectSlots(1, &slot);
     alDeleteEffects(1, &effect);
     alDeleteBuffers(1, &buffer);
 
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/alstream.c b/examples/alstream.c
index 56505ddb..a61680d2 100644
--- a/examples/alstream.c
+++ b/examples/alstream.c
@@ -24,44 +24,49 @@
 
 /* This file contains a relatively simple streaming audio player. */
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-#include "SDL_sound.h"
-#include "SDL_audio.h"
-#include "SDL_stdinc.h"
+#include "sndfile.h"
 
 #include "AL/al.h"
+#include "AL/alext.h"
 
 #include "common/alhelpers.h"
 
 
-#ifndef SDL_AUDIO_MASK_BITSIZE
-#define SDL_AUDIO_MASK_BITSIZE (0xFF)
-#endif
-#ifndef SDL_AUDIO_BITSIZE
-#define SDL_AUDIO_BITSIZE(x) (x & SDL_AUDIO_MASK_BITSIZE)
-#endif
-
 /* Define the number of buffers and buffer size (in milliseconds) to use. 4
- * buffers with 200ms each gives a nice per-chunk size, and lets the queue last
- * for almost one second. */
+ * buffers at 200ms each gives a nice per-chunk size, and lets the queue last
+ * for almost one second.
+ */
 #define NUM_BUFFERS 4
-#define BUFFER_TIME_MS 200
+#define BUFFER_MILLISEC 200
+
+typedef enum SampleType {
+    Int16, Float, IMA4, MSADPCM
+} SampleType;
 
 typedef struct StreamPlayer {
-    /* These are the buffers and source to play out through OpenAL with */
+    /* These are the buffers and source to play out through OpenAL with. */
     ALuint buffers[NUM_BUFFERS];
     ALuint source;
 
     /* Handle for the audio file */
-    Sound_Sample *sample;
+    SNDFILE *sndfile;
+    SF_INFO sfinfo;
+    void *membuf;
 
-    /* The format of the output stream */
+    /* The sample type and block/frame size being read for the buffer. */
+    SampleType sample_type;
+    int byteblockalign;
+    int sampleblockalign;
+    int block_count;
+
+    /* The format of the output stream (sample rate is in sfinfo) */
     ALenum format;
-    ALsizei srate;
 } StreamPlayer;
 
 static StreamPlayer *NewPlayer(void);
@@ -73,7 +78,8 @@ static int UpdatePlayer(StreamPlayer *player);
 
 /* Creates a new player object, and allocates the needed OpenAL source and
  * buffer objects. Error checking is simplified for the purposes of this
- * example, and will cause an abort if needed. */
+ * example, and will cause an abort if needed.
+ */
 static StreamPlayer *NewPlayer(void)
 {
     StreamPlayer *player;
@@ -118,73 +124,197 @@ static void DeletePlayer(StreamPlayer *player)
  * it will be closed first. */
 static int OpenPlayerFile(StreamPlayer *player, const char *filename)
 {
-    Uint32 frame_size;
+    int byteblockalign=0, splblockalign=0;
 
     ClosePlayerFile(player);
 
-    /* Open the file and get the first stream from it */
-    player->sample = Sound_NewSampleFromFile(filename, NULL, 0);
-    if(!player->sample)
+    /* Open the audio file and check that it's usable. */
+    player->sndfile = sf_open(filename, SFM_READ, &player->sfinfo);
+    if(!player->sndfile)
     {
-        fprintf(stderr, "Could not open audio in %s\n", filename);
-        goto error;
+        fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(NULL));
+        return 0;
     }
 
-    /* Get the stream format, and figure out the OpenAL format */
-    if(player->sample->actual.channels == 1)
+    /* Detect a suitable format to load. Formats like Vorbis and Opus use float
+     * natively, so load as float to avoid clipping when possible. Formats
+     * larger than 16-bit can also use float to preserve a bit more precision.
+     */
+    switch((player->sfinfo.format&SF_FORMAT_SUBMASK))
     {
-        if(player->sample->actual.format == AUDIO_U8)
-            player->format = AL_FORMAT_MONO8;
-        else if(player->sample->actual.format == AUDIO_S16SYS)
-            player->format = AL_FORMAT_MONO16;
+    case SF_FORMAT_PCM_24:
+    case SF_FORMAT_PCM_32:
+    case SF_FORMAT_FLOAT:
+    case SF_FORMAT_DOUBLE:
+    case SF_FORMAT_VORBIS:
+    case SF_FORMAT_OPUS:
+    case SF_FORMAT_ALAC_20:
+    case SF_FORMAT_ALAC_24:
+    case SF_FORMAT_ALAC_32:
+    case 0x0080/*SF_FORMAT_MPEG_LAYER_I*/:
+    case 0x0081/*SF_FORMAT_MPEG_LAYER_II*/:
+    case 0x0082/*SF_FORMAT_MPEG_LAYER_III*/:
+        if(alIsExtensionPresent("AL_EXT_FLOAT32"))
+            player->sample_type = Float;
+        break;
+    case SF_FORMAT_IMA_ADPCM:
+        /* ADPCM formats require setting a block alignment as specified in the
+         * file, which needs to be read from the wave 'fmt ' chunk manually
+         * since libsndfile doesn't provide it in a format-agnostic way.
+         */
+        if(player->sfinfo.channels <= 2
+            && (player->sfinfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+            && alIsExtensionPresent("AL_EXT_IMA4")
+            && alIsExtensionPresent("AL_SOFT_block_alignment"))
+            player->sample_type = IMA4;
+        break;
+    case SF_FORMAT_MS_ADPCM:
+        if(player->sfinfo.channels <= 2
+            && (player->sfinfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+            && alIsExtensionPresent("AL_SOFT_MSADPCM")
+            && alIsExtensionPresent("AL_SOFT_block_alignment"))
+            player->sample_type = MSADPCM;
+        break;
+    }
+
+    if(player->sample_type == IMA4 || player->sample_type == MSADPCM)
+    {
+        /* For ADPCM, lookup the wave file's "fmt " chunk, which is a
+         * WAVEFORMATEX-based structure for the audio format.
+         */
+        SF_CHUNK_INFO inf = { "fmt ", 4, 0, NULL };
+        SF_CHUNK_ITERATOR *iter = sf_get_chunk_iterator(player->sndfile, &inf);
+
+        /* If there's an issue getting the chunk or block alignment, load as
+         * 16-bit and have libsndfile do the conversion.
+         */
+        if(!iter || sf_get_chunk_size(iter, &inf) != SF_ERR_NO_ERROR || inf.datalen < 14)
+            player->sample_type = Int16;
         else
         {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", player->sample->actual.format);
-            goto error;
+            ALubyte *fmtbuf = calloc(inf.datalen, 1);
+            inf.data = fmtbuf;
+            if(sf_get_chunk_data(iter, &inf) != SF_ERR_NO_ERROR)
+                player->sample_type = Int16;
+            else
+            {
+                /* Read the nBlockAlign field, and convert from bytes- to
+                 * samples-per-block (verifying it's valid by converting back
+                 * and comparing to the original value).
+                 */
+                byteblockalign = fmtbuf[12] | (fmtbuf[13]<<8);
+                if(player->sample_type == IMA4)
+                {
+                    splblockalign = (byteblockalign/player->sfinfo.channels - 4)/4*8 + 1;
+                    if(splblockalign < 1
+                        || ((splblockalign-1)/2 + 4)*player->sfinfo.channels != byteblockalign)
+                        player->sample_type = Int16;
+                }
+                else
+                {
+                    splblockalign = (byteblockalign/player->sfinfo.channels - 7)*2 + 2;
+                    if(splblockalign < 2
+                        || ((splblockalign-2)/2 + 7)*player->sfinfo.channels != byteblockalign)
+                        player->sample_type = Int16;
+                }
+            }
+            free(fmtbuf);
         }
     }
-    else if(player->sample->actual.channels == 2)
+
+    if(player->sample_type == Int16)
     {
-        if(player->sample->actual.format == AUDIO_U8)
-            player->format = AL_FORMAT_STEREO8;
-        else if(player->sample->actual.format == AUDIO_S16SYS)
+        player->sampleblockalign = 1;
+        player->byteblockalign = player->sfinfo.channels * 2;
+    }
+    else if(player->sample_type == Float)
+    {
+        player->sampleblockalign = 1;
+        player->byteblockalign = player->sfinfo.channels * 4;
+    }
+    else
+    {
+        player->sampleblockalign = splblockalign;
+        player->byteblockalign = byteblockalign;
+    }
+
+    /* Figure out the OpenAL format from the file and desired sample type. */
+    player->format = AL_NONE;
+    if(player->sfinfo.channels == 1)
+    {
+        if(player->sample_type == Int16)
+            player->format = AL_FORMAT_MONO16;
+        else if(player->sample_type == Float)
+            player->format = AL_FORMAT_MONO_FLOAT32;
+        else if(player->sample_type == IMA4)
+            player->format = AL_FORMAT_MONO_IMA4;
+        else if(player->sample_type == MSADPCM)
+            player->format = AL_FORMAT_MONO_MSADPCM_SOFT;
+    }
+    else if(player->sfinfo.channels == 2)
+    {
+        if(player->sample_type == Int16)
             player->format = AL_FORMAT_STEREO16;
-        else
+        else if(player->sample_type == Float)
+            player->format = AL_FORMAT_STEREO_FLOAT32;
+        else if(player->sample_type == IMA4)
+            player->format = AL_FORMAT_STEREO_IMA4;
+        else if(player->sample_type == MSADPCM)
+            player->format = AL_FORMAT_STEREO_MSADPCM_SOFT;
+    }
+    else if(player->sfinfo.channels == 3)
+    {
+        if(sf_command(player->sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
         {
-            fprintf(stderr, "Unsupported sample format: 0x%04x\n", player->sample->actual.format);
-            goto error;
+            if(player->sample_type == Int16)
+                player->format = AL_FORMAT_BFORMAT2D_16;
+            else if(player->sample_type == Float)
+                player->format = AL_FORMAT_BFORMAT2D_FLOAT32;
         }
     }
-    else
+    else if(player->sfinfo.channels == 4)
     {
-        fprintf(stderr, "Unsupported channel count: %d\n", player->sample->actual.channels);
-        goto error;
+        if(sf_command(player->sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+        {
+            if(player->sample_type == Int16)
+                player->format = AL_FORMAT_BFORMAT3D_16;
+            else if(player->sample_type == Float)
+                player->format = AL_FORMAT_BFORMAT3D_FLOAT32;
+        }
+    }
+    if(!player->format)
+    {
+        fprintf(stderr, "Unsupported channel count: %d\n", player->sfinfo.channels);
+        sf_close(player->sndfile);
+        player->sndfile = NULL;
+        return 0;
     }
-    player->srate = (ALsizei)player->sample->actual.rate;
-
-    frame_size = player->sample->actual.channels *
-        SDL_AUDIO_BITSIZE(player->sample->actual.format) / 8;
 
-    /* Set the buffer size, given the desired millisecond length. */
-    Sound_SetBufferSize(player->sample, (Uint32)((Uint64)player->srate*BUFFER_TIME_MS/1000) *
-                                        frame_size);
+    player->block_count = player->sfinfo.samplerate / player->sampleblockalign;
+    player->block_count = player->block_count * BUFFER_MILLISEC / 1000;
+    player->membuf = malloc((size_t)(player->block_count * player->byteblockalign));
 
     return 1;
-
-error:
-    if(player->sample)
-        Sound_FreeSample(player->sample);
-    player->sample = NULL;
-
-    return 0;
 }
 
 /* Closes the audio file stream */
 static void ClosePlayerFile(StreamPlayer *player)
 {
-    if(player->sample)
-        Sound_FreeSample(player->sample);
-    player->sample = NULL;
+    if(player->sndfile)
+        sf_close(player->sndfile);
+    player->sndfile = NULL;
+
+    free(player->membuf);
+    player->membuf = NULL;
+
+    if(player->sampleblockalign > 1)
+    {
+        ALsizei i;
+        for(i = 0;i < NUM_BUFFERS;i++)
+            alBufferi(player->buffers[i], AL_UNPACK_BLOCK_ALIGNMENT_SOFT, 0);
+        player->sampleblockalign = 0;
+        player->byteblockalign = 0;
+    }
 }
 
 
@@ -200,12 +330,37 @@ static int StartPlayer(StreamPlayer *player)
     /* Fill the buffer queue */
     for(i = 0;i < NUM_BUFFERS;i++)
     {
+        sf_count_t slen;
+
         /* Get some data to give it to the buffer */
-        Uint32 slen = Sound_Decode(player->sample);
-        if(slen == 0) break;
+        if(player->sample_type == Int16)
+        {
+            slen = sf_readf_short(player->sndfile, player->membuf,
+                player->block_count * player->sampleblockalign);
+            if(slen < 1) break;
+            slen *= player->byteblockalign;
+        }
+        else if(player->sample_type == Float)
+        {
+            slen = sf_readf_float(player->sndfile, player->membuf,
+                player->block_count * player->sampleblockalign);
+            if(slen < 1) break;
+            slen *= player->byteblockalign;
+        }
+        else
+        {
+            slen = sf_read_raw(player->sndfile, player->membuf,
+                player->block_count * player->byteblockalign);
+            if(slen > 0) slen -= slen%player->byteblockalign;
+            if(slen < 1) break;
+        }
 
-        alBufferData(player->buffers[i], player->format, player->sample->buffer, (ALsizei)slen,
-            player->srate);
+        if(player->sampleblockalign > 1)
+            alBufferi(player->buffers[i], AL_UNPACK_BLOCK_ALIGNMENT_SOFT,
+                player->sampleblockalign);
+
+        alBufferData(player->buffers[i], player->format, player->membuf, (ALsizei)slen,
+            player->sfinfo.samplerate);
     }
     if(alGetError() != AL_NO_ERROR)
     {
@@ -242,21 +397,36 @@ static int UpdatePlayer(StreamPlayer *player)
     while(processed > 0)
     {
         ALuint bufid;
-        Uint32 slen;
+        sf_count_t slen;
 
         alSourceUnqueueBuffers(player->source, 1, &bufid);
         processed--;
 
-        if((player->sample->flags&(SOUND_SAMPLEFLAG_EOF|SOUND_SAMPLEFLAG_ERROR)))
-            continue;
-
         /* Read the next chunk of data, refill the buffer, and queue it
          * back on the source */
-        slen = Sound_Decode(player->sample);
+        if(player->sample_type == Int16)
+        {
+            slen = sf_readf_short(player->sndfile, player->membuf,
+                player->block_count * player->sampleblockalign);
+            if(slen > 0) slen *= player->byteblockalign;
+        }
+        else if(player->sample_type == Float)
+        {
+            slen = sf_readf_float(player->sndfile, player->membuf,
+                player->block_count * player->sampleblockalign);
+            if(slen > 0) slen *= player->byteblockalign;
+        }
+        else
+        {
+            slen = sf_read_raw(player->sndfile, player->membuf,
+                player->block_count * player->byteblockalign);
+            if(slen > 0) slen -= slen%player->byteblockalign;
+        }
+
         if(slen > 0)
         {
-            alBufferData(bufid, player->format, player->sample->buffer, (ALsizei)slen,
-                player->srate);
+            alBufferData(bufid, player->format, player->membuf, (ALsizei)slen,
+                player->sfinfo.samplerate);
             alSourceQueueBuffers(player->source, 1, &bufid);
         }
         if(alGetError() != AL_NO_ERROR)
@@ -304,8 +474,6 @@ int main(int argc, char **argv)
     if(InitAL(&argv, &argc) != 0)
         return 1;
 
-    Sound_Init();
-
     player = NewPlayer();
 
     /* Play each file listed on the command line */
@@ -323,7 +491,8 @@ int main(int argc, char **argv)
         else
             namepart = argv[i];
 
-        printf("Playing: %s (%s, %dhz)\n", namepart, FormatName(player->format), player->srate);
+        printf("Playing: %s (%s, %dhz)\n", namepart, FormatName(player->format),
+            player->sfinfo.samplerate);
         fflush(stdout);
 
         if(!StartPlayer(player))
@@ -340,11 +509,10 @@ int main(int argc, char **argv)
     }
     printf("Done.\n");
 
-    /* All files done. Delete the player, and close down SDL_sound and OpenAL */
+    /* All files done. Delete the player, and close down OpenAL */
     DeletePlayer(player);
     player = NULL;
 
-    Sound_Quit();
     CloseAL();
 
     return 0;
diff --git a/examples/alstreamcb.cpp b/examples/alstreamcb.cpp
new file mode 100644
index 00000000..a2e7b659
--- /dev/null
+++ b/examples/alstreamcb.cpp
@@ -0,0 +1,551 @@
+/*
+ * OpenAL Callback-based Stream Example
+ *
+ * Copyright (c) 2020 by Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* This file contains a streaming audio player using a callback buffer. */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "sndfile.h"
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "common/alhelpers.h"
+
+
+namespace {
+
+using std::chrono::seconds;
+using std::chrono::nanoseconds;
+
+LPALBUFFERCALLBACKSOFT alBufferCallbackSOFT;
+
+struct StreamPlayer {
+    /* A lockless ring-buffer (supports single-provider, single-consumer
+     * operation).
+     */
+    std::unique_ptr<ALbyte[]> mBufferData;
+    size_t mBufferDataSize{0};
+    std::atomic<size_t> mReadPos{0};
+    std::atomic<size_t> mWritePos{0};
+    size_t mSamplesPerBlock{1};
+    size_t mBytesPerBlock{1};
+
+    enum class SampleType {
+        Int16, Float, IMA4, MSADPCM
+    };
+    SampleType mSampleFormat{SampleType::Int16};
+
+    /* The buffer to get the callback, and source to play with. */
+    ALuint mBuffer{0}, mSource{0};
+    size_t mStartOffset{0};
+
+    /* Handle for the audio file to decode. */
+    SNDFILE *mSndfile{nullptr};
+    SF_INFO mSfInfo{};
+    size_t mDecoderOffset{0};
+
+    /* The format of the callback samples. */
+    ALenum mFormat;
+
+    StreamPlayer()
+    {
+        alGenBuffers(1, &mBuffer);
+        if(alGetError() != AL_NO_ERROR)
+            throw std::runtime_error{"alGenBuffers failed"};
+        alGenSources(1, &mSource);
+        if(alGetError() != AL_NO_ERROR)
+        {
+            alDeleteBuffers(1, &mBuffer);
+            throw std::runtime_error{"alGenSources failed"};
+        }
+    }
+    ~StreamPlayer()
+    {
+        alDeleteSources(1, &mSource);
+        alDeleteBuffers(1, &mBuffer);
+        if(mSndfile)
+            sf_close(mSndfile);
+    }
+
+    void close()
+    {
+        if(mSamplesPerBlock > 1)
+            alBufferi(mBuffer, AL_UNPACK_BLOCK_ALIGNMENT_SOFT, 0);
+
+        if(mSndfile)
+        {
+            alSourceRewind(mSource);
+            alSourcei(mSource, AL_BUFFER, 0);
+            sf_close(mSndfile);
+            mSndfile = nullptr;
+        }
+    }
+
+    bool open(const char *filename)
+    {
+        close();
+
+        /* Open the file and figure out the OpenAL format. */
+        mSndfile = sf_open(filename, SFM_READ, &mSfInfo);
+        if(!mSndfile)
+        {
+            fprintf(stderr, "Could not open audio in %s: %s\n", filename, sf_strerror(mSndfile));
+            return false;
+        }
+
+        switch((mSfInfo.format&SF_FORMAT_SUBMASK))
+        {
+        case SF_FORMAT_PCM_24:
+        case SF_FORMAT_PCM_32:
+        case SF_FORMAT_FLOAT:
+        case SF_FORMAT_DOUBLE:
+        case SF_FORMAT_VORBIS:
+        case SF_FORMAT_OPUS:
+        case SF_FORMAT_ALAC_20:
+        case SF_FORMAT_ALAC_24:
+        case SF_FORMAT_ALAC_32:
+        case 0x0080/*SF_FORMAT_MPEG_LAYER_I*/:
+        case 0x0081/*SF_FORMAT_MPEG_LAYER_II*/:
+        case 0x0082/*SF_FORMAT_MPEG_LAYER_III*/:
+            if(alIsExtensionPresent("AL_EXT_FLOAT32"))
+                mSampleFormat = SampleType::Float;
+            break;
+        case SF_FORMAT_IMA_ADPCM:
+            if(mSfInfo.channels <= 2 && (mSfInfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+                && alIsExtensionPresent("AL_EXT_IMA4")
+                && alIsExtensionPresent("AL_SOFT_block_alignment"))
+                mSampleFormat = SampleType::IMA4;
+            break;
+        case SF_FORMAT_MS_ADPCM:
+            if(mSfInfo.channels <= 2 && (mSfInfo.format&SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV
+                && alIsExtensionPresent("AL_SOFT_MSADPCM")
+                && alIsExtensionPresent("AL_SOFT_block_alignment"))
+                mSampleFormat = SampleType::MSADPCM;
+            break;
+        }
+
+        int splblocksize{}, byteblocksize{};
+        if(mSampleFormat == SampleType::IMA4 || mSampleFormat == SampleType::MSADPCM)
+        {
+            SF_CHUNK_INFO inf{ "fmt ", 4, 0, nullptr };
+            SF_CHUNK_ITERATOR *iter = sf_get_chunk_iterator(mSndfile, &inf);
+            if(!iter || sf_get_chunk_size(iter, &inf) != SF_ERR_NO_ERROR || inf.datalen < 14)
+                mSampleFormat = SampleType::Int16;
+            else
+            {
+                auto fmtbuf = std::make_unique<ALubyte[]>(inf.datalen);
+                inf.data = fmtbuf.get();
+                if(sf_get_chunk_data(iter, &inf) != SF_ERR_NO_ERROR)
+                    mSampleFormat = SampleType::Int16;
+                else
+                {
+                    byteblocksize = fmtbuf[12] | (fmtbuf[13]<<8u);
+                    if(mSampleFormat == SampleType::IMA4)
+                    {
+                        splblocksize = (byteblocksize/mSfInfo.channels - 4)/4*8 + 1;
+                        if(splblocksize < 1
+                            || ((splblocksize-1)/2 + 4)*mSfInfo.channels != byteblocksize)
+                            mSampleFormat = SampleType::Int16;
+                    }
+                    else
+                    {
+                        splblocksize = (byteblocksize/mSfInfo.channels - 7)*2 + 2;
+                        if(splblocksize < 2
+                            || ((splblocksize-2)/2 + 7)*mSfInfo.channels != byteblocksize)
+                            mSampleFormat = SampleType::Int16;
+                    }
+                }
+            }
+        }
+
+        if(mSampleFormat == SampleType::Int16)
+        {
+            mSamplesPerBlock = 1;
+            mBytesPerBlock = static_cast<size_t>(mSfInfo.channels * 2);
+        }
+        else if(mSampleFormat == SampleType::Float)
+        {
+            mSamplesPerBlock = 1;
+            mBytesPerBlock = static_cast<size_t>(mSfInfo.channels * 4);
+        }
+        else
+        {
+            mSamplesPerBlock = static_cast<size_t>(splblocksize);
+            mBytesPerBlock = static_cast<size_t>(byteblocksize);
+        }
+
+        mFormat = AL_NONE;
+        if(mSfInfo.channels == 1)
+        {
+            if(mSampleFormat == SampleType::Int16)
+                mFormat = AL_FORMAT_MONO16;
+            else if(mSampleFormat == SampleType::Float)
+                mFormat = AL_FORMAT_MONO_FLOAT32;
+            else if(mSampleFormat == SampleType::IMA4)
+                mFormat = AL_FORMAT_MONO_IMA4;
+            else if(mSampleFormat == SampleType::MSADPCM)
+                mFormat = AL_FORMAT_MONO_MSADPCM_SOFT;
+        }
+        else if(mSfInfo.channels == 2)
+        {
+            if(mSampleFormat == SampleType::Int16)
+                mFormat = AL_FORMAT_STEREO16;
+            else if(mSampleFormat == SampleType::Float)
+                mFormat = AL_FORMAT_STEREO_FLOAT32;
+            else if(mSampleFormat == SampleType::IMA4)
+                mFormat = AL_FORMAT_STEREO_IMA4;
+            else if(mSampleFormat == SampleType::MSADPCM)
+                mFormat = AL_FORMAT_STEREO_MSADPCM_SOFT;
+        }
+        else if(mSfInfo.channels == 3)
+        {
+            if(sf_command(mSndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            {
+                if(mSampleFormat == SampleType::Int16)
+                    mFormat = AL_FORMAT_BFORMAT2D_16;
+                else if(mSampleFormat == SampleType::Float)
+                    mFormat = AL_FORMAT_BFORMAT2D_FLOAT32;
+            }
+        }
+        else if(mSfInfo.channels == 4)
+        {
+            if(sf_command(mSndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+            {
+                if(mSampleFormat == SampleType::Int16)
+                    mFormat = AL_FORMAT_BFORMAT3D_16;
+                else if(mSampleFormat == SampleType::Float)
+                    mFormat = AL_FORMAT_BFORMAT3D_FLOAT32;
+            }
+        }
+        if(!mFormat)
+        {
+            fprintf(stderr, "Unsupported channel count: %d\n", mSfInfo.channels);
+            sf_close(mSndfile);
+            mSndfile = nullptr;
+
+            return false;
+        }
+
+        /* Set a 1s ring buffer size. */
+        size_t numblocks{(static_cast<ALuint>(mSfInfo.samplerate) + mSamplesPerBlock-1)
+            / mSamplesPerBlock};
+        mBufferDataSize = static_cast<ALuint>(numblocks * mBytesPerBlock);
+        mBufferData.reset(new ALbyte[mBufferDataSize]);
+        mReadPos.store(0, std::memory_order_relaxed);
+        mWritePos.store(0, std::memory_order_relaxed);
+        mDecoderOffset = 0;
+
+        return true;
+    }
+
+    /* The actual C-style callback just forwards to the non-static method. Not
+     * strictly needed and the compiler will optimize it to a normal function,
+     * but it allows the callback implementation to have a nice 'this' pointer
+     * with normal member access.
+     */
+    static ALsizei AL_APIENTRY bufferCallbackC(void *userptr, void *data, ALsizei size)
+    { return static_cast<StreamPlayer*>(userptr)->bufferCallback(data, size); }
+    ALsizei bufferCallback(void *data, ALsizei size)
+    {
+        /* NOTE: The callback *MUST* be real-time safe! That means no blocking,
+         * no allocations or deallocations, no I/O, no page faults, or calls to
+         * functions that could do these things (this includes calling to
+         * libraries like SDL_sound, libsndfile, ffmpeg, etc). Nothing should
+         * unexpectedly stall this call since the audio has to get to the
+         * device on time.
+         */
+        ALsizei got{0};
+
+        size_t roffset{mReadPos.load(std::memory_order_acquire)};
+        while(got < size)
+        {
+            /* If the write offset == read offset, there's nothing left in the
+             * ring-buffer. Break from the loop and give what has been written.
+             */
+            const size_t woffset{mWritePos.load(std::memory_order_relaxed)};
+            if(woffset == roffset) break;
+
+            /* If the write offset is behind the read offset, the readable
+             * portion wrapped around. Just read up to the end of the buffer in
+             * that case, otherwise read up to the write offset. Also limit the
+             * amount to copy given how much is remaining to write.
+             */
+            size_t todo{((woffset < roffset) ? mBufferDataSize : woffset) - roffset};
+            todo = std::min<size_t>(todo, static_cast<ALuint>(size-got));
+
+            /* Copy from the ring buffer to the provided output buffer. Wrap
+             * the resulting read offset if it reached the end of the ring-
+             * buffer.
+             */
+            memcpy(data, &mBufferData[roffset], todo);
+            data = static_cast<ALbyte*>(data) + todo;
+            got += static_cast<ALsizei>(todo);
+
+            roffset += todo;
+            if(roffset == mBufferDataSize)
+                roffset = 0;
+        }
+        /* Finally, store the updated read offset, and return how many bytes
+         * have been written.
+         */
+        mReadPos.store(roffset, std::memory_order_release);
+
+        return got;
+    }
+
+    bool prepare()
+    {
+        if(mSamplesPerBlock > 1)
+            alBufferi(mBuffer, AL_UNPACK_BLOCK_ALIGNMENT_SOFT, static_cast<int>(mSamplesPerBlock));
+        alBufferCallbackSOFT(mBuffer, mFormat, mSfInfo.samplerate, bufferCallbackC, this);
+        alSourcei(mSource, AL_BUFFER, static_cast<ALint>(mBuffer));
+        if(ALenum err{alGetError()})
+        {
+            fprintf(stderr, "Failed to set callback: %s (0x%04x)\n", alGetString(err), err);
+            return false;
+        }
+        return true;
+    }
+
+    bool update()
+    {
+        ALenum state;
+        ALint pos;
+        alGetSourcei(mSource, AL_SAMPLE_OFFSET, &pos);
+        alGetSourcei(mSource, AL_SOURCE_STATE, &state);
+
+        size_t woffset{mWritePos.load(std::memory_order_acquire)};
+        if(state != AL_INITIAL)
+        {
+            const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+            const size_t readable{((woffset >= roffset) ? woffset : (mBufferDataSize+woffset)) -
+                roffset};
+            /* For a stopped (underrun) source, the current playback offset is
+             * the current decoder offset excluding the readable buffered data.
+             * For a playing/paused source, it's the source's offset including
+             * the playback offset the source was started with.
+             */
+            const size_t curtime{((state == AL_STOPPED)
+                ? (mDecoderOffset-readable) / mBytesPerBlock * mSamplesPerBlock
+                : (static_cast<ALuint>(pos) + mStartOffset/mBytesPerBlock*mSamplesPerBlock))
+                / static_cast<ALuint>(mSfInfo.samplerate)};
+            printf("\r%3zus (%3zu%% full)", curtime, readable * 100 / mBufferDataSize);
+        }
+        else
+            fputs("Starting...", stdout);
+        fflush(stdout);
+
+        while(!sf_error(mSndfile))
+        {
+            size_t read_bytes;
+            const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+            if(roffset > woffset)
+            {
+                /* Note that the ring buffer's writable space is one byte less
+                 * than the available area because the write offset ending up
+                 * at the read offset would be interpreted as being empty
+                 * instead of full.
+                 */
+                const size_t writable{(roffset-woffset-1) / mBytesPerBlock};
+                if(!writable) break;
+
+                if(mSampleFormat == SampleType::Int16)
+                {
+                    sf_count_t num_frames{sf_readf_short(mSndfile,
+                        reinterpret_cast<short*>(&mBufferData[woffset]),
+                        static_cast<sf_count_t>(writable*mSamplesPerBlock))};
+                    if(num_frames < 1) break;
+                    read_bytes = static_cast<size_t>(num_frames) * mBytesPerBlock;
+                }
+                else if(mSampleFormat == SampleType::Float)
+                {
+                    sf_count_t num_frames{sf_readf_float(mSndfile,
+                        reinterpret_cast<float*>(&mBufferData[woffset]),
+                        static_cast<sf_count_t>(writable*mSamplesPerBlock))};
+                    if(num_frames < 1) break;
+                    read_bytes = static_cast<size_t>(num_frames) * mBytesPerBlock;
+                }
+                else
+                {
+                    sf_count_t numbytes{sf_read_raw(mSndfile, &mBufferData[woffset],
+                        static_cast<sf_count_t>(writable*mBytesPerBlock))};
+                    if(numbytes < 1) break;
+                    read_bytes = static_cast<size_t>(numbytes);
+                }
+
+                woffset += read_bytes;
+            }
+            else
+            {
+                /* If the read offset is at or behind the write offset, the
+                 * writeable area (might) wrap around. Make sure the sample
+                 * data can fit, and calculate how much can go in front before
+                 * wrapping.
+                 */
+                const size_t writable{(!roffset ? mBufferDataSize-woffset-1 :
+                    (mBufferDataSize-woffset)) / mBytesPerBlock};
+                if(!writable) break;
+
+                if(mSampleFormat == SampleType::Int16)
+                {
+                    sf_count_t num_frames{sf_readf_short(mSndfile,
+                        reinterpret_cast<short*>(&mBufferData[woffset]),
+                        static_cast<sf_count_t>(writable*mSamplesPerBlock))};
+                    if(num_frames < 1) break;
+                    read_bytes = static_cast<size_t>(num_frames) * mBytesPerBlock;
+                }
+                else if(mSampleFormat == SampleType::Float)
+                {
+                    sf_count_t num_frames{sf_readf_float(mSndfile,
+                        reinterpret_cast<float*>(&mBufferData[woffset]),
+                        static_cast<sf_count_t>(writable*mSamplesPerBlock))};
+                    if(num_frames < 1) break;
+                    read_bytes = static_cast<size_t>(num_frames) * mBytesPerBlock;
+                }
+                else
+                {
+                    sf_count_t numbytes{sf_read_raw(mSndfile, &mBufferData[woffset],
+                        static_cast<sf_count_t>(writable*mBytesPerBlock))};
+                    if(numbytes < 1) break;
+                    read_bytes = static_cast<size_t>(numbytes);
+                }
+
+                woffset += read_bytes;
+                if(woffset == mBufferDataSize)
+                    woffset = 0;
+            }
+            mWritePos.store(woffset, std::memory_order_release);
+            mDecoderOffset += read_bytes;
+        }
+
+        if(state != AL_PLAYING && state != AL_PAUSED)
+        {
+            /* If the source is not playing or paused, it either underrun
+             * (AL_STOPPED) or is just getting started (AL_INITIAL). If the
+             * ring buffer is empty, it's done, otherwise play the source with
+             * what's available.
+             */
+            const size_t roffset{mReadPos.load(std::memory_order_relaxed)};
+            const size_t readable{((woffset >= roffset) ? woffset : (mBufferDataSize+woffset)) -
+                roffset};
+            if(readable == 0)
+                return false;
+
+            /* Store the playback offset that the source will start reading
+             * from, so it can be tracked during playback.
+             */
+            mStartOffset = mDecoderOffset - readable;
+            alSourcePlay(mSource);
+            if(alGetError() != AL_NO_ERROR)
+                return false;
+        }
+        return true;
+    }
+};
+
+} // namespace
+
+int main(int argc, char **argv)
+{
+    /* A simple RAII container for OpenAL startup and shutdown. */
+    struct AudioManager {
+        AudioManager(char ***argv_, int *argc_)
+        {
+            if(InitAL(argv_, argc_) != 0)
+                throw std::runtime_error{"Failed to initialize OpenAL"};
+        }
+        ~AudioManager() { CloseAL(); }
+    };
+
+    /* Print out usage if no arguments were specified */
+    if(argc < 2)
+    {
+        fprintf(stderr, "Usage: %s [-device <name>] <filenames...>\n", argv[0]);
+        return 1;
+    }
+
+    argv++; argc--;
+    AudioManager almgr{&argv, &argc};
+
+    if(!alIsExtensionPresent("AL_SOFT_callback_buffer"))
+    {
+        fprintf(stderr, "AL_SOFT_callback_buffer extension not available\n");
+        return 1;
+    }
+
+    alBufferCallbackSOFT = reinterpret_cast<LPALBUFFERCALLBACKSOFT>(
+        alGetProcAddress("alBufferCallbackSOFT"));
+
+    ALCint refresh{25};
+    alcGetIntegerv(alcGetContextsDevice(alcGetCurrentContext()), ALC_REFRESH, 1, &refresh);
+
+    std::unique_ptr<StreamPlayer> player{new StreamPlayer{}};
+
+    /* Play each file listed on the command line */
+    for(int i{0};i < argc;++i)
+    {
+        if(!player->open(argv[i]))
+            continue;
+
+        /* Get the name portion, without the path, for display. */
+        const char *namepart{strrchr(argv[i], '/')};
+        if(namepart || (namepart=strrchr(argv[i], '\\')))
+            ++namepart;
+        else
+            namepart = argv[i];
+
+        printf("Playing: %s (%s, %dhz)\n", namepart, FormatName(player->mFormat),
+            player->mSfInfo.samplerate);
+        fflush(stdout);
+
+        if(!player->prepare())
+        {
+            player->close();
+            continue;
+        }
+
+        while(player->update())
+            std::this_thread::sleep_for(nanoseconds{seconds{1}} / refresh);
+        putc('\n', stdout);
+
+        /* All done with this file. Close it and go to the next */
+        player->close();
+    }
+    /* All done. */
+    printf("Done.\n");
+
+    return 0;
+}
diff --git a/examples/altonegen.c b/examples/altonegen.c
index 553bc996..75db2d6b 100644
--- a/examples/altonegen.c
+++ b/examples/altonegen.c
@@ -44,6 +44,8 @@
 
 #include "common/alhelpers.h"
 
+#include "win_main_utf8.h"
+
 #ifndef M_PI
 #define M_PI    (3.14159265358979323846)
 #endif
@@ -91,7 +93,7 @@ static void ApplySin(ALfloat *data, ALdouble g, ALuint srate, ALuint freq)
 /* Generates waveforms using additive synthesis. Each waveform is constructed
  * by summing one or more sine waves, up to (and excluding) nyquist.
  */
-static ALuint CreateWave(enum WaveType type, ALuint freq, ALuint srate)
+static ALuint CreateWave(enum WaveType type, ALuint freq, ALuint srate, ALfloat gain)
 {
     ALuint seed = 22222;
     ALuint data_size;
@@ -142,6 +144,12 @@ static ALuint CreateWave(enum WaveType type, ALuint freq, ALuint srate)
             break;
     }
 
+    if(gain != 1.0f)
+    {
+        for(i = 0;i < srate;i++)
+            data[i] *= gain;
+    }
+
     /* Buffer the audio data into a new buffer object. */
     buffer = 0;
     alGenBuffers(1, &buffer);
@@ -173,6 +181,7 @@ int main(int argc, char *argv[])
     ALint tone_freq = 1000;
     ALCint dev_rate;
     ALenum state;
+    ALfloat gain = 1.0f;
     int i;
 
     argv++; argc--;
@@ -188,7 +197,8 @@ int main(int argc, char *argv[])
 
     for(i = 0;i < argc;i++)
     {
-        if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
+        if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-?") == 0
+            || strcmp(argv[i], "--help") == 0)
         {
             fprintf(stderr, "OpenAL Tone Generator\n"
 "\n"
@@ -200,6 +210,7 @@ int main(int argc, char *argv[])
 "  --waveform/-w <type>      Waveform type: sine (default), square, sawtooth,\n"
 "                                triangle, impulse, noise\n"
 "  --freq/-f <hz>            Tone frequency (default 1000 hz)\n"
+"  --gain/-g <gain>          gain 0.0 to 1 (default 1)\n"
 "  --srate/-s <sample rate>  Sampling rate (default output rate)\n",
                 appname
             );
@@ -239,6 +250,16 @@ int main(int argc, char *argv[])
                 tone_freq = 1;
             }
         }
+        else if(i+1 < argc && (strcmp(argv[i], "--gain") == 0 || strcmp(argv[i], "-g") == 0))
+        {
+            i++;
+            gain = (ALfloat)atof(argv[i]);
+            if(gain < 0.0f || gain > 1.0f)
+            {
+                fprintf(stderr, "Invalid gain: %s (min: 0.0, max 1.0)\n", argv[i]);
+                gain = 1.0f;
+            }
+        }
         else if(i+1 < argc && (strcmp(argv[i], "--srate") == 0 || strcmp(argv[i], "-s") == 0))
         {
             i++;
@@ -260,7 +281,7 @@ int main(int argc, char *argv[])
         srate = dev_rate;
 
     /* Load the sound into a buffer. */
-    buffer = CreateWave(wavetype, (ALuint)tone_freq, (ALuint)srate);
+    buffer = CreateWave(wavetype, (ALuint)tone_freq, (ALuint)srate, gain);
     if(!buffer)
     {
         CloseAL();
diff --git a/examples/common/alhelpers.c b/examples/common/alhelpers.c
index 0febef43..6627f704 100644
--- a/examples/common/alhelpers.c
+++ b/examples/common/alhelpers.c
@@ -36,6 +36,7 @@
 
 #include "AL/al.h"
 #include "AL/alc.h"
+#include "AL/alext.h"
 
 
 /* InitAL opens a device and sets up a context using default attributes, making
@@ -107,10 +108,53 @@ const char *FormatName(ALenum format)
 {
     switch(format)
     {
-        case AL_FORMAT_MONO8: return "Mono, U8";
-        case AL_FORMAT_MONO16: return "Mono, S16";
-        case AL_FORMAT_STEREO8: return "Stereo, U8";
-        case AL_FORMAT_STEREO16: return "Stereo, S16";
+    case AL_FORMAT_MONO8: return "Mono, U8";
+    case AL_FORMAT_MONO16: return "Mono, S16";
+    case AL_FORMAT_MONO_FLOAT32: return "Mono, Float32";
+    case AL_FORMAT_MONO_MULAW: return "Mono, muLaw";
+    case AL_FORMAT_MONO_ALAW_EXT: return "Mono, aLaw";
+    case AL_FORMAT_MONO_IMA4: return "Mono, IMA4 ADPCM";
+    case AL_FORMAT_MONO_MSADPCM_SOFT: return "Mono, MS ADPCM";
+    case AL_FORMAT_STEREO8: return "Stereo, U8";
+    case AL_FORMAT_STEREO16: return "Stereo, S16";
+    case AL_FORMAT_STEREO_FLOAT32: return "Stereo, Float32";
+    case AL_FORMAT_STEREO_MULAW: return "Stereo, muLaw";
+    case AL_FORMAT_STEREO_ALAW_EXT: return "Stereo, aLaw";
+    case AL_FORMAT_STEREO_IMA4: return "Stereo, IMA4 ADPCM";
+    case AL_FORMAT_STEREO_MSADPCM_SOFT: return "Stereo, MS ADPCM";
+    case AL_FORMAT_QUAD8: return "Quadraphonic, U8";
+    case AL_FORMAT_QUAD16: return "Quadraphonic, S16";
+    case AL_FORMAT_QUAD32: return "Quadraphonic, Float32";
+    case AL_FORMAT_QUAD_MULAW: return "Quadraphonic, muLaw";
+    case AL_FORMAT_51CHN8: return "5.1 Surround, U8";
+    case AL_FORMAT_51CHN16: return "5.1 Surround, S16";
+    case AL_FORMAT_51CHN32: return "5.1 Surround, Float32";
+    case AL_FORMAT_51CHN_MULAW: return "5.1 Surround, muLaw";
+    case AL_FORMAT_61CHN8: return "6.1 Surround, U8";
+    case AL_FORMAT_61CHN16: return "6.1 Surround, S16";
+    case AL_FORMAT_61CHN32: return "6.1 Surround, Float32";
+    case AL_FORMAT_61CHN_MULAW: return "6.1 Surround, muLaw";
+    case AL_FORMAT_71CHN8: return "7.1 Surround, U8";
+    case AL_FORMAT_71CHN16: return "7.1 Surround, S16";
+    case AL_FORMAT_71CHN32: return "7.1 Surround, Float32";
+    case AL_FORMAT_71CHN_MULAW: return "7.1 Surround, muLaw";
+    case AL_FORMAT_BFORMAT2D_8: return "B-Format 2D, U8";
+    case AL_FORMAT_BFORMAT2D_16: return "B-Format 2D, S16";
+    case AL_FORMAT_BFORMAT2D_FLOAT32: return "B-Format 2D, Float32";
+    case AL_FORMAT_BFORMAT2D_MULAW: return "B-Format 2D, muLaw";
+    case AL_FORMAT_BFORMAT3D_8: return "B-Format 3D, U8";
+    case AL_FORMAT_BFORMAT3D_16: return "B-Format 3D, S16";
+    case AL_FORMAT_BFORMAT3D_FLOAT32: return "B-Format 3D, Float32";
+    case AL_FORMAT_BFORMAT3D_MULAW: return "B-Format 3D, muLaw";
+    case AL_FORMAT_UHJ2CHN8_SOFT: return "UHJ 2-channel, U8";
+    case AL_FORMAT_UHJ2CHN16_SOFT: return "UHJ 2-channel, S16";
+    case AL_FORMAT_UHJ2CHN_FLOAT32_SOFT: return "UHJ 2-channel, Float32";
+    case AL_FORMAT_UHJ3CHN8_SOFT: return "UHJ 3-channel, U8";
+    case AL_FORMAT_UHJ3CHN16_SOFT: return "UHJ 3-channel, S16";
+    case AL_FORMAT_UHJ3CHN_FLOAT32_SOFT: return "UHJ 3-channel, Float32";
+    case AL_FORMAT_UHJ4CHN8_SOFT: return "UHJ 4-channel, U8";
+    case AL_FORMAT_UHJ4CHN16_SOFT: return "UHJ 4-channel, S16";
+    case AL_FORMAT_UHJ4CHN_FLOAT32_SOFT: return "UHJ 4-channel, Float32";
     }
     return "Unknown Format";
 }
diff --git a/examples/common/alhelpers.h b/examples/common/alhelpers.h
index 3752d218..34f73864 100644
--- a/examples/common/alhelpers.h
+++ b/examples/common/alhelpers.h
@@ -18,6 +18,19 @@ void CloseAL(void);
 int altime_get(void);
 void al_nssleep(unsigned long nsec);
 
+/* C doesn't allow casting between function and non-function pointer types, so
+ * with C99 we need to use a union to reinterpret the pointer type. Pre-C99
+ * still needs to use a normal cast and live with the warning (C++ is fine with
+ * a regular reinterpret_cast).
+ */
+#if __STDC_VERSION__ >= 199901L
+#define FUNCTION_CAST(T, ptr) (union{void *p; T f;}){ptr}.f
+#elif defined(__cplusplus)
+#define FUNCTION_CAST(T, ptr) reinterpret_cast<T>(ptr)
+#else
+#define FUNCTION_CAST(T, ptr) (T)(ptr)
+#endif
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/hrtf/Default HRTF.mhr b/hrtf/Default HRTF.mhr
new file mode 100644
index 00000000..49551675
--- /dev/null
+++ b/hrtf/Default HRTF.mhr
diff --git a/hrtf/default-44100.mhr b/hrtf/default-44100.mhr
deleted file mode 100644
index f7992e13..00000000
--- a/hrtf/default-44100.mhr
+++ /dev/null
diff --git a/hrtf/default-48000.mhr b/hrtf/default-48000.mhr
deleted file mode 100644
index 66fd4f56..00000000
--- a/hrtf/default-48000.mhr
+++ /dev/null
diff --git a/include/AL/al.h b/include/AL/al.h
index 413b3833..5071fa5e 100644
--- a/include/AL/al.h
+++ b/include/AL/al.h
@@ -1,7 +1,7 @@
 #ifndef AL_AL_H
 #define AL_AL_H
 
-#if defined(__cplusplus)
+#ifdef __cplusplus
 extern "C" {
 #endif
 
@@ -15,14 +15,14 @@ extern "C" {
  #endif
 #endif
 
-#if defined(_WIN32)
+#ifdef _WIN32
  #define AL_APIENTRY __cdecl
 #else
  #define AL_APIENTRY
 #endif
 
 
-/** Deprecated macro. */
+/* Deprecated macros. */
 #define OPENAL
 #define ALAPI                                    AL_API
 #define ALAPIENTRY                               AL_APIENTRY
@@ -30,7 +30,7 @@ extern "C" {
 #define AL_ILLEGAL_ENUM                          AL_INVALID_ENUM
 #define AL_ILLEGAL_COMMAND                       AL_INVALID_OPERATION
 
-/** Supported AL version. */
+/* Supported AL versions. */
 #define AL_VERSION_1_0
 #define AL_VERSION_1_1
 
@@ -40,43 +40,43 @@ typedef char ALboolean;
 /** character */
 typedef char ALchar;
 
-/** signed 8-bit 2's complement integer */
+/** signed 8-bit integer */
 typedef signed char ALbyte;
 
 /** unsigned 8-bit integer */
 typedef unsigned char ALubyte;
 
-/** signed 16-bit 2's complement integer */
+/** signed 16-bit integer */
 typedef short ALshort;
 
 /** unsigned 16-bit integer */
 typedef unsigned short ALushort;
 
-/** signed 32-bit 2's complement integer */
+/** signed 32-bit integer */
 typedef int ALint;
 
 /** unsigned 32-bit integer */
 typedef unsigned int ALuint;
 
-/** non-negative 32-bit binary integer size */
+/** non-negative 32-bit integer size */
 typedef int ALsizei;
 
-/** enumerated 32-bit value */
+/** 32-bit enumeration value */
 typedef int ALenum;
 
-/** 32-bit IEEE754 floating-point */
+/** 32-bit IEEE-754 floating-point */
 typedef float ALfloat;
 
-/** 64-bit IEEE754 floating-point */
+/** 64-bit IEEE-754 floating-point */
 typedef double ALdouble;
 
-/** void type (for opaque pointers only) */
+/** void type (opaque pointers only) */
 typedef void ALvoid;
 
 
-/* Enumerant values begin at column 50. No tabs. */
+/* Enumeration values begin at column 50. Do not use tabs. */
 
-/** "no distance model" or "no buffer" */
+/** No distance model or no buffer */
 #define AL_NONE                                  0
 
 /** Boolean False. */
@@ -89,10 +89,10 @@ typedef void ALvoid;
 /**
  * Relative source.
  * Type:    ALboolean
- * Range:   [AL_TRUE, AL_FALSE]
+ * Range:   [AL_FALSE, AL_TRUE]
  * Default: AL_FALSE
  *
- * Specifies if the Source has relative coordinates.
+ * Specifies if the source uses relative coordinates.
  */
 #define AL_SOURCE_RELATIVE                       0x202
 
@@ -103,7 +103,8 @@ typedef void ALvoid;
  * Range:   [0 - 360]
  * Default: 360
  *
- * The angle covered by the inner cone, where the source will not attenuate.
+ * The angle covered by the inner cone, the area within which the source will
+ * not be attenuated by direction.
  */
 #define AL_CONE_INNER_ANGLE                      0x1001
 
@@ -112,8 +113,8 @@ typedef void ALvoid;
  * Range:   [0 - 360]
  * Default: 360
  *
- * The angle covered by the outer cone, where the source will be fully
- * attenuated.
+ * The angle covered by the outer cone, the area outside of which the source
+ * will be fully attenuated by direction.
  */
 #define AL_CONE_OUTER_ANGLE                      0x1002
 
@@ -123,7 +124,7 @@ typedef void ALvoid;
  * Range:   [0.5 - 2.0]
  * Default: 1.0
  *
- * A multiplier for the frequency (sample rate) of the source's buffer.
+ * A multiplier for the sample rate of the source's buffer.
  */
 #define AL_PITCH                                 0x1003
 
@@ -134,12 +135,12 @@ typedef void ALvoid;
  *
  * The source or listener location in three dimensional space.
  *
- * OpenAL, like OpenGL, uses a right handed coordinate system, where in a
- * frontal default view X (thumb) points right, Y points up (index finger), and
- * Z points towards the viewer/camera (middle finger).
+ * OpenAL uses a right handed coordinate system, like OpenGL, where with a
+ * default view, X points right (thumb), Y points up (index finger), and Z
+ * points towards the viewer/camera (middle finger).
  *
- * To switch from a left handed coordinate system, flip the sign on the Z
- * coordinate.
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_POSITION                              0x1004
 
@@ -148,8 +149,11 @@ typedef void ALvoid;
  * Type:    ALfloat[3], ALint[3]
  * Default: {0, 0, 0}
  *
- * Specifies the current direction in local space.
- * A zero-length vector specifies an omni-directional source (cone is ignored).
+ * Specifies the current direction in local space. A zero-length vector
+ * specifies an omni-directional source (cone is ignored).
+ *
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_DIRECTION                             0x1005
 
@@ -158,26 +162,30 @@ typedef void ALvoid;
  * Type:    ALfloat[3], ALint[3]
  * Default: {0, 0, 0}
  *
- * Specifies the current velocity in local space.
+ * Specifies the current velocity, relative to the position.
+ *
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_VELOCITY                              0x1006
 
 /**
  * Source looping.
  * Type:    ALboolean
- * Range:   [AL_TRUE, AL_FALSE]
+ * Range:   [AL_FALSE, AL_TRUE]
  * Default: AL_FALSE
  *
- * Specifies whether source is looping.
+ * Specifies whether source playback loops.
  */
 #define AL_LOOPING                               0x1007
 
 /**
  * Source buffer.
- * Type:  ALuint
- * Range: any valid Buffer.
+ * Type:    ALuint
+ * Range:   any valid Buffer ID
+ * Default: AL_NONE
  *
- * Specifies the buffer to provide sound samples.
+ * Specifies the buffer to provide sound samples for a source.
  */
 #define AL_BUFFER                                0x1009
 
@@ -186,12 +194,12 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - ]
  *
+ * For sources, an initial linear gain value (before attenuation is applied).
+ * For the listener, an output linear gain adjustment.
+ *
  * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
- * of about -6dB. Each multiplicaton by 2 equals an amplification of about
+ * of about -6dB. Each multiplication by 2 equals an amplification of about
  * +6dB.
- *
- * A value of 0.0 is meaningless with respect to a logarithmic scale; it is
- * silent.
  */
 #define AL_GAIN                                  0x100A
 
@@ -200,8 +208,8 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - 1.0]
  *
- * The minimum gain allowed for a source, after distance and cone attenation is
- * applied (if applicable).
+ * The minimum gain allowed for a source, after distance and cone attenuation
+ * are applied (if applicable).
  */
 #define AL_MIN_GAIN                              0x100D
 
@@ -210,31 +218,33 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - 1.0]
  *
- * The maximum gain allowed for a source, after distance and cone attenation is
- * applied (if applicable).
+ * The maximum gain allowed for a source, after distance and cone attenuation
+ * are applied (if applicable).
  */
 #define AL_MAX_GAIN                              0x100E
 
 /**
  * Listener orientation.
- * Type: ALfloat[6]
+ * Type:    ALfloat[6]
  * Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
  *
  * Effectively two three dimensional vectors. The first vector is the front (or
- * "at") and the second is the top (or "up").
+ * "at") and the second is the top (or "up"). Both vectors are relative to the
+ * listener position.
  *
- * Both vectors are in local space.
+ * To change from or to a left handed coordinate system, negate the Z
+ * component of both vectors.
  */
 #define AL_ORIENTATION                           0x100F
 
 /**
  * Source state (query only).
- * Type:  ALint
+ * Type:  ALenum
  * Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
  */
 #define AL_SOURCE_STATE                          0x1010
 
-/** Source state value. */
+/* Source state values. */
 #define AL_INITIAL                               0x1011
 #define AL_PLAYING                               0x1012
 #define AL_PAUSED                                0x1013
@@ -267,9 +277,9 @@ typedef void ALvoid;
  * Range:   [0.0 - ]
  * Default: 1.0
  *
- * The distance in units that no attenuation occurs.
+ * The distance in units that no distance attenuation occurs.
  *
- * At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
+ * At 0.0, no distance attenuation occurs with non-linear attenuation models.
  */
 #define AL_REFERENCE_DISTANCE                    0x1020
 
@@ -292,7 +302,7 @@ typedef void ALvoid;
  * Default: 0.0
  *
  * The gain attenuation applied when the listener is outside of the source's
- * outer cone.
+ * outer cone angle.
  */
 #define AL_CONE_OUTER_GAIN                       0x1022
 
@@ -300,7 +310,7 @@ typedef void ALvoid;
  * Source maximum distance.
  * Type:    ALfloat
  * Range:   [0.0 - ]
- * Default: +inf
+ * Default: FLT_MAX
  *
  * The distance above which the source is not attenuated any further with a
  * clamped distance model, or where attenuation reaches 0.0 gain for linear
@@ -308,16 +318,16 @@ typedef void ALvoid;
  */
 #define AL_MAX_DISTANCE                          0x1023
 
-/** Source buffer position, in seconds */
+/** Source buffer offset, in seconds */
 #define AL_SEC_OFFSET                            0x1024
-/** Source buffer position, in sample frames */
+/** Source buffer offset, in sample frames */
 #define AL_SAMPLE_OFFSET                         0x1025
-/** Source buffer position, in bytes */
+/** Source buffer offset, in bytes */
 #define AL_BYTE_OFFSET                           0x1026
 
 /**
  * Source type (query only).
- * Type:  ALint
+ * Type:  ALenum
  * Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
  *
  * A Source is Static if a Buffer has been attached using AL_BUFFER.
@@ -330,31 +340,30 @@ typedef void ALvoid;
  */
 #define AL_SOURCE_TYPE                           0x1027
 
-/** Source type value. */
+/* Source type values. */
 #define AL_STATIC                                0x1028
 #define AL_STREAMING                             0x1029
 #define AL_UNDETERMINED                          0x1030
 
-/** Buffer format specifier. */
+/** Unsigned 8-bit mono buffer format. */
 #define AL_FORMAT_MONO8                          0x1100
+/** Signed 16-bit mono buffer format. */
 #define AL_FORMAT_MONO16                         0x1101
+/** Unsigned 8-bit stereo buffer format. */
 #define AL_FORMAT_STEREO8                        0x1102
+/** Signed 16-bit stereo buffer format. */
 #define AL_FORMAT_STEREO16                       0x1103
 
-/** Buffer frequency (query only). */
+/** Buffer frequency/sample rate (query only). */
 #define AL_FREQUENCY                             0x2001
 /** Buffer bits per sample (query only). */
 #define AL_BITS                                  0x2002
 /** Buffer channel count (query only). */
 #define AL_CHANNELS                              0x2003
-/** Buffer data size (query only). */
+/** Buffer data size in bytes (query only). */
 #define AL_SIZE                                  0x2004
 
-/**
- * Buffer state.
- *
- * Not for public use.
- */
+/* Buffer state. Not for public use. */
 #define AL_UNUSED                                0x2010
 #define AL_PENDING                               0x2011
 #define AL_PROCESSED                             0x2012
@@ -363,32 +372,31 @@ typedef void ALvoid;
 /** No error. */
 #define AL_NO_ERROR                              0
 
-/** Invalid name paramater passed to AL call. */
+/** Invalid name (ID) passed to an AL call. */
 #define AL_INVALID_NAME                          0xA001
 
-/** Invalid enum parameter passed to AL call. */
+/** Invalid enumeration passed to AL call. */
 #define AL_INVALID_ENUM                          0xA002
 
-/** Invalid value parameter passed to AL call. */
+/** Invalid value passed to AL call. */
 #define AL_INVALID_VALUE                         0xA003
 
 /** Illegal AL call. */
 #define AL_INVALID_OPERATION                     0xA004
 
-/** Not enough memory. */
+/** Not enough memory to execute the AL call. */
 #define AL_OUT_OF_MEMORY                         0xA005
 
 
-/** Context string: Vendor ID. */
+/** Context string: Vendor name. */
 #define AL_VENDOR                                0xB001
 /** Context string: Version. */
 #define AL_VERSION                               0xB002
-/** Context string: Renderer ID. */
+/** Context string: Renderer name. */
 #define AL_RENDERER                              0xB003
 /** Context string: Space-separated extension list. */
 #define AL_EXTENSIONS                            0xB004
 
-
 /**
  * Doppler scale.
  * Type:    ALfloat
@@ -398,7 +406,6 @@ typedef void ALvoid;
  * Scale for source and listener velocities.
  */
 #define AL_DOPPLER_FACTOR                        0xC000
-AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
 
 /**
  * Doppler velocity (deprecated).
@@ -406,7 +413,6 @@ AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
  * A multiplier applied to the Speed of Sound.
  */
 #define AL_DOPPLER_VELOCITY                      0xC001
-AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
 
 /**
  * Speed of Sound, in units per second.
@@ -415,14 +421,13 @@ AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
  * Default: 343.3
  *
  * The speed at which sound waves are assumed to travel, when calculating the
- * doppler effect.
+ * doppler effect from source and listener velocities.
  */
 #define AL_SPEED_OF_SOUND                        0xC003
-AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
 
 /**
  * Distance attenuation model.
- * Type:    ALint
+ * Type:    ALenum
  * Range:   [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
  *           AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
  *           AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
@@ -439,9 +444,8 @@ AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
  * distance calculated is clamped between the reference and max distances.
  */
 #define AL_DISTANCE_MODEL                        0xD000
-AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
 
-/** Distance model value. */
+/* Distance model values. */
 #define AL_INVERSE_DISTANCE                      0xD001
 #define AL_INVERSE_DISTANCE_CLAMPED              0xD002
 #define AL_LINEAR_DISTANCE                       0xD003
@@ -449,12 +453,19 @@ AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
 #define AL_EXPONENT_DISTANCE                     0xD005
 #define AL_EXPONENT_DISTANCE_CLAMPED             0xD006
 
-/** Renderer State management. */
+#ifndef AL_NO_PROTOTYPES
+/* Renderer State management. */
 AL_API void AL_APIENTRY alEnable(ALenum capability);
 AL_API void AL_APIENTRY alDisable(ALenum capability);
 AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability);
 
-/** State retrieval. */
+/* Context state setting. */
+AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
+AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
+AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
+AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
+
+/* Context state retrieval. */
 AL_API const ALchar* AL_APIENTRY alGetString(ALenum param);
 AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values);
 AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values);
@@ -466,24 +477,25 @@ AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param);
 AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param);
 
 /**
- * Error retrieval.
- *
- * Obtain the first error generated in the AL context since the last check.
+ * Obtain the first error generated in the AL context since the last call to
+ * this function.
  */
 AL_API ALenum AL_APIENTRY alGetError(void);
 
+/** Query for the presence of an extension on the AL context. */
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname);
 /**
- * Extension support.
- *
- * Query for the presence of an extension, and obtain any appropriate function
- * pointers and enum values.
+ * Retrieve the address of a function. The returned function may be context-
+ * specific.
  */
-AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname);
 AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname);
+/**
+ * Retrieve the value of an enum. The returned value may be context-specific.
+ */
 AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename);
 
 
-/** Set Listener parameters */
+/* Set listener parameters. */
 AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value);
 AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values);
@@ -491,7 +503,7 @@ AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value);
 AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3);
 AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values);
 
-/** Get Listener parameters */
+/* Get listener parameters. */
 AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value);
 AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values);
@@ -500,14 +512,14 @@ AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *valu
 AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values);
 
 
-/** Create Source objects. */
+/** Create source objects. */
 AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources);
-/** Delete Source objects. */
+/** Delete source objects. */
 AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources);
-/** Verify a handle is a valid Source. */
+/** Verify an ID is for a valid source. */
 AL_API ALboolean AL_APIENTRY alIsSource(ALuint source);
 
-/** Set Source parameters. */
+/* Set source parameters. */
 AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value);
 AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values);
@@ -515,7 +527,7 @@ AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value);
 AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
 AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values);
 
-/** Get Source parameters. */
+/* Get source parameters. */
 AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value);
 AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values);
@@ -524,41 +536,44 @@ AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1
 AL_API void AL_APIENTRY alGetSourceiv(ALuint source,  ALenum param, ALint *values);
 
 
-/** Play, replay, or resume (if paused) a list of Sources */
-AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources);
-/** Stop a list of Sources */
-AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources);
-/** Rewind a list of Sources */
-AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources);
-/** Pause a list of Sources */
-AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources);
-
-/** Play, replay, or resume a Source */
+/** Play, restart, or resume a source, setting its state to AL_PLAYING. */
 AL_API void AL_APIENTRY alSourcePlay(ALuint source);
-/** Stop a Source */
+/** Stop a source, setting its state to AL_STOPPED if playing or paused. */
 AL_API void AL_APIENTRY alSourceStop(ALuint source);
-/** Rewind a Source (set playback postiton to beginning) */
+/** Rewind a source, setting its state to AL_INITIAL. */
 AL_API void AL_APIENTRY alSourceRewind(ALuint source);
-/** Pause a Source */
+/** Pause a source, setting its state to AL_PAUSED if playing. */
 AL_API void AL_APIENTRY alSourcePause(ALuint source);
 
+/** Play, restart, or resume a list of sources atomically. */
+AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources);
+/** Stop a list of sources atomically. */
+AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources);
+/** Rewind a list of sources atomically. */
+AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources);
+/** Pause a list of sources atomically. */
+AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources);
+
 /** Queue buffers onto a source */
 AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers);
 /** Unqueue processed buffers from a source */
 AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers);
 
 
-/** Create Buffer objects */
+/** Create buffer objects */
 AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers);
-/** Delete Buffer objects */
+/** Delete buffer objects */
 AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers);
-/** Verify a handle is a valid Buffer */
+/** Verify an ID is a valid buffer (including the NULL buffer) */
 AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer);
 
-/** Specifies the data to be copied into a buffer */
-AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+/**
+ * Copies data into the buffer, interpreting it using the specified format and
+ * samplerate.
+ */
+AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate);
 
-/** Set Buffer parameters, */
+/* Set buffer parameters. */
 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value);
 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values);
@@ -566,15 +581,18 @@ AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value);
 AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values);
 
-/** Get Buffer parameters. */
+/* Get buffer parameters. */
 AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value);
 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values);
 AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value);
 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values);
+#endif /* AL_NO_PROTOTYPES */
 
-/** Pointer-to-function type, useful for dynamically getting AL entry points. */
+/* Pointer-to-function types, useful for storing dynamically loaded AL entry
+ * points.
+ */
 typedef void          (AL_APIENTRY *LPALENABLE)(ALenum capability);
 typedef void          (AL_APIENTRY *LPALDISABLE)(ALenum capability);
 typedef ALboolean     (AL_APIENTRY *LPALISENABLED)(ALenum capability);
@@ -631,7 +649,7 @@ typedef void          (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALs
 typedef void          (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers);
 typedef void          (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers);
 typedef ALboolean     (AL_APIENTRY *LPALISBUFFER)(ALuint buffer);
-typedef void          (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+typedef void          (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate);
 typedef void          (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value);
 typedef void          (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 typedef void          (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values);
@@ -649,7 +667,7 @@ typedef void          (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value);
 typedef void          (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value);
 typedef void          (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel);
 
-#if defined(__cplusplus)
+#ifdef __cplusplus
 }  /* extern "C" */
 #endif
 
diff --git a/include/AL/alc.h b/include/AL/alc.h
index 5786bad2..6d210333 100644
--- a/include/AL/alc.h
+++ b/include/AL/alc.h
@@ -1,7 +1,7 @@
 #ifndef AL_ALC_H
 #define AL_ALC_H
 
-#if defined(__cplusplus)
+#ifdef __cplusplus
 extern "C" {
 #endif
 
@@ -15,14 +15,14 @@ extern "C" {
  #endif
 #endif
 
-#if defined(_WIN32)
+#ifdef _WIN32
  #define ALC_APIENTRY __cdecl
 #else
  #define ALC_APIENTRY
 #endif
 
 
-/** Deprecated macro. */
+/* Deprecated macros. */
 #define ALCAPI                                   ALC_API
 #define ALCAPIENTRY                              ALC_APIENTRY
 #define ALC_INVALID                              0
@@ -41,41 +41,41 @@ typedef char ALCboolean;
 /** character */
 typedef char ALCchar;
 
-/** signed 8-bit 2's complement integer */
+/** signed 8-bit integer */
 typedef signed char ALCbyte;
 
 /** unsigned 8-bit integer */
 typedef unsigned char ALCubyte;
 
-/** signed 16-bit 2's complement integer */
+/** signed 16-bit integer */
 typedef short ALCshort;
 
 /** unsigned 16-bit integer */
 typedef unsigned short ALCushort;
 
-/** signed 32-bit 2's complement integer */
+/** signed 32-bit integer */
 typedef int ALCint;
 
 /** unsigned 32-bit integer */
 typedef unsigned int ALCuint;
 
-/** non-negative 32-bit binary integer size */
+/** non-negative 32-bit integer size */
 typedef int ALCsizei;
 
-/** enumerated 32-bit value */
+/** 32-bit enumeration value */
 typedef int ALCenum;
 
-/** 32-bit IEEE754 floating-point */
+/** 32-bit IEEE-754 floating-point */
 typedef float ALCfloat;
 
-/** 64-bit IEEE754 floating-point */
+/** 64-bit IEEE-754 floating-point */
 typedef double ALCdouble;
 
 /** void type (for opaque pointers only) */
 typedef void ALCvoid;
 
 
-/* Enumerant values begin at column 50. No tabs. */
+/* Enumeration values begin at column 50. Do not use tabs. */
 
 /** Boolean False. */
 #define ALC_FALSE                                0
@@ -89,7 +89,7 @@ typedef void ALCvoid;
 /** Context attribute: <int> Hz. */
 #define ALC_REFRESH                              0x1008
 
-/** Context attribute: AL_TRUE or AL_FALSE. */
+/** Context attribute: AL_TRUE or AL_FALSE synchronous context? */
 #define ALC_SYNC                                 0x1009
 
 /** Context attribute: <int> requested Mono (3D) Sources. */
@@ -107,30 +107,32 @@ typedef void ALCvoid;
 /** Invalid context handle. */
 #define ALC_INVALID_CONTEXT                      0xA002
 
-/** Invalid enum parameter passed to an ALC call. */
+/** Invalid enumeration passed to an ALC call. */
 #define ALC_INVALID_ENUM                         0xA003
 
-/** Invalid value parameter passed to an ALC call. */
+/** Invalid value passed to an ALC call. */
 #define ALC_INVALID_VALUE                        0xA004
 
 /** Out of memory. */
 #define ALC_OUT_OF_MEMORY                        0xA005
 
 
-/** Runtime ALC version. */
+/** Runtime ALC major version. */
 #define ALC_MAJOR_VERSION                        0x1000
+/** Runtime ALC minor version. */
 #define ALC_MINOR_VERSION                        0x1001
 
-/** Context attribute list properties. */
+/** Context attribute list size. */
 #define ALC_ATTRIBUTES_SIZE                      0x1002
+/** Context attribute list properties. */
 #define ALC_ALL_ATTRIBUTES                       0x1003
 
 /** String for the default device specifier. */
 #define ALC_DEFAULT_DEVICE_SPECIFIER             0x1004
 /**
- * String for the given device's specifier.
+ * Device specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known device specifiers (list ends with an empty string).
  */
 #define ALC_DEVICE_SPECIFIER                     0x1005
@@ -141,9 +143,9 @@ typedef void ALCvoid;
 /** Capture extension */
 #define ALC_EXT_CAPTURE 1
 /**
- * String for the given capture device's specifier.
+ * Capture device specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known capture device specifiers (list ends with an empty string).
  */
 #define ALC_CAPTURE_DEVICE_SPECIFIER             0x310
@@ -158,57 +160,92 @@ typedef void ALCvoid;
 /** String for the default extended device specifier. */
 #define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
 /**
- * String for the given extended device's specifier.
+ * Device's extended specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known extended device specifiers (list ends with an empty string).
  */
 #define ALC_ALL_DEVICES_SPECIFIER                0x1013
 
 
-/** Context management. */
-ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist);
+#ifndef ALC_NO_PROTOTYPES
+/* Context management. */
+
+/** Create and attach a context to the given device. */
+ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrlist);
+/**
+ * Makes the given context the active process-wide context. Passing NULL clears
+ * the active context.
+ */
 ALC_API ALCboolean  ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context);
+/** Resumes processing updates for the given context. */
 ALC_API void        ALC_APIENTRY alcProcessContext(ALCcontext *context);
+/** Suspends updates for the given context. */
 ALC_API void        ALC_APIENTRY alcSuspendContext(ALCcontext *context);
+/** Remove a context from its device and destroys it. */
 ALC_API void        ALC_APIENTRY alcDestroyContext(ALCcontext *context);
+/** Returns the currently active context. */
 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void);
+/** Returns the device that a particular context is attached to. */
 ALC_API ALCdevice*  ALC_APIENTRY alcGetContextsDevice(ALCcontext *context);
 
-/** Device management. */
+/* Device management. */
+
+/** Opens the named playback device. */
 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename);
+/** Closes the given playback device. */
 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device);
 
+/* Error support. */
 
-/**
- * Error support.
- *
- * Obtain the most recent Device error.
- */
+/** Obtain the most recent Device error. */
 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device);
 
+/* Extension support. */
+
 /**
- * Extension support.
- *
- * Query for the presence of an extension, and obtain any appropriate
- * function pointers and enum values.
+ * Query for the presence of an extension on the device. Pass a NULL device to
+ * query a device-inspecific extension.
  */
 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname);
-ALC_API void*      ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
+/**
+ * Retrieve the address of a function. Given a non-NULL device, the returned
+ * function may be device-specific.
+ */
+ALC_API ALCvoid*   ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
+/**
+ * Retrieve the value of an enum. Given a non-NULL device, the returned value
+ * may be device-specific.
+ */
 ALC_API ALCenum    ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname);
 
-/** Query function. */
+/* Query functions. */
+
+/** Returns information about the device, and error strings. */
 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param);
+/** Returns information about the device and the version of OpenAL. */
 ALC_API void           ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
 
-/** Capture function. */
+/* Capture functions. */
+
+/**
+ * Opens the named capture device with the given frequency, format, and buffer
+ * size.
+ */
 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
+/** Closes the given capture device. */
 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device);
+/** Starts capturing samples into the device buffer. */
 ALC_API void       ALC_APIENTRY alcCaptureStart(ALCdevice *device);
+/** Stops capturing samples. Samples in the device buffer remain available. */
 ALC_API void       ALC_APIENTRY alcCaptureStop(ALCdevice *device);
+/** Reads samples from the device buffer. */
 ALC_API void       ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+#endif /* ALC_NO_PROTOTYPES */
 
-/** Pointer-to-function type, useful for dynamically getting ALC entry points. */
+/* Pointer-to-function types, useful for storing dynamically loaded ALC entry
+ * points.
+ */
 typedef ALCcontext*    (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist);
 typedef ALCboolean     (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context);
 typedef void           (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context);
@@ -220,7 +257,7 @@ typedef ALCdevice*     (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename
 typedef ALCboolean     (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device);
 typedef ALCenum        (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device);
 typedef ALCboolean     (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname);
-typedef void*          (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname);
+typedef ALCvoid*       (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname);
 typedef ALCenum        (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname);
 typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param);
 typedef void           (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
@@ -230,8 +267,8 @@ typedef void           (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device);
 typedef void           (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device);
 typedef void           (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
 
-#if defined(__cplusplus)
-}
+#ifdef __cplusplus
+} /* extern "C" */
 #endif
 
 #endif /* AL_ALC_H */
diff --git a/include/AL/alext.h b/include/AL/alext.h
index cd7f2750..d313a999 100644
--- a/include/AL/alext.h
+++ b/include/AL/alext.h
@@ -1,38 +1,21 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2008 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
- */
-
 #ifndef AL_ALEXT_H
 #define AL_ALEXT_H
 
 #include <stddef.h>
-/* Define int64_t and uint64_t types */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#include <inttypes.h>
-#elif defined(_WIN32) && defined(__GNUC__)
+/* Define int64 and uint64 types */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) ||             \
+    (defined(__cplusplus) && __cplusplus >= 201103L)
 #include <stdint.h>
+typedef int64_t _alsoft_int64_t;
+typedef uint64_t _alsoft_uint64_t;
 #elif defined(_WIN32)
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
+typedef __int64 _alsoft_int64_t;
+typedef unsigned __int64 _alsoft_uint64_t;
 #else
 /* Fallback if nothing above works */
-#include <inttypes.h>
+#include <stdint.h>
+typedef int64_t _alsoft_int64_t;
+typedef uint64_t _alsoft_uint64_t;
 #endif
 
 #include "alc.h"
@@ -158,9 +141,9 @@ extern "C" {
 
 #ifndef AL_EXT_STATIC_BUFFER
 #define AL_EXT_STATIC_BUFFER 1
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei);
+typedef void (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALuint,ALenum,ALvoid*,ALsizei,ALsizei);
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq);
+void AL_APIENTRY alBufferDataStatic(const ALuint buffer, ALenum format, ALvoid *data, ALsizei size, ALsizei freq);
 #endif
 #endif
 
@@ -193,9 +176,9 @@ ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
 #define AL_SOFT_buffer_sub_data 1
 #define AL_BYTE_RW_OFFSETS_SOFT                  0x1031
 #define AL_SAMPLE_RW_OFFSETS_SOFT                0x1032
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
+typedef void (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
+AL_API void AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
 #endif
 #endif
 
@@ -343,8 +326,8 @@ ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffe
 #define AL_SOFT_source_latency 1
 #define AL_SAMPLE_OFFSET_LATENCY_SOFT            0x1200
 #define AL_SEC_OFFSET_LATENCY_SOFT               0x1201
-typedef int64_t ALint64SOFT;
-typedef uint64_t ALuint64SOFT;
+typedef _alsoft_int64_t ALint64SOFT;
+typedef _alsoft_uint64_t ALuint64SOFT;
 typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble);
 typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble);
 typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*);
@@ -381,11 +364,11 @@ AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64
 #ifndef AL_SOFT_deferred_updates
 #define AL_SOFT_deferred_updates 1
 #define AL_DEFERRED_UPDATES_SOFT                 0xC002
-typedef ALvoid (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void);
-typedef ALvoid (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void);
+typedef void (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void);
+typedef void (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void);
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void);
-AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void);
+AL_API void AL_APIENTRY alDeferUpdatesSOFT(void);
+AL_API void AL_APIENTRY alProcessUpdatesSOFT(void);
 #endif
 #endif
 
@@ -408,6 +391,13 @@ AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void);
 /*#define AL_SEC_LENGTH_SOFT                       0x200B*/
 #endif
 
+#ifndef AL_SOFT_buffer_length_query
+#define AL_SOFT_buffer_length_query 1
+/*#define AL_BYTE_LENGTH_SOFT                      0x2009*/
+/*#define AL_SAMPLE_LENGTH_SOFT                    0x200A*/
+/*#define AL_SEC_LENGTH_SOFT                       0x200B*/
+#endif
+
 #ifndef ALC_SOFT_pause_device
 #define ALC_SOFT_pause_device 1
 typedef void (ALC_APIENTRY*LPALCDEVICEPAUSESOFT)(ALCdevice *device);
@@ -496,8 +486,8 @@ AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index);
 
 #ifndef ALC_SOFT_device_clock
 #define ALC_SOFT_device_clock 1
-typedef int64_t ALCint64SOFT;
-typedef uint64_t ALCuint64SOFT;
+typedef _alsoft_int64_t ALCint64SOFT;
+typedef _alsoft_uint64_t ALCuint64SOFT;
 #define ALC_DEVICE_CLOCK_SOFT                    0x1600
 #define ALC_DEVICE_LATENCY_SOFT                  0x1601
 #define ALC_DEVICE_CLOCK_LATENCY_SOFT            0x1602
@@ -509,6 +499,155 @@ ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname,
 #endif
 #endif
 
+#ifndef AL_SOFT_direct_channels_remix
+#define AL_SOFT_direct_channels_remix 1
+#define AL_DROP_UNMATCHED_SOFT                   0x0001
+#define AL_REMIX_UNMATCHED_SOFT                  0x0002
+#endif
+
+#ifndef AL_SOFT_bformat_ex
+#define AL_SOFT_bformat_ex 1
+#define AL_AMBISONIC_LAYOUT_SOFT                 0x1997
+#define AL_AMBISONIC_SCALING_SOFT                0x1998
+
+/* Ambisonic layouts */
+#define AL_FUMA_SOFT                             0x0000
+#define AL_ACN_SOFT                              0x0001
+
+/* Ambisonic scalings (normalization) */
+/*#define AL_FUMA_SOFT*/
+#define AL_SN3D_SOFT                             0x0001
+#define AL_N3D_SOFT                              0x0002
+#endif
+
+#ifndef ALC_SOFT_loopback_bformat
+#define ALC_SOFT_loopback_bformat 1
+#define ALC_AMBISONIC_LAYOUT_SOFT                0x1997
+#define ALC_AMBISONIC_SCALING_SOFT               0x1998
+#define ALC_AMBISONIC_ORDER_SOFT                 0x1999
+#define ALC_MAX_AMBISONIC_ORDER_SOFT             0x199B
+
+#define ALC_BFORMAT3D_SOFT                       0x1507
+
+/* Ambisonic layouts */
+#define ALC_FUMA_SOFT                            0x0000
+#define ALC_ACN_SOFT                             0x0001
+
+/* Ambisonic scalings (normalization) */
+/*#define ALC_FUMA_SOFT*/
+#define ALC_SN3D_SOFT                            0x0001
+#define ALC_N3D_SOFT                             0x0002
+#endif
+
+#ifndef AL_SOFT_effect_target
+#define AL_SOFT_effect_target
+#define AL_EFFECTSLOT_TARGET_SOFT                0x199C
+#endif
+
+#ifndef AL_SOFT_events
+#define AL_SOFT_events 1
+#define AL_EVENT_CALLBACK_FUNCTION_SOFT          0x19A2
+#define AL_EVENT_CALLBACK_USER_PARAM_SOFT        0x19A3
+#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT      0x19A4
+#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT  0x19A5
+#define AL_EVENT_TYPE_DISCONNECTED_SOFT          0x19A6
+typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param,
+                                           ALsizei length, const ALchar *message,
+                                           void *userParam);
+typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable);
+typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam);
+typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname);
+typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable);
+AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam);
+AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname);
+AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values);
+#endif
+#endif
+
+#ifndef ALC_SOFT_reopen_device
+#define ALC_SOFT_reopen_device
+typedef ALCboolean (ALC_APIENTRY*LPALCREOPENDEVICESOFT)(ALCdevice *device,
+    const ALCchar *deviceName, const ALCint *attribs);
+#ifdef AL_ALEXT_PROTOTYPES
+ALCboolean ALC_APIENTRY alcReopenDeviceSOFT(ALCdevice *device, const ALCchar *deviceName,
+    const ALCint *attribs);
+#endif
+#endif
+
+#ifndef AL_SOFT_callback_buffer
+#define AL_SOFT_callback_buffer
+#define AL_BUFFER_CALLBACK_FUNCTION_SOFT         0x19A0
+#define AL_BUFFER_CALLBACK_USER_PARAM_SOFT       0x19A1
+typedef ALsizei (AL_APIENTRY*ALBUFFERCALLBACKTYPESOFT)(ALvoid *userptr, ALvoid *sampledata, ALsizei numbytes);
+typedef void (AL_APIENTRY*LPALBUFFERCALLBACKSOFT)(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr);
+typedef void (AL_APIENTRY*LPALGETBUFFERPTRSOFT)(ALuint buffer, ALenum param, ALvoid **value);
+typedef void (AL_APIENTRY*LPALGETBUFFER3PTRSOFT)(ALuint buffer, ALenum param, ALvoid **value1, ALvoid **value2, ALvoid **value3);
+typedef void (AL_APIENTRY*LPALGETBUFFERPTRVSOFT)(ALuint buffer, ALenum param, ALvoid **values);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alBufferCallbackSOFT(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr);
+AL_API void AL_APIENTRY alGetBufferPtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr);
+AL_API void AL_APIENTRY alGetBuffer3PtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr0, ALvoid **ptr1, ALvoid **ptr2);
+AL_API void AL_APIENTRY alGetBufferPtrvSOFT(ALuint buffer, ALenum param, ALvoid **ptr);
+#endif
+#endif
+
+#ifndef AL_SOFT_UHJ
+#define AL_SOFT_UHJ
+#define AL_FORMAT_UHJ2CHN8_SOFT                  0x19A2
+#define AL_FORMAT_UHJ2CHN16_SOFT                 0x19A3
+#define AL_FORMAT_UHJ2CHN_FLOAT32_SOFT           0x19A4
+#define AL_FORMAT_UHJ3CHN8_SOFT                  0x19A5
+#define AL_FORMAT_UHJ3CHN16_SOFT                 0x19A6
+#define AL_FORMAT_UHJ3CHN_FLOAT32_SOFT           0x19A7
+#define AL_FORMAT_UHJ4CHN8_SOFT                  0x19A8
+#define AL_FORMAT_UHJ4CHN16_SOFT                 0x19A9
+#define AL_FORMAT_UHJ4CHN_FLOAT32_SOFT           0x19AA
+
+#define AL_STEREO_MODE_SOFT                      0x19B0
+#define AL_NORMAL_SOFT                           0x0000
+#define AL_SUPER_STEREO_SOFT                     0x0001
+#define AL_SUPER_STEREO_WIDTH_SOFT               0x19B1
+#endif
+
+#ifndef AL_SOFT_UHJ_ex
+#define AL_SOFT_UHJ_ex
+#define AL_FORMAT_UHJ2CHN_MULAW_SOFT             0x19B3
+#define AL_FORMAT_UHJ2CHN_ALAW_SOFT              0x19B4
+#define AL_FORMAT_UHJ2CHN_IMA4_SOFT              0x19B5
+#define AL_FORMAT_UHJ2CHN_MSADPCM_SOFT           0x19B6
+#define AL_FORMAT_UHJ3CHN_MULAW_SOFT             0x19B7
+#define AL_FORMAT_UHJ3CHN_ALAW_SOFT              0x19B8
+#define AL_FORMAT_UHJ4CHN_MULAW_SOFT             0x19B9
+#define AL_FORMAT_UHJ4CHN_ALAW_SOFT              0x19BA
+#endif
+
+#ifndef ALC_SOFT_output_mode
+#define ALC_SOFT_output_mode
+#define ALC_OUTPUT_MODE_SOFT                     0x19AC
+#define ALC_ANY_SOFT                             0x19AD
+/*#define ALC_MONO_SOFT                            0x1500*/
+/*#define ALC_STEREO_SOFT                          0x1501*/
+#define ALC_STEREO_BASIC_SOFT                    0x19AE
+#define ALC_STEREO_UHJ_SOFT                      0x19AF
+#define ALC_STEREO_HRTF_SOFT                     0x19B2
+/*#define ALC_QUAD_SOFT                            0x1503*/
+#define ALC_SURROUND_5_1_SOFT                    0x1504
+#define ALC_SURROUND_6_1_SOFT                    0x1505
+#define ALC_SURROUND_7_1_SOFT                    0x1506
+#endif
+
+#ifndef AL_SOFT_source_start_delay
+#define AL_SOFT_source_start_delay
+typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMESOFT)(ALuint source, ALint64SOFT start_time);
+typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMEVSOFT)(ALsizei n, const ALuint *sources, ALint64SOFT start_time);
+#ifdef AL_ALEXT_PROTOTYPES
+void AL_APIENTRY alSourcePlayAtTimeSOFT(ALuint source, ALint64SOFT start_time);
+void AL_APIENTRY alSourcePlayAtTimevSOFT(ALsizei n, const ALuint *sources, ALint64SOFT start_time);
+#endif
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/AL/efx.h b/include/AL/efx.h
index 34085651..5ab64a64 100644
--- a/include/AL/efx.h
+++ b/include/AL/efx.h
@@ -243,41 +243,41 @@ typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*
 typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*);
 
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
-AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects);
+AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
+AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects);
 AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect);
-AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
-
-AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
-AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters);
+AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
+AL_API void AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues);
+AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
+AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues);
+AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
+AL_API void AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
+AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
+AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
+
+AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
+AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters);
 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter);
-AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
-
-AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
-AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots);
+AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
+AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues);
+AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
+AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues);
+AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
+AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
+AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
+AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
+
+AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
+AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots);
 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
+AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues);
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
 #endif
 
 /* Filter ranges and defaults. */
diff --git a/libopenal.version b/libopenal.version
new file mode 100644
index 00000000..dd998e14
--- /dev/null
+++ b/libopenal.version
@@ -0,0 +1,192 @@
+{
+global:
+alBuffer3f;
+alBuffer3i;
+alBufferData;
+alBufferf;
+alBufferfv;
+alBufferi;
+alBufferiv;
+alcCaptureCloseDevice;
+alcCaptureOpenDevice;
+alcCaptureSamples;
+alcCaptureStart;
+alcCaptureStop;
+alcCloseDevice;
+alcCreateContext;
+alcDestroyContext;
+alcGetContextsDevice;
+alcGetCurrentContext;
+alcGetEnumValue;
+alcGetError;
+alcGetIntegerv;
+alcGetProcAddress;
+alcGetString;
+alcIsExtensionPresent;
+alcMakeContextCurrent;
+alcOpenDevice;
+alcProcessContext;
+alcSuspendContext;
+alDeleteBuffers;
+alDeleteSources;
+alDisable;
+alDistanceModel;
+alDopplerFactor;
+alEnable;
+alGenBuffers;
+alGenSources;
+alGetBoolean;
+alGetBooleanv;
+alGetBuffer3f;
+alGetBuffer3i;
+alGetBufferf;
+alGetBufferfv;
+alGetBufferi;
+alGetBufferiv;
+alGetDouble;
+alGetDoublev;
+alGetEnumValue;
+alGetError;
+alGetFloat;
+alGetFloatv;
+alGetInteger;
+alGetIntegerv;
+alGetListener3f;
+alGetListener3i;
+alGetListenerf;
+alGetListenerfv;
+alGetListeneri;
+alGetListeneriv;
+alGetProcAddress;
+alGetSource3f;
+alGetSource3i;
+alGetSourcef;
+alGetSourcefv;
+alGetSourcei;
+alGetSourceiv;
+alGetString;
+alIsBuffer;
+alIsEnabled;
+alIsExtensionPresent;
+alIsSource;
+alListener3f;
+alListener3i;
+alListenerf;
+alListenerfv;
+alListeneri;
+alListeneriv;
+alSource3f;
+alSource3i;
+alSourcef;
+alSourcefv;
+alSourcei;
+alSourceiv;
+alSourcePause;
+alSourcePausev;
+alSourcePlay;
+alSourcePlayv;
+alSourceQueueBuffers;
+alSourceRewind;
+alSourceRewindv;
+alSourceStop;
+alSourceStopv;
+alSourceUnqueueBuffers;
+alSpeedOfSound;
+
+# Deprecated in AL 1.1, kept for compatibility.
+alDopplerVelocity;
+
+# EFX, effectively standard at this point.
+alAuxiliaryEffectSlotf;
+alAuxiliaryEffectSlotfv;
+alAuxiliaryEffectSloti;
+alAuxiliaryEffectSlotiv;
+alDeleteAuxiliaryEffectSlots;
+alDeleteEffects;
+alDeleteFilters;
+alEffectf;
+alEffectfv;
+alEffecti;
+alEffectiv;
+alFilterf;
+alFilterfv;
+alFilteri;
+alFilteriv;
+alGenAuxiliaryEffectSlots;
+alGenEffects;
+alGenFilters;
+alGetAuxiliaryEffectSlotf;
+alGetAuxiliaryEffectSlotfv;
+alGetAuxiliaryEffectSloti;
+alGetAuxiliaryEffectSlotiv;
+alGetEffectf;
+alGetEffectfv;
+alGetEffecti;
+alGetEffectiv;
+alGetFilterf;
+alGetFilterfv;
+alGetFilteri;
+alGetFilteriv;
+alIsAuxiliaryEffectSlot;
+alIsEffect;
+alIsFilter;
+
+# Non-standard
+alsoft_get_version;
+
+# These extension functions shouldn't be exported here, but they were exported
+# by mistake in previous releases, so need to stay for compatibility with apps
+# that may have directly linked to them. Remove them if it can be done without
+# breaking anything.
+alAuxiliaryEffectSlotPlaySOFT;
+alAuxiliaryEffectSlotPlayvSOFT;
+alAuxiliaryEffectSlotStopSOFT;
+alAuxiliaryEffectSlotStopvSOFT;
+alBufferCallbackSOFT;
+alBufferSamplesSOFT;
+alBufferStorageSOFT;
+alBufferSubDataSOFT;
+alBufferSubSamplesSOFT;
+alcDevicePauseSOFT;
+alcDeviceResumeSOFT;
+alcGetInteger64vSOFT;
+alcGetStringiSOFT;
+alcGetThreadContext;
+alcIsRenderFormatSupportedSOFT;
+alcLoopbackOpenDeviceSOFT;
+alcRenderSamplesSOFT;
+alcResetDeviceSOFT;
+alcSetThreadContext;
+alDeferUpdatesSOFT;
+alEventCallbackSOFT;
+alEventControlSOFT;
+alFlushMappedBufferSOFT;
+alGetBuffer3PtrSOFT;
+alGetBufferPtrSOFT;
+alGetBufferPtrvSOFT;
+alGetBufferSamplesSOFT;
+alGetInteger64SOFT;
+alGetInteger64vSOFT;
+alGetPointerSOFT;
+alGetPointervSOFT;
+alGetSource3dSOFT;
+alGetSource3i64SOFT;
+alGetSourcedSOFT;
+alGetSourcedvSOFT;
+alGetSourcei64SOFT;
+alGetSourcei64vSOFT;
+alGetStringiSOFT;
+alIsBufferFormatSupportedSOFT;
+alMapBufferSOFT;
+alProcessUpdatesSOFT;
+alSource3dSOFT;
+alSource3i64SOFT;
+alSourcedSOFT;
+alSourcedvSOFT;
+alSourcei64SOFT;
+alSourcei64vSOFT;
+alSourceQueueBufferLayersSOFT;
+alUnmapBufferSOFT;
+
+local: *;
+};
diff --git a/native-tools/CMakeLists.txt b/native-tools/CMakeLists.txt
deleted file mode 100644
index 5e816bba..00000000
--- a/native-tools/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-cmake_minimum_required(VERSION 3.0.2)
-
-project(native-tools)
-
-include(CheckLibraryExists)
-
-set(CPP_DEFS )
-if(WIN32)
-    set(CPP_DEFS ${CPP_DEFS} _WIN32)
-endif(WIN32)
-
-check_library_exists(m pow "" HAVE_LIBM)
-
-add_executable(bin2h bin2h.c)
-# Enforce no dressing for executable names, so the main script can find it
-set_target_properties(bin2h PROPERTIES OUTPUT_NAME bin2h)
-# Avoid configuration-dependent subdirectories while building with Visual Studio
-set_target_properties(bin2h PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}")
-set_target_properties(bin2h PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}")
-target_compile_definitions(bin2h PRIVATE ${CPP_DEFS})
-
-add_executable(bsincgen bsincgen.c)
-set_target_properties(bsincgen PROPERTIES OUTPUT_NAME bsincgen)
-set_target_properties(bsincgen PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}")
-set_target_properties(bsincgen PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}")
-target_compile_definitions(bsincgen PRIVATE ${CPP_DEFS})
-if(HAVE_LIBM)
-    target_link_libraries(bsincgen m)
-endif(HAVE_LIBM)
diff --git a/native-tools/bin2h.c b/native-tools/bin2h.c
deleted file mode 100644
index 92f2b8a5..00000000
--- a/native-tools/bin2h.c
+++ /dev/null
@@ -1,100 +0,0 @@
-
-#ifdef _MSC_VER
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-int main (int argc, char *argv[])
-{
-    char* input_name;
-    FILE* input_file;
-
-    char* output_name;
-    FILE* output_file;
-
-    char* variable_name;
-
-    if (4 != argc)
-    {
-        puts("Usage: bin2h [input] [output] [variable]");
-        return EXIT_FAILURE;
-    }
-
-    input_name = argv[1];
-    output_name = argv[2];
-    variable_name = argv[3];
-
-    input_file = fopen(input_name, "rb");
-
-    if (NULL == input_file)
-    {
-        printf("Could not open input file '%s': %s\n", input_name, strerror(errno));
-        return EXIT_FAILURE;
-    }
-
-    output_file = fopen(output_name, "w");
-
-    if (NULL == output_file)
-    {
-        printf("Could not open output file '%s': %s\n", output_name, strerror(errno));
-        return EXIT_FAILURE;
-    }
-
-    if (fprintf(output_file, "static const unsigned char %s[] = {", variable_name) < 0)
-    {
-        printf("Could not write to output file '%s': %s\n", output_name, strerror(ferror(output_file)));
-        return EXIT_FAILURE;
-    }
-
-    while (0 == feof(input_file))
-    {
-        unsigned char buffer[4096];
-        size_t i, count = fread(buffer, 1, sizeof(buffer), input_file);
-
-        if (sizeof(buffer) != count)
-        {
-            if (0 == feof(input_file) || 0 != ferror(input_file))
-            {
-                printf("Could not read from input file '%s': %s\n", input_name, strerror(ferror(input_file)));
-                return EXIT_FAILURE;
-            }
-        }
-
-        for (i = 0; i < count; ++i)
-        {
-            if ((i & 15) == 0)
-            {
-                if (fprintf(output_file, "\n  ") < 0)
-                {
-                    printf("Could not write to output file '%s': %s\n", output_name, strerror(ferror(output_file)));
-                    return EXIT_FAILURE;
-                }
-            }
-
-            if (fprintf(output_file, "0x%2.2x, ", buffer[i]) < 0)
-            {
-                printf("Could not write to output file '%s': %s\n", output_name, strerror(ferror(output_file)));
-                return EXIT_FAILURE;
-            }
-
-        }
-    }
-
-    if (fprintf(output_file, "\n};\n") < 0)
-    {
-        printf("Could not write to output file '%s': %s\n", output_name, strerror(ferror(output_file)));
-        return EXIT_FAILURE;
-    }
-
-    if (fclose(output_file) < 0)
-    {
-        printf("Could not close output file '%s': %s\n", output_name, strerror(ferror(output_file)));
-        return EXIT_FAILURE;
-    }
-
-    return EXIT_SUCCESS;
-}
diff --git a/native-tools/bsincgen.c b/native-tools/bsincgen.c
deleted file mode 100644
index 7e7a1fa3..00000000
--- a/native-tools/bsincgen.c
+++ /dev/null
@@ -1,366 +0,0 @@
-/*

- * Sinc interpolator coefficient and delta generator for the OpenAL Soft

- * cross platform audio library.

- *

- * Copyright (C) 2015 by Christopher Fitzgerald.

- *

- * 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 visit:  http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html

- *

- * --------------------------------------------------------------------------

- *

- * This is a modified version of the bandlimited windowed sinc interpolator

- * algorithm presented here:

- *

- *   Smith, J.O. "Windowed Sinc Interpolation", in

- *   Physical Audio Signal Processing,

- *   https://ccrma.stanford.edu/~jos/pasp/Windowed_Sinc_Interpolation.html,

- *   online book,

- *   accessed October 2012.

- */

-

-#define _UNICODE

-#include <stdio.h>

-#include <math.h>

-#include <string.h>

-#include <stdlib.h>

-

-#include "../common/win_main_utf8.h"

-

-

-#ifndef M_PI

-#define M_PI                         3.14159265358979323846

-#endif

-

-#if !(defined(_ISOC99_SOURCE) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L))

-#define log2(x)  (log(x) / log(2.0))

-#endif

-

-// The number of distinct scale and phase intervals within the filter table.

-// Must be the same as in alu.h!

-#define BSINC_SCALE_COUNT 16

-#define BSINC_PHASE_COUNT 32

-

-/* 48 points includes the doubling for downsampling, so the maximum number of

- * base sample points is 24, which is 23rd order.

- */

-#define BSINC_POINTS_MAX 48

-

-static double MinDouble(double a, double b)

-{ return (a <= b) ? a : b; }

-

-static double MaxDouble(double a, double b)

-{ return (a >= b) ? a : b; }

-

-/* NOTE: This is the normalized (instead of just sin(x)/x) cardinal sine

- *       function.

- *       2 f_t sinc(2 f_t x)

- *       f_t -- normalized transition frequency (0.5 is nyquist)

- *       x   -- sample index (-N to N)

- */

-static double Sinc(const double x)

-{

-    if(fabs(x) < 1e-15)

-        return 1.0;

-    return sin(M_PI * x) / (M_PI * x);

-}

-

-static double BesselI_0(const double x)

-{

-    double term, sum, last_sum, x2, y;

-    int i;

-

-    term = 1.0;

-    sum = 1.0;

-    x2 = x / 2.0;

-    i = 1;

-

-    do {

-        y = x2 / i;

-        i++;

-        last_sum = sum;

-        term *= y * y;

-        sum += term;

-    } while(sum != last_sum);

-

-    return sum;

-}

-

-/* NOTE: k is assumed normalized (-1 to 1)

- *       beta is equivalent to 2 alpha

- */

-static double Kaiser(const double b, const double k)

-{

-    if(!(k >= -1.0 && k <= 1.0))

-        return 0.0;

-    return BesselI_0(b * sqrt(1.0 - k*k)) / BesselI_0(b);

-}

-

-/* Calculates the (normalized frequency) transition width of the Kaiser window.

- * Rejection is in dB.

- */

-static double CalcKaiserWidth(const double rejection, const int order)

-{

-    double w_t = 2.0 * M_PI;

-

-    if(rejection > 21.0)

-       return (rejection - 7.95) / (order * 2.285 * w_t);

-    /* This enforces a minimum rejection of just above 21.18dB */

-    return 5.79 / (order * w_t);

-}

-

-static double CalcKaiserBeta(const double rejection)

-{

-    if(rejection > 50.0)

-       return 0.1102 * (rejection - 8.7);

-    else if(rejection >= 21.0)

-       return (0.5842 * pow(rejection - 21.0, 0.4)) +

-              (0.07886 * (rejection - 21.0));

-    return 0.0;

-}

-

-/* Generates the coefficient, delta, and index tables required by the bsinc resampler */

-static void BsiGenerateTables(FILE *output, const char *tabname, const double rejection, const int order)

-{

-    static double   filter[BSINC_SCALE_COUNT][BSINC_PHASE_COUNT + 1][BSINC_POINTS_MAX];

-    static double phDeltas[BSINC_SCALE_COUNT][BSINC_PHASE_COUNT + 1][BSINC_POINTS_MAX];

-    static double scDeltas[BSINC_SCALE_COUNT][BSINC_PHASE_COUNT    ][BSINC_POINTS_MAX];

-    static double spDeltas[BSINC_SCALE_COUNT][BSINC_PHASE_COUNT    ][BSINC_POINTS_MAX];

-    static int mt[BSINC_SCALE_COUNT];

-    static double at[BSINC_SCALE_COUNT];

-    const int num_points_min = order + 1;

-    double width, beta, scaleBase, scaleRange;

-    int si, pi, i;

-

-    memset(filter, 0, sizeof(filter));

-    memset(phDeltas, 0, sizeof(phDeltas));

-    memset(scDeltas, 0, sizeof(scDeltas));

-    memset(spDeltas, 0, sizeof(spDeltas));

-

-    /* Calculate windowing parameters.  The width describes the transition

-       band, but it may vary due to the linear interpolation between scales

-       of the filter.

-    */

-    width = CalcKaiserWidth(rejection, order);

-    beta = CalcKaiserBeta(rejection);

-    scaleBase = width / 2.0;

-    scaleRange = 1.0 - scaleBase;

-

-    // Determine filter scaling.

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-    {

-        const double scale = scaleBase + (scaleRange * si / (BSINC_SCALE_COUNT - 1));

-        const double a = MinDouble(floor(num_points_min / (2.0 * scale)), num_points_min);

-        const int m = 2 * (int)a;

-

-        mt[si] = m;

-        at[si] = a;

-    }

-

-    /* Calculate the Kaiser-windowed Sinc filter coefficients for each scale

-     * and phase.

-     */

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-    {

-        const int m = mt[si];

-        const int o = num_points_min - (m / 2);

-        const int l = (m / 2) - 1;

-        const double a = at[si];

-        const double scale = scaleBase + (scaleRange * si / (BSINC_SCALE_COUNT - 1));

-        const double cutoff = (0.5 * scale) - (scaleBase * MaxDouble(0.5, scale));

-

-        for(pi = 0; pi <= BSINC_PHASE_COUNT; pi++)

-        {

-            const double phase = l + ((double)pi / BSINC_PHASE_COUNT);

-

-            for(i = 0; i < m; i++)

-            {

-                const double x = i - phase;

-                filter[si][pi][o + i] = Kaiser(beta, x / a) * 2.0 * cutoff * Sinc(2.0 * cutoff * x);

-            }

-        }

-    }

-

-    /* Linear interpolation between phases is simplified by pre-calculating the

-     * delta (b - a) in: x = a + f (b - a)

-     */

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-    {

-        const int m = mt[si];

-        const int o = num_points_min - (m / 2);

-

-        for(pi = 0; pi < BSINC_PHASE_COUNT; pi++)

-        {

-            for(i = 0; i < m; i++)

-                phDeltas[si][pi][o + i] = filter[si][pi + 1][o + i] - filter[si][pi][o + i];

-        }

-    }

-

-    /* Linear interpolation between scales is also simplified.

-     *

-     * Given a difference in points between scales, the destination points will

-     * be 0, thus: x = a + f (-a)

-     */

-    for(si = 0; si < (BSINC_SCALE_COUNT - 1); si++)

-    {

-        const int m = mt[si];

-        const int o = num_points_min - (m / 2);

-

-        for(pi = 0; pi < BSINC_PHASE_COUNT; pi++)

-        {

-            for(i = 0; i < m; i++)

-                scDeltas[si][pi][o + i] = filter[si + 1][pi][o + i] - filter[si][pi][o + i];

-        }

-    }

-

-    /* This last simplification is done to complete the bilinear equation for

-     * the combination of phase and scale.

-     */

-    for(si = 0; si < (BSINC_SCALE_COUNT - 1); si++)

-    {

-        const int m = mt[si];

-        const int o = num_points_min - (m / 2);

-

-        for(pi = 0; pi < BSINC_PHASE_COUNT; pi++)

-        {

-            for(i = 0; i < m; i++)

-                spDeltas[si][pi][o + i] = phDeltas[si + 1][pi][o + i] - phDeltas[si][pi][o + i];

-        }

-    }

-

-    /* Make sure the number of points is a multiple of 4 (for SIMD). */

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-        mt[si] = (mt[si]+3) & ~3;

-

-    /* Calculate the table size. */

-    i = 0;

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-        i += 4 * BSINC_PHASE_COUNT * mt[si];

-

-    fprintf(output,

-"/* This %d%s order filter has a rejection of -%.0fdB, yielding a transition width\n"

-" * of ~%.3f (normalized frequency). Order increases when downsampling to a\n"

-" * limit of one octave, after which the quality of the filter (transition\n"

-" * width) suffers to reduce the CPU cost. The bandlimiting will cut all sound\n"

-" * after downsampling by ~%.2f octaves.\n"

-" */\n"

-"alignas(16) constexpr float %s_tab[%d] = {\n",

-            order, (((order%100)/10) == 1) ? "th" :

-                   ((order%10) == 1) ? "st" :

-                   ((order%10) == 2) ? "nd" :

-                   ((order%10) == 3) ? "rd" : "th",

-            rejection, width, log2(1.0/scaleBase), tabname, i);

-    for(si = 0; si < BSINC_SCALE_COUNT; si++)

-    {

-        const int m = mt[si];

-        const int o = num_points_min - (m / 2);

-

-        for(pi = 0; pi < BSINC_PHASE_COUNT; pi++)

-        {

-            fprintf(output, "    /* %2d,%2d (%d) */", si, pi, m);

-            fprintf(output, "\n   ");

-            for(i = 0; i < m; i++)

-                fprintf(output, " %+14.9ef,", filter[si][pi][o + i]);

-            fprintf(output, "\n   ");

-            for(i = 0; i < m; i++)

-                fprintf(output, " %+14.9ef,", phDeltas[si][pi][o + i]);

-            fprintf(output, "\n   ");

-            for(i = 0; i < m; i++)

-                fprintf(output, " %+14.9ef,", scDeltas[si][pi][o + i]);

-            fprintf(output, "\n   ");

-            for(i = 0; i < m; i++)

-                fprintf(output, " %+14.9ef,", spDeltas[si][pi][o + i]);

-            fprintf(output, "\n");

-        }

-    }

-    fprintf(output, "};\nconstexpr BSincTable %s = {\n", tabname);

-

-    /* The scaleBase is calculated from the Kaiser window transition width.

-       It represents the absolute limit to the filter before it fully cuts

-       the signal.  The limit in octaves can be calculated by taking the

-       base-2 logarithm of its inverse: log_2(1 / scaleBase)

-    */

-    fprintf(output, "    /* scaleBase */ %.9ef, /* scaleRange */ %.9ef,\n", scaleBase, 1.0 / scaleRange);

-

-    fprintf(output, "    /* m */ {");

-    fprintf(output, " %du", mt[0]);

-    for(si = 1; si < BSINC_SCALE_COUNT; si++)

-        fprintf(output, ", %du", mt[si]);

-    fprintf(output, " },\n");

-

-    fprintf(output, "    /* filterOffset */ {");

-    fprintf(output, " %du", 0);

-    i = mt[0]*4*BSINC_PHASE_COUNT;

-    for(si = 1; si < BSINC_SCALE_COUNT; si++)

-    {

-        fprintf(output, ", %du", i);

-        i += mt[si]*4*BSINC_PHASE_COUNT;

-    }

-

-    fprintf(output, " },\n");

-    fprintf(output, "    %s_tab\n", tabname);

-    fprintf(output, "};\n\n");

-}

-

-

-int main(int argc, char *argv[])

-{

-    FILE *output;

-

-    GET_UNICODE_ARGS(&argc, &argv);

-

-    if(argc > 2)

-    {

-        fprintf(stderr, "Usage: %s [output file]\n", argv[0]);

-        return 1;

-    }

-

-    if(argc == 2)

-    {

-        output = fopen(argv[1], "wb");

-        if(!output)

-        {

-            fprintf(stderr, "Failed to open %s for writing\n", argv[1]);

-            return 1;

-        }

-    }

-    else

-        output = stdout;

-

-    fprintf(output, "/* Generated by bsincgen, do not edit! */\n"

-"#pragma once\n\n"

-"static_assert(BSINC_SCALE_COUNT == %d, \"Unexpected BSINC_SCALE_COUNT value!\");\n"

-"static_assert(BSINC_PHASE_COUNT == %d, \"Unexpected BSINC_PHASE_COUNT value!\");\n\n"

-"namespace {\n\n"

-"struct BSincTable {\n"

-"    const float scaleBase, scaleRange;\n"

-"    const unsigned int m[BSINC_SCALE_COUNT];\n"

-"    const unsigned int filterOffset[BSINC_SCALE_COUNT];\n"

-"    const float *Tab;\n"

-"};\n\n", BSINC_SCALE_COUNT, BSINC_PHASE_COUNT);

-    /* A 23rd order filter with a -60dB drop at nyquist. */

-    BsiGenerateTables(output, "bsinc24", 60.0, 23);

-    /* An 11th order filter with a -60dB drop at nyquist. */

-    BsiGenerateTables(output, "bsinc12", 60.0, 11);

-

-    fprintf(output, "} // namespace\n");

-    if(output != stdout)

-        fclose(output);

-    output = NULL;

-

-    return 0;

-}

diff --git a/presets/3D7.1.ambdec b/presets/3D7.1.ambdec
index 42b6a0bb..ec3b787d 100644
--- a/presets/3D7.1.ambdec
+++ b/presets/3D7.1.ambdec
@@ -1,43 +1,66 @@
 # AmbDec configuration
 # Written by Ambisonic Decoder Toolbox, version 8.0
 
-/description     3D7_2h1v_allrad_5200_rE_max_1_band
+# input channel order: W Y Z X
+
+/description     3D7-noCenter_1h1v_pinv_even_energy_rV_max_rE_2_band
+
+# In OpenAL Soft, 3D7.1 is a distinct configuration that uses the standard 5.1
+# channels (LF, RF, CE, LS, RS), plus two auxiliary channels (AUX0, AUX1) in
+# place of the rear speakers. AUX0 corresponds to the LB speaker (upper back
+# center), and AUX1 corresponds to the RB speaker (lower front center).
+
+# Similar to the the ITU-5.1-nocenter configuration, the front-center is
+# declared here so that an appropriate distance may be set (for proper delaying
+# or attenuating of dialog and such which feed it directly). It otherwise does
+# not contribute to positional sound output due to its irregular position.
 
 /version         	3
 
-/dec/chan_mask   	1bf
-/dec/freq_bands  	1
-/dec/speakers    	7
-/dec/coeff_scale 	fuma
+/dec/chan_mask   	f
+/dec/freq_bands  	2
+/dec/speakers    	6
+/dec/coeff_scale 	n3d
 
-/opt/input_scale  	fuma
-/opt/nfeff_comp   	output
+/opt/input_scale  	n3d
+/opt/nfeff_comp   	input
 /opt/delay_comp   	on
 /opt/level_comp   	on
 /opt/xover_freq   	400.000000
 /opt/xover_ratio  	0.000000
 
 /speakers/{
-#           id     dist          azim       elev     conn
+#       	id  	 dist    	 azim      	 elev     	conn
 #-----------------------------------------------------------------------
-add_spkr 	LF	 1.500000	  51.000000	 24.000000
-add_spkr 	RF	 1.500000	 -51.000000	 24.000000
-add_spkr 	CE	 1.500000	   0.000000	  0.000000
-add_spkr 	LB	 1.500000	 180.000000	 55.000000
-add_spkr 	RB	 1.500000	   0.000000	-55.000000
-add_spkr 	LS	 1.500000	 129.000000	-24.000000
-add_spkr 	RS	 1.500000	-129.000000	-24.000000
+add_spkr 	LF  	 1.828800	  51.000000	 24.000000
+add_spkr 	RF  	 1.828800	 -51.000000	 24.000000
+add_spkr 	CE  	 1.828800	   0.000000	  0.000000
+add_spkr 	AUX0	 1.828800	 180.000000	 55.000000
+add_spkr 	AUX1	 1.828800	   0.000000	-55.000000
+add_spkr 	LS  	 1.828800	 129.000000	-24.000000
+add_spkr 	RS  	 1.828800	-129.000000	-24.000000
+/}
+
+/lfmatrix/{
+order_gain	1.00000000e+00	1.00000000e+00	0.000000	0.000000
+add_row 	 1.666666667e-01  2.033043281e-01  1.175581508e-01  1.678904388e-01
+add_row 	 1.666666667e-01 -2.033043281e-01  1.175581508e-01  1.678904388e-01
+add_row 	 0.000000000e+00  0.000000000e+00  0.000000000e+00  0.000000000e+00
+add_row 	 1.666666667e-01  0.000000000e+00  2.356640879e-01 -1.667265410e-01
+add_row 	 1.666666667e-01  0.000000000e+00 -2.356640879e-01  1.667265410e-01
+add_row 	 1.666666667e-01  2.033043281e-01 -1.175581508e-01 -1.678904388e-01
+add_row 	 1.666666667e-01 -2.033043281e-01 -1.175581508e-01 -1.678904388e-01
 /}
 
-/matrix/{
-order_gain	1.000000	0.774597	0.400000	0.000000
-add_row 	 0.325031	 0.357638	 0.206500	 0.234037	 0.202440	 0.135692	 0.116927	-0.098768
-add_row 	 0.325036	-0.357619	 0.206537	 0.234033	-0.202427	-0.135680	 0.116934	-0.098768
-add_row 	 0.080073	-0.000010	-0.000296	 0.155843	-0.000016	-0.000011	-0.000623	 0.163306
-add_row 	 0.353556	 0.000002	 0.408453	-0.288377	-0.000004	-0.000003	-0.221039	 0.077297
-add_row 	 0.325297	 0.000008	-0.414018	 0.232789	 0.000004	 0.000003	-0.232940	 0.018311
-add_row 	 0.353558	 0.352704	-0.203542	-0.290124	-0.191868	-0.134582	 0.110616	-0.038294
-add_row 	 0.353556	-0.352691	-0.203576	-0.290115	 0.191871	 0.134585	 0.110612	-0.038293
+/hfmatrix/{
+order_gain	1.73205081e+00	1.00000000e+00	0.000000	0.000000
+add_row 	 1.666666667e-01  2.033043281e-01  1.175581508e-01  1.678904388e-01
+add_row 	 1.666666667e-01 -2.033043281e-01  1.175581508e-01  1.678904388e-01
+add_row 	 0.000000000e+00  0.000000000e+00  0.000000000e+00  0.000000000e+00
+add_row 	 1.666666667e-01  0.000000000e+00  2.356640879e-01 -1.667265410e-01
+add_row 	 1.666666667e-01  0.000000000e+00 -2.356640879e-01  1.667265410e-01
+add_row 	 1.666666667e-01  2.033043281e-01 -1.175581508e-01 -1.678904388e-01
+add_row 	 1.666666667e-01 -2.033043281e-01 -1.175581508e-01 -1.678904388e-01
 /}
 
 /end
diff --git a/presets/hex-quad.ambdec b/presets/hex-quad.ambdec
new file mode 100644
index 00000000..ce6cf8bf
--- /dev/null
+++ b/presets/hex-quad.ambdec
@@ -0,0 +1,53 @@
+# AmbDec configuration
+# Written by Ambisonic Decoder Toolbox, version 8.0
+
+# input channel order: W Y Z X 
+
+/description     11_1_1h1v_allrad_5200_rE_max_1_band
+
+/version         	3
+
+/dec/chan_mask   	f
+/dec/freq_bands  	1
+/dec/speakers    	11
+/dec/coeff_scale 	n3d
+
+/opt/input_scale  	n3d
+/opt/nfeff_comp   	output
+/opt/delay_comp   	on
+/opt/level_comp   	on
+/opt/xover_freq   	400.000000
+/opt/xover_ratio  	0.000000
+
+/speakers/{
+#       	id	 dist    	 azim      	 elev     	conn
+#-----------------------------------------------------------------------
+add_spkr 	LF	 1.000000	  30.000000	  0.000000
+add_spkr 	RF	 1.000000	 -30.000000	  0.000000
+add_spkr 	CE	 1.000000	   0.000000	  0.000000
+add_spkr 	LS	 1.000000	  90.000000	  0.000000
+add_spkr 	RS	 1.000000	 -90.000000	  0.000000
+add_spkr 	LB	 1.000000	 150.000000	  0.000000
+add_spkr 	RB	 1.000000	-150.000000	  0.000000
+add_spkr 	LFT	 1.000000	  45.000000	 35.000000
+add_spkr 	RFT	 1.000000	 -45.000000	 35.000000
+add_spkr 	LBT	 1.000000	 135.000000	 35.000000
+add_spkr 	RBT	 1.000000	-135.000000	 35.000000
+/}
+
+/matrix/{
+order_gain	1.00000000e+00	1.00000000e+00	0.000000	0.000000
+add_row 	 1.27149251e-01  7.63047539e-02 -3.64373750e-02  1.59700680e-01
+add_row 	 1.07005418e-01 -7.67638760e-02 -4.92129762e-02  1.29012797e-01
+add_row 	 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+add_row 	 1.26400196e-01  1.77494694e-01 -3.71203389e-02  0.00000000e+00
+add_row 	 1.26396516e-01 -1.77488059e-01 -3.71297878e-02  0.00000000e+00
+add_row 	 1.06996956e-01  7.67615256e-02 -4.92166307e-02 -1.29001640e-01
+add_row 	 1.27145671e-01 -7.63003471e-02 -3.64353304e-02 -1.59697510e-01
+add_row 	 8.80919747e-02  7.48940670e-02  9.08786244e-02  6.22527183e-02
+add_row 	 1.57880745e-01 -7.28755272e-02  1.82364187e-01  8.74240284e-02
+add_row 	 1.57892225e-01  7.28944768e-02  1.82363474e-01 -8.74301086e-02
+add_row 	 8.80892603e-02 -7.48948724e-02  9.08779842e-02 -6.22480443e-02
+/}
+
+/end
diff --git a/presets/itu5.1.ambdec b/presets/itu5.1.ambdec
index 74386034..8f4b14e1 100644
--- a/presets/itu5.1.ambdec
+++ b/presets/itu5.1.ambdec
@@ -1,7 +1,6 @@
 # AmbDec configuration
-# Written by Ambisonic Decoder Toolbox, version 8.0
 
-/description     itu50_2h0p_allrad_5200_rE_max_1_band
+/description     itu50_2h0p_idhoa
 
 /version         	3
 
@@ -15,7 +14,7 @@
 /opt/delay_comp   	on
 /opt/level_comp   	on
 /opt/xover_freq   	400.000000
-/opt/xover_ratio  	3.000000
+/opt/xover_ratio  	0.000000
 
 /speakers/{
 #           id     dist         azim       elev     conn
@@ -29,20 +28,20 @@ add_spkr 	RS	 1.000000	-110.000000	 0.000000
 
 /lfmatrix/{
 order_gain	1.000000	1.000000	1.000000	0.000000
-add_row 	 0.420330	 0.330200	-0.312250	 0.019350	-0.027010
-add_row 	 0.197700	 0.288820	 0.287820	 0.049110	 0.007420
-add_row 	 0.058030	 0.000000	 0.205970	 0.000000	 0.050790
-add_row 	 0.197700	-0.288820	 0.287820	-0.049110	 0.007420
-add_row 	 0.420330	-0.330200	-0.312250	-0.019350	-0.027010
+add_row 	 4.9010985e-1  3.7730501e-1 -3.7310699e-1 -1.2591453e-1  1.4513300e-2
+add_row 	 1.4908573e-1  3.0356168e-1  1.5329006e-1  2.4511248e-1 -1.5075313e-1
+add_row 	 1.3765492e-1  0.0000000e+0  4.4941794e-1  0.0000000e+0  2.5784407e-1
+add_row 	 1.4908573e-1 -3.0356168e-1  1.5329006e-1 -2.4511248e-1 -1.5075313e-1
+add_row 	 4.9010985e-1 -3.7730501e-1 -3.7310699e-1  1.2591453e-1  1.4513300e-2
 /}
 
 /hfmatrix/{
-order_gain	1.000000	0.866025	0.500000	0.000000
-add_row 	 0.470934	 0.378170	-0.400085	-0.082226	-0.044377
-add_row 	 0.208954	 0.257988	 0.230383	 0.288520	-0.025085
-add_row 	 0.109403	-0.000002	 0.194278	-0.000003	 0.200863
-add_row 	 0.208950	-0.257989	 0.230379	-0.288516	-0.025088
-add_row 	 0.470936	-0.378173	-0.400081	 0.082228	-0.044372
+order_gain	1.000000	1.000000	1.000000	0.000000
+add_row 	 5.6731600e-1  4.2292000e-1 -3.1549500e-1 -6.3449000e-2 -2.9238000e-2
+add_row 	 3.6858400e-1  2.7234900e-1  3.2161600e-1  1.9264500e-1  4.8260000e-2
+add_row 	 1.8357900e-1  0.0000000e+0  1.9958800e-1  0.0000000e+0  9.6282000e-2
+add_row 	 3.6858400e-1 -2.7234900e-1  3.2161600e-1 -1.9264500e-1  4.8260000e-2
+add_row 	 5.6731600e-1 -4.2292000e-1 -3.1549500e-1  6.3449000e-2 -2.9238000e-2
 /}
 
 /end
diff --git a/presets/presets.txt b/presets/presets.txt
index 541416e2..f75a53e9 100644
--- a/presets/presets.txt
+++ b/presets/presets.txt
@@ -36,7 +36,19 @@ is defined for the decoder, meaning that speaker will be silent for 3D sound
 output). A "proper" 7.1 decoder may be provided in the future, but due to the
 nature of the speaker configuration will have trade-offs.
 
+hex-quad.ambdec
+Specifies a flat-front hexagonal speaker setup, plus an elevated quad speaker
+setup, for 7.1.4 Surround output. The front left and right speakers are placed
+at +30 and -30 degrees, the side speakers are placed at +90 and -90 degrees,
+and the back speakers are placed at +150 and -150 degrees. The elevated
+speakers are placed at an elevation of +35 degrees, with the top front left and
+right speakers placed at +45 and -45 degrees, and the top back left and right
+speakers placed at +135 and -135 degrees. Similar to 7.1, the front-center
+speaker is not used for 3D sound, but will be used as appropriate with
+AL_SOFT_direct_channels or ALC_EXT_DEDICATED.
+
 3D7.1.ambdec
-Specifies a 3D7.1 speaker setup for 7.1 Surround output. Although it's for 7.1
-output, the speakers for such a configuration need to be placed in different
-positions for proper results. Please see docs/3D7.1.txt for more information.
+Specifies a 3D7.1 speaker setup for 3D7.1 Surround output. Please see
+docs/3D7.1.txt for information about speaker placement. Similar to 7.1, the
+front-center speaker is not used for 3D sound, but will be used as appropriate
+with AL_SOFT_direct_channels or ALC_EXT_DEDICATED.
diff --git a/router/al.cpp b/router/al.cpp
index 4c8b0006..06c314eb 100644
--- a/router/al.cpp
+++ b/router/al.cpp
@@ -11,31 +11,31 @@ std::atomic<DriverIface*> CurrentCtxDriver{nullptr};
 
 #define DECL_THUNK1(R,n,T1) AL_API R AL_APIENTRY n(T1 a)                      \
 {                                                                             \
-    DriverIface *iface = ThreadCtxDriver;                                     \
+    DriverIface *iface = GetThreadDriver();                                   \
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);      \
     return iface->n(a);                                                       \
 }
 #define DECL_THUNK2(R,n,T1,T2) AL_API R AL_APIENTRY n(T1 a, T2 b) \
 {                                                                             \
-    DriverIface *iface = ThreadCtxDriver;                                     \
+    DriverIface *iface = GetThreadDriver();                                   \
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);      \
     return iface->n(a, b);                                                    \
 }
 #define DECL_THUNK3(R,n,T1,T2,T3) AL_API R AL_APIENTRY n(T1 a, T2 b, T3 c) \
 {                                                                             \
-    DriverIface *iface = ThreadCtxDriver;                                     \
+    DriverIface *iface = GetThreadDriver();                                   \
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);      \
     return iface->n(a, b, c);                                                 \
 }
 #define DECL_THUNK4(R,n,T1,T2,T3,T4) AL_API R AL_APIENTRY n(T1 a, T2 b, T3 c, T4 d) \
 {                                                                             \
-    DriverIface *iface = ThreadCtxDriver;                                     \
+    DriverIface *iface = GetThreadDriver();                                   \
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);      \
     return iface->n(a, b, c, d);                                              \
 }
 #define DECL_THUNK5(R,n,T1,T2,T3,T4,T5) AL_API R AL_APIENTRY n(T1 a, T2 b, T3 c, T4 d, T5 e) \
 {                                                                             \
-    DriverIface *iface = ThreadCtxDriver;                                     \
+    DriverIface *iface = GetThreadDriver();                                   \
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);      \
     return iface->n(a, b, c, d, e);                                           \
 }
@@ -46,7 +46,7 @@ std::atomic<DriverIface*> CurrentCtxDriver{nullptr};
  */
 AL_API ALenum AL_APIENTRY alGetError(void)
 {
-    DriverIface *iface = ThreadCtxDriver;
+    DriverIface *iface = GetThreadDriver();
     if(!iface) iface = CurrentCtxDriver.load(std::memory_order_acquire);
     return iface ? iface->alGetError() : AL_NO_ERROR;
 }
@@ -130,3 +130,42 @@ DECL_THUNK3(void, alGetBufferi, ALuint, ALenum, ALint*)
 DECL_THUNK5(void, alGetBuffer3i, ALuint, ALenum, ALint*, ALint*, ALint*)
 DECL_THUNK3(void, alGetBufferiv, ALuint, ALenum, ALint*)
 DECL_THUNK5(void, alBufferData, ALuint, ALenum, const ALvoid*, ALsizei, ALsizei)
+
+/* EFX 1.0. Required here to be exported from libOpenAL32.dll.a/OpenAL32.lib
+ * with the router enabled.
+ */
+DECL_THUNK2(void, alGenFilters, ALsizei, ALuint*)
+DECL_THUNK2(void, alDeleteFilters, ALsizei, const ALuint*)
+DECL_THUNK1(ALboolean, alIsFilter, ALuint)
+DECL_THUNK3(void, alFilterf, ALuint, ALenum, ALfloat)
+DECL_THUNK3(void, alFilterfv, ALuint, ALenum, const ALfloat*)
+DECL_THUNK3(void, alFilteri, ALuint, ALenum, ALint)
+DECL_THUNK3(void, alFilteriv, ALuint, ALenum, const ALint*)
+DECL_THUNK3(void, alGetFilterf, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetFilterfv, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetFilteri, ALuint, ALenum, ALint*)
+DECL_THUNK3(void, alGetFilteriv, ALuint, ALenum, ALint*)
+
+DECL_THUNK2(void, alGenEffects, ALsizei, ALuint*)
+DECL_THUNK2(void, alDeleteEffects, ALsizei, const ALuint*)
+DECL_THUNK1(ALboolean, alIsEffect, ALuint)
+DECL_THUNK3(void, alEffectf, ALuint, ALenum, ALfloat)
+DECL_THUNK3(void, alEffectfv, ALuint, ALenum, const ALfloat*)
+DECL_THUNK3(void, alEffecti, ALuint, ALenum, ALint)
+DECL_THUNK3(void, alEffectiv, ALuint, ALenum, const ALint*)
+DECL_THUNK3(void, alGetEffectf, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetEffectfv, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetEffecti, ALuint, ALenum, ALint*)
+DECL_THUNK3(void, alGetEffectiv, ALuint, ALenum, ALint*)
+
+DECL_THUNK2(void, alGenAuxiliaryEffectSlots, ALsizei, ALuint*)
+DECL_THUNK2(void, alDeleteAuxiliaryEffectSlots, ALsizei, const ALuint*)
+DECL_THUNK1(ALboolean, alIsAuxiliaryEffectSlot, ALuint)
+DECL_THUNK3(void, alAuxiliaryEffectSlotf, ALuint, ALenum, ALfloat)
+DECL_THUNK3(void, alAuxiliaryEffectSlotfv, ALuint, ALenum, const ALfloat*)
+DECL_THUNK3(void, alAuxiliaryEffectSloti, ALuint, ALenum, ALint)
+DECL_THUNK3(void, alAuxiliaryEffectSlotiv, ALuint, ALenum, const ALint*)
+DECL_THUNK3(void, alGetAuxiliaryEffectSlotf, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetAuxiliaryEffectSlotfv, ALuint, ALenum, ALfloat*)
+DECL_THUNK3(void, alGetAuxiliaryEffectSloti, ALuint, ALenum, ALint*)
+DECL_THUNK3(void, alGetAuxiliaryEffectSlotiv, ALuint, ALenum, ALint*)
diff --git a/router/alc.cpp b/router/alc.cpp
index c99e7c93..3aa3382b 100644
--- a/router/alc.cpp
+++ b/router/alc.cpp
@@ -17,10 +17,10 @@
 
 #define DECL(x) { #x, reinterpret_cast<void*>(x) }
 struct FuncExportEntry {
-    const ALCchar *funcName;
-    ALCvoid *address;
+    const char *funcName;
+    void *address;
 };
-static const std::array<FuncExportEntry,95> alcFunctions{{
+static const std::array<FuncExportEntry,128> alcFunctions{{
     DECL(alcCreateContext),
     DECL(alcMakeContextCurrent),
     DECL(alcProcessContext),
@@ -118,6 +118,41 @@ static const std::array<FuncExportEntry,95> alcFunctions{{
     DECL(alDopplerVelocity),
     DECL(alSpeedOfSound),
     DECL(alDistanceModel),
+
+    /* EFX 1.0 */
+    DECL(alGenFilters),
+    DECL(alDeleteFilters),
+    DECL(alIsFilter),
+    DECL(alFilterf),
+    DECL(alFilterfv),
+    DECL(alFilteri),
+    DECL(alFilteriv),
+    DECL(alGetFilterf),
+    DECL(alGetFilterfv),
+    DECL(alGetFilteri),
+    DECL(alGetFilteriv),
+    DECL(alGenEffects),
+    DECL(alDeleteEffects),
+    DECL(alIsEffect),
+    DECL(alEffectf),
+    DECL(alEffectfv),
+    DECL(alEffecti),
+    DECL(alEffectiv),
+    DECL(alGetEffectf),
+    DECL(alGetEffectfv),
+    DECL(alGetEffecti),
+    DECL(alGetEffectiv),
+    DECL(alGenAuxiliaryEffectSlots),
+    DECL(alDeleteAuxiliaryEffectSlots),
+    DECL(alIsAuxiliaryEffectSlot),
+    DECL(alAuxiliaryEffectSlotf),
+    DECL(alAuxiliaryEffectSlotfv),
+    DECL(alAuxiliaryEffectSloti),
+    DECL(alAuxiliaryEffectSlotiv),
+    DECL(alGetAuxiliaryEffectSlotf),
+    DECL(alGetAuxiliaryEffectSlotfv),
+    DECL(alGetAuxiliaryEffectSloti),
+    DECL(alGetAuxiliaryEffectSlotiv),
 }};
 #undef DECL
 
@@ -249,7 +284,7 @@ static const ALCint alcMajorVersion = 1;
 static const ALCint alcMinorVersion = 1;
 
 
-static std::mutex EnumerationLock;
+static std::recursive_mutex EnumerationLock;
 static std::mutex ContextSwitchLock;
 
 static std::atomic<ALCenum> LastError{ALC_NO_ERROR};
@@ -309,6 +344,56 @@ static ALint GetDriverIndexForName(const EnumeratedList *list, const ALCchar *na
 }
 
 
+static void InitCtxFuncs(DriverIface &iface)
+{
+    ALCdevice *device{iface.alcGetContextsDevice(iface.alcGetCurrentContext())};
+
+#define LOAD_PROC(x) do {                                                     \
+    iface.x = reinterpret_cast<decltype(iface.x)>(iface.alGetProcAddress(#x));\
+    if(!iface.x)                                                              \
+        ERR("Failed to find entry point for %s in %ls\n", #x,                 \
+            iface.Name.c_str());                                              \
+} while(0)
+    if(iface.alcIsExtensionPresent(device, "ALC_EXT_EFX"))
+    {
+        LOAD_PROC(alGenFilters);
+        LOAD_PROC(alDeleteFilters);
+        LOAD_PROC(alIsFilter);
+        LOAD_PROC(alFilterf);
+        LOAD_PROC(alFilterfv);
+        LOAD_PROC(alFilteri);
+        LOAD_PROC(alFilteriv);
+        LOAD_PROC(alGetFilterf);
+        LOAD_PROC(alGetFilterfv);
+        LOAD_PROC(alGetFilteri);
+        LOAD_PROC(alGetFilteriv);
+        LOAD_PROC(alGenEffects);
+        LOAD_PROC(alDeleteEffects);
+        LOAD_PROC(alIsEffect);
+        LOAD_PROC(alEffectf);
+        LOAD_PROC(alEffectfv);
+        LOAD_PROC(alEffecti);
+        LOAD_PROC(alEffectiv);
+        LOAD_PROC(alGetEffectf);
+        LOAD_PROC(alGetEffectfv);
+        LOAD_PROC(alGetEffecti);
+        LOAD_PROC(alGetEffectiv);
+        LOAD_PROC(alGenAuxiliaryEffectSlots);
+        LOAD_PROC(alDeleteAuxiliaryEffectSlots);
+        LOAD_PROC(alIsAuxiliaryEffectSlot);
+        LOAD_PROC(alAuxiliaryEffectSlotf);
+        LOAD_PROC(alAuxiliaryEffectSlotfv);
+        LOAD_PROC(alAuxiliaryEffectSloti);
+        LOAD_PROC(alAuxiliaryEffectSlotiv);
+        LOAD_PROC(alGetAuxiliaryEffectSlotf);
+        LOAD_PROC(alGetAuxiliaryEffectSlotfv);
+        LOAD_PROC(alGetAuxiliaryEffectSloti);
+        LOAD_PROC(alGetAuxiliaryEffectSlotiv);
+    }
+#undef LOAD_PROC
+}
+
+
 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename)
 {
     ALCdevice *device = nullptr;
@@ -325,7 +410,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename)
         devicename = nullptr;
     if(devicename)
     {
-        { std::lock_guard<std::mutex> _{EnumerationLock};
+        {
+            std::lock_guard<std::recursive_mutex> _{EnumerationLock};
             if(DevicesList.Names.empty())
                 (void)alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
             idx = GetDriverIndexForName(&DevicesList, devicename);
@@ -344,17 +430,17 @@ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename)
             return nullptr;
         }
         TRACE("Found driver %d for name \"%s\"\n", idx, devicename);
-        device = DriverList[idx].alcOpenDevice(devicename);
+        device = DriverList[idx]->alcOpenDevice(devicename);
     }
     else
     {
         for(const auto &drv : DriverList)
         {
-            if(drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-               drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
             {
                 TRACE("Using default device from driver %d\n", idx);
-                device = drv.alcOpenDevice(nullptr);
+                device = drv->alcOpenDevice(nullptr);
                 break;
             }
             ++idx;
@@ -365,7 +451,7 @@ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename)
     {
         if(DeviceIfaceMap.insert(device, idx) != ALC_NO_ERROR)
         {
-            DriverList[idx].alcCloseDevice(device);
+            DriverList[idx]->alcCloseDevice(device);
             device = nullptr;
         }
     }
@@ -382,7 +468,7 @@ ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
         LastError.store(ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
-    if(!DriverList[idx].alcCloseDevice(device))
+    if(!DriverList[idx]->alcCloseDevice(device))
         return ALC_FALSE;
     DeviceIfaceMap.removeByKey(device);
     return ALC_TRUE;
@@ -399,12 +485,12 @@ ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCin
         LastError.store(ALC_INVALID_DEVICE);
         return nullptr;
     }
-    context = DriverList[idx].alcCreateContext(device, attrlist);
+    context = DriverList[idx]->alcCreateContext(device, attrlist);
     if(context)
     {
         if(ContextIfaceMap.insert(context, idx) != ALC_NO_ERROR)
         {
-            DriverList[idx].alcDestroyContext(context);
+            DriverList[idx]->alcDestroyContext(context);
             context = nullptr;
         }
     }
@@ -425,8 +511,11 @@ ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
             LastError.store(ALC_INVALID_CONTEXT);
             return ALC_FALSE;
         }
-        if(!DriverList[idx].alcMakeContextCurrent(context))
+        if(!DriverList[idx]->alcMakeContextCurrent(context))
             return ALC_FALSE;
+
+        auto do_init = [idx]() { InitCtxFuncs(*DriverList[idx]); };
+        std::call_once(DriverList[idx]->InitOnceCtx, do_init);
     }
 
     /* Unset the context from the old driver if it's different from the new
@@ -434,21 +523,21 @@ ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
      */
     if(idx < 0)
     {
-        DriverIface *oldiface = ThreadCtxDriver;
+        DriverIface *oldiface = GetThreadDriver();
         if(oldiface) oldiface->alcSetThreadContext(nullptr);
         oldiface = CurrentCtxDriver.exchange(nullptr);
         if(oldiface) oldiface->alcMakeContextCurrent(nullptr);
     }
     else
     {
-        DriverIface *oldiface = ThreadCtxDriver;
-        if(oldiface && oldiface != &DriverList[idx])
+        DriverIface *oldiface = GetThreadDriver();
+        if(oldiface && oldiface != DriverList[idx].get())
             oldiface->alcSetThreadContext(nullptr);
-        oldiface = CurrentCtxDriver.exchange(&DriverList[idx]);
-        if(oldiface && oldiface != &DriverList[idx])
+        oldiface = CurrentCtxDriver.exchange(DriverList[idx].get());
+        if(oldiface && oldiface != DriverList[idx].get())
             oldiface->alcMakeContextCurrent(nullptr);
     }
-    ThreadCtxDriver = nullptr;
+    SetThreadDriver(nullptr);
 
     return ALC_TRUE;
 }
@@ -459,7 +548,7 @@ ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context)
     {
         ALint idx = ContextIfaceMap.lookupByKey(context);
         if(idx >= 0)
-            return DriverList[idx].alcProcessContext(context);
+            return DriverList[idx]->alcProcessContext(context);
     }
     LastError.store(ALC_INVALID_CONTEXT);
 }
@@ -470,7 +559,7 @@ ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context)
     {
         ALint idx = ContextIfaceMap.lookupByKey(context);
         if(idx >= 0)
-            return DriverList[idx].alcSuspendContext(context);
+            return DriverList[idx]->alcSuspendContext(context);
     }
     LastError.store(ALC_INVALID_CONTEXT);
 }
@@ -485,13 +574,13 @@ ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context)
         return;
     }
 
-    DriverList[idx].alcDestroyContext(context);
+    DriverList[idx]->alcDestroyContext(context);
     ContextIfaceMap.removeByKey(context);
 }
 
 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
 {
-    DriverIface *iface = ThreadCtxDriver;
+    DriverIface *iface = GetThreadDriver();
     if(!iface) iface = CurrentCtxDriver.load();
     return iface ? iface->alcGetCurrentContext() : nullptr;
 }
@@ -502,7 +591,7 @@ ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context)
     {
         ALint idx = ContextIfaceMap.lookupByKey(context);
         if(idx >= 0)
-            return DriverList[idx].alcGetContextsDevice(context);
+            return DriverList[idx]->alcGetContextsDevice(context);
     }
     LastError.store(ALC_INVALID_CONTEXT);
     return nullptr;
@@ -515,7 +604,7 @@ ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
     {
         ALint idx = DeviceIfaceMap.lookupByKey(device);
         if(idx < 0) return ALC_INVALID_DEVICE;
-        return DriverList[idx].alcGetError(device);
+        return DriverList[idx]->alcGetError(device);
     }
     return LastError.exchange(ALC_NO_ERROR);
 }
@@ -533,7 +622,7 @@ ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const A
             LastError.store(ALC_INVALID_DEVICE);
             return ALC_FALSE;
         }
-        return DriverList[idx].alcIsExtensionPresent(device, extname);
+        return DriverList[idx]->alcIsExtensionPresent(device, extname);
     }
 
     len = strlen(extname);
@@ -562,7 +651,7 @@ ALC_API void* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *f
             LastError.store(ALC_INVALID_DEVICE);
             return nullptr;
         }
-        return DriverList[idx].alcGetProcAddress(device, funcname);
+        return DriverList[idx]->alcGetProcAddress(device, funcname);
     }
 
     auto iter = std::find_if(alcFunctions.cbegin(), alcFunctions.cend(),
@@ -582,7 +671,7 @@ ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *e
             LastError.store(ALC_INVALID_DEVICE);
             return 0;
         }
-        return DriverList[idx].alcGetEnumValue(device, enumname);
+        return DriverList[idx]->alcGetEnumValue(device, enumname);
     }
 
     auto iter = std::find_if(alcEnumerations.cbegin(), alcEnumerations.cend(),
@@ -602,7 +691,7 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum para
             LastError.store(ALC_INVALID_DEVICE);
             return nullptr;
         }
-        return DriverList[idx].alcGetString(device, param);
+        return DriverList[idx]->alcGetString(device, param);
     }
 
     switch(param)
@@ -623,18 +712,18 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum para
         return alcExtensionList;
 
     case ALC_DEVICE_SPECIFIER:
-    { std::lock_guard<std::mutex> _{EnumerationLock};
+    {
+        std::lock_guard<std::recursive_mutex> _{EnumerationLock};
         DevicesList.clear();
-        ALint idx = 0;
+        ALint idx{0};
         for(const auto &drv : DriverList)
         {
             /* Only enumerate names from drivers that support it. */
-            if(drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-               drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
                 AppendDeviceList(&DevicesList,
-                    drv.alcGetString(nullptr, ALC_DEVICE_SPECIFIER), idx
-                );
-            idx++;
+                    drv->alcGetString(nullptr, ALC_DEVICE_SPECIFIER), idx);
+            ++idx;
         }
         /* Ensure the list is double-null termianted. */
         if(DevicesList.Names.empty())
@@ -644,23 +733,22 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum para
     }
 
     case ALC_ALL_DEVICES_SPECIFIER:
-    { std::lock_guard<std::mutex> _{EnumerationLock};
+    {
+        std::lock_guard<std::recursive_mutex> _{EnumerationLock};
         AllDevicesList.clear();
-        ALint idx = 0;
+        ALint idx{0};
         for(const auto &drv : DriverList)
         {
             /* If the driver doesn't support ALC_ENUMERATE_ALL_EXT, substitute
              * standard enumeration.
              */
-            if(drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT"))
+            if(drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT"))
                 AppendDeviceList(&AllDevicesList,
-                    drv.alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER), idx
-                );
-            else if(drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-                    drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
+                    drv->alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER), idx);
+            else if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
                 AppendDeviceList(&AllDevicesList,
-                    drv.alcGetString(nullptr, ALC_DEVICE_SPECIFIER), idx
-                );
+                    drv->alcGetString(nullptr, ALC_DEVICE_SPECIFIER), idx);
             ++idx;
         }
         /* Ensure the list is double-null termianted. */
@@ -671,16 +759,16 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum para
     }
 
     case ALC_CAPTURE_DEVICE_SPECIFIER:
-    { std::lock_guard<std::mutex> _{EnumerationLock};
+    {
+        std::lock_guard<std::recursive_mutex> _{EnumerationLock};
         CaptureDevicesList.clear();
-        ALint idx = 0;
+        ALint idx{0};
         for(const auto &drv : DriverList)
         {
-            if(drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-               drv.alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE"))
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE"))
                 AppendDeviceList(&CaptureDevicesList,
-                    drv.alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER), idx
-                );
+                    drv->alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER), idx);
             ++idx;
         }
         /* Ensure the list is double-null termianted. */
@@ -692,40 +780,33 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum para
 
     case ALC_DEFAULT_DEVICE_SPECIFIER:
     {
-        auto iter = std::find_if(DriverList.cbegin(), DriverList.cend(),
-            [](const DriverIface &drv) -> bool
-            {
-                return drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-                       drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT");
-            }
-        );
-        if(iter != DriverList.cend())
-            return iter->alcGetString(nullptr, ALC_DEFAULT_DEVICE_SPECIFIER);
+        for(const auto &drv : DriverList)
+        {
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATION_EXT"))
+                return drv->alcGetString(nullptr, ALC_DEFAULT_DEVICE_SPECIFIER);
+        }
         return "";
     }
 
     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
     {
-        auto iter = std::find_if(DriverList.cbegin(), DriverList.cend(),
-            [](const DriverIface &drv) -> bool
-            { return drv.alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT") != ALC_FALSE; }
-        );
-        if(iter != DriverList.cend())
-            return iter->alcGetString(nullptr, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
+        for(const auto &drv : DriverList)
+        {
+            if(drv->alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT") != ALC_FALSE)
+                return drv->alcGetString(nullptr, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
+        }
         return "";
     }
 
     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
     {
-        auto iter = std::find_if(DriverList.cbegin(), DriverList.cend(),
-            [](const DriverIface &drv) -> bool
-            {
-                return drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-                       drv.alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE");
-            }
-        );
-        if(iter != DriverList.cend())
-            return iter->alcGetString(nullptr, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+        for(const auto &drv : DriverList)
+        {
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE"))
+                return drv->alcGetString(nullptr, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+        }
         return "";
     }
 
@@ -746,7 +827,7 @@ ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsi
             LastError.store(ALC_INVALID_DEVICE);
             return;
         }
-        return DriverList[idx].alcGetIntegerv(device, param, size, values);
+        return DriverList[idx]->alcGetIntegerv(device, param, size, values);
     }
 
     if(size <= 0 || values == nullptr)
@@ -800,7 +881,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename,
         devicename = nullptr;
     if(devicename)
     {
-        { std::lock_guard<std::mutex> _{EnumerationLock};
+        {
+            std::lock_guard<std::recursive_mutex> _{EnumerationLock};
             if(CaptureDevicesList.Names.empty())
                 (void)alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER);
             idx = GetDriverIndexForName(&CaptureDevicesList, devicename);
@@ -813,21 +895,17 @@ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename,
             return nullptr;
         }
         TRACE("Found driver %d for name \"%s\"\n", idx, devicename);
-        device = DriverList[idx].alcCaptureOpenDevice(
-            devicename, frequency, format, buffersize
-        );
+        device = DriverList[idx]->alcCaptureOpenDevice(devicename, frequency, format, buffersize);
     }
     else
     {
         for(const auto &drv : DriverList)
         {
-            if(drv.ALCVer >= MAKE_ALC_VER(1, 1) ||
-               drv.alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE"))
+            if(drv->ALCVer >= MAKE_ALC_VER(1, 1)
+                || drv->alcIsExtensionPresent(nullptr, "ALC_EXT_CAPTURE"))
             {
                 TRACE("Using default capture device from driver %d\n", idx);
-                device = drv.alcCaptureOpenDevice(
-                    nullptr, frequency, format, buffersize
-                );
+                device = drv->alcCaptureOpenDevice(nullptr, frequency, format, buffersize);
                 break;
             }
             ++idx;
@@ -838,7 +916,7 @@ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename,
     {
         if(DeviceIfaceMap.insert(device, idx) != ALC_NO_ERROR)
         {
-            DriverList[idx].alcCaptureCloseDevice(device);
+            DriverList[idx]->alcCaptureCloseDevice(device);
             device = nullptr;
         }
     }
@@ -855,7 +933,7 @@ ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
         LastError.store(ALC_INVALID_DEVICE);
         return ALC_FALSE;
     }
-    if(!DriverList[idx].alcCaptureCloseDevice(device))
+    if(!DriverList[idx]->alcCaptureCloseDevice(device))
         return ALC_FALSE;
     DeviceIfaceMap.removeByKey(device);
     return ALC_TRUE;
@@ -867,7 +945,7 @@ ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
     {
         ALint idx = DeviceIfaceMap.lookupByKey(device);
         if(idx >= 0)
-            return DriverList[idx].alcCaptureStart(device);
+            return DriverList[idx]->alcCaptureStart(device);
     }
     LastError.store(ALC_INVALID_DEVICE);
 }
@@ -878,7 +956,7 @@ ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
     {
         ALint idx = DeviceIfaceMap.lookupByKey(device);
         if(idx >= 0)
-            return DriverList[idx].alcCaptureStop(device);
+            return DriverList[idx]->alcCaptureStop(device);
     }
     LastError.store(ALC_INVALID_DEVICE);
 }
@@ -889,7 +967,7 @@ ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer,
     {
         ALint idx = DeviceIfaceMap.lookupByKey(device);
         if(idx >= 0)
-            return DriverList[idx].alcCaptureSamples(device, buffer, samples);
+            return DriverList[idx]->alcCaptureSamples(device, buffer, samples);
     }
     LastError.store(ALC_INVALID_DEVICE);
 }
@@ -902,27 +980,30 @@ ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
 
     if(!context)
     {
-        DriverIface *oldiface = ThreadCtxDriver;
+        DriverIface *oldiface = GetThreadDriver();
         if(oldiface && !oldiface->alcSetThreadContext(nullptr))
             return ALC_FALSE;
-        ThreadCtxDriver = nullptr;
+        SetThreadDriver(nullptr);
         return ALC_TRUE;
     }
 
     idx = ContextIfaceMap.lookupByKey(context);
     if(idx >= 0)
     {
-        if(DriverList[idx].alcSetThreadContext(context))
+        if(DriverList[idx]->alcSetThreadContext(context))
         {
-            DriverIface *oldiface = ThreadCtxDriver;
-            if(oldiface != &DriverList[idx])
+            auto do_init = [idx]() { InitCtxFuncs(*DriverList[idx]); };
+            std::call_once(DriverList[idx]->InitOnceCtx, do_init);
+
+            DriverIface *oldiface = GetThreadDriver();
+            if(oldiface != DriverList[idx].get())
             {
-                ThreadCtxDriver = &DriverList[idx];
+                SetThreadDriver(DriverList[idx].get());
                 if(oldiface) oldiface->alcSetThreadContext(nullptr);
             }
             return ALC_TRUE;
         }
-        err = DriverList[idx].alcGetError(nullptr);
+        err = DriverList[idx]->alcGetError(nullptr);
     }
     LastError.store(err);
     return ALC_FALSE;
@@ -930,7 +1011,7 @@ ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
 
 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
 {
-    DriverIface *iface = ThreadCtxDriver;
+    DriverIface *iface = GetThreadDriver();
     if(iface) return iface->alcGetThreadContext();
     return nullptr;
 }
diff --git a/router/router.cpp b/router/router.cpp
index 85a75aea..3c891053 100644
--- a/router/router.cpp
+++ b/router/router.cpp
@@ -17,13 +17,18 @@
 #include "version.h"
 
 
-std::vector<DriverIface> DriverList;
+std::vector<DriverIfacePtr> DriverList;
 
 thread_local DriverIface *ThreadCtxDriver;
 
 enum LogLevel LogLevel = LogLevel_Error;
 FILE *LogFile;
 
+#ifdef __MINGW32__
+DriverIface *GetThreadDriver() noexcept { return ThreadCtxDriver; }
+void SetThreadDriver(DriverIface *driver) noexcept { ThreadCtxDriver = driver; }
+#endif
+
 static void LoadDriverList(void);
 
 
@@ -79,13 +84,13 @@ static void AddModule(HMODULE module, const WCHAR *name)
 {
     for(auto &drv : DriverList)
     {
-        if(drv.Module == module)
+        if(drv->Module == module)
         {
             TRACE("Skipping already-loaded module %p\n", decltype(std::declval<void*>()){module});
             FreeLibrary(module);
             return;
         }
-        if(drv.Name == name)
+        if(drv->Name == name)
         {
             TRACE("Skipping similarly-named module %ls\n", name);
             FreeLibrary(module);
@@ -93,8 +98,8 @@ static void AddModule(HMODULE module, const WCHAR *name)
         }
     }
 
-    DriverList.emplace_back(name, module);
-    DriverIface &newdrv = DriverList.back();
+    DriverList.emplace_back(std::make_unique<DriverIface>(name, module));
+    DriverIface &newdrv = *DriverList.back();
 
     /* Load required functions. */
     int err = 0;
@@ -184,18 +189,6 @@ static void AddModule(HMODULE module, const WCHAR *name)
     LOAD_PROC(alGenBuffers);
     LOAD_PROC(alDeleteBuffers);
     LOAD_PROC(alIsBuffer);
-    LOAD_PROC(alBufferf);
-    LOAD_PROC(alBuffer3f);
-    LOAD_PROC(alBufferfv);
-    LOAD_PROC(alBufferi);
-    LOAD_PROC(alBuffer3i);
-    LOAD_PROC(alBufferiv);
-    LOAD_PROC(alGetBufferf);
-    LOAD_PROC(alGetBuffer3f);
-    LOAD_PROC(alGetBufferfv);
-    LOAD_PROC(alGetBufferi);
-    LOAD_PROC(alGetBuffer3i);
-    LOAD_PROC(alGetBufferiv);
     LOAD_PROC(alBufferData);
     LOAD_PROC(alDopplerFactor);
     LOAD_PROC(alDopplerVelocity);
@@ -209,7 +202,32 @@ static void AddModule(HMODULE module, const WCHAR *name)
         if(newdrv.alcGetError(nullptr) == ALC_NO_ERROR)
             newdrv.ALCVer = MAKE_ALC_VER(alc_ver[0], alc_ver[1]);
         else
+        {
+            WARN("Failed to query ALC version for %ls, assuming 1.0\n", name);
             newdrv.ALCVer = MAKE_ALC_VER(1, 0);
+        }
+
+#undef LOAD_PROC
+#define LOAD_PROC(x) do {                                                      \
+    newdrv.x = reinterpret_cast<decltype(newdrv.x)>(reinterpret_cast<void*>(   \
+        GetProcAddress(module, #x)));                                          \
+    if(!newdrv.x)                                                              \
+    {                                                                          \
+        WARN("Failed to find optional entry point for %s in %ls\n", #x, name); \
+    }                                                                          \
+} while(0)
+    LOAD_PROC(alBufferf);
+    LOAD_PROC(alBuffer3f);
+    LOAD_PROC(alBufferfv);
+    LOAD_PROC(alBufferi);
+    LOAD_PROC(alBuffer3i);
+    LOAD_PROC(alBufferiv);
+    LOAD_PROC(alGetBufferf);
+    LOAD_PROC(alGetBuffer3f);
+    LOAD_PROC(alGetBufferfv);
+    LOAD_PROC(alGetBufferi);
+    LOAD_PROC(alGetBuffer3i);
+    LOAD_PROC(alGetBufferiv);
 
 #undef LOAD_PROC
 #define LOAD_PROC(x) do {                                                     \
@@ -360,7 +378,7 @@ PtrIntMap::~PtrIntMap()
     mCapacity = 0;
 }
 
-ALenum PtrIntMap::insert(ALvoid *key, ALint value)
+ALenum PtrIntMap::insert(void *key, int value)
 {
     std::lock_guard<std::mutex> maplock{mLock};
     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
@@ -370,15 +388,15 @@ ALenum PtrIntMap::insert(ALvoid *key, ALint value)
     {
         if(mSize == mCapacity)
         {
-            ALvoid **newkeys{nullptr};
+            void **newkeys{nullptr};
             ALsizei newcap{mCapacity ? (mCapacity<<1) : 4};
             if(newcap > mCapacity)
-                newkeys = static_cast<ALvoid**>(
+                newkeys = static_cast<void**>(
                     al_calloc(16, (sizeof(mKeys[0])+sizeof(mValues[0]))*newcap)
                 );
             if(!newkeys)
                 return AL_OUT_OF_MEMORY;
-            auto newvalues = reinterpret_cast<ALint*>(&newkeys[newcap]);
+            auto newvalues = reinterpret_cast<int*>(&newkeys[newcap]);
 
             if(mKeys)
             {
@@ -404,9 +422,9 @@ ALenum PtrIntMap::insert(ALvoid *key, ALint value)
     return AL_NO_ERROR;
 }
 
-ALint PtrIntMap::removeByKey(ALvoid *key)
+int PtrIntMap::removeByKey(void *key)
 {
-    ALint ret = -1;
+    int ret = -1;
 
     std::lock_guard<std::mutex> maplock{mLock};
     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
@@ -425,9 +443,9 @@ ALint PtrIntMap::removeByKey(ALvoid *key)
     return ret;
 }
 
-ALint PtrIntMap::lookupByKey(ALvoid *key)
+int PtrIntMap::lookupByKey(void *key)
 {
-    ALint ret = -1;
+    int ret = -1;
 
     std::lock_guard<std::mutex> maplock{mLock};
     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
diff --git a/router/router.h b/router/router.h
index 007b6a16..2a126d42 100644
--- a/router/router.h
+++ b/router/router.h
@@ -7,10 +7,12 @@
 
 #include <stdio.h>
 
-#include <vector>
-#include <string>
 #include <atomic>
+#include <memory>
 #include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "AL/alc.h"
 #include "AL/al.h"
@@ -23,6 +25,7 @@ struct DriverIface {
     std::wstring Name;
     HMODULE Module{nullptr};
     int ALCVer{0};
+    std::once_flag InitOnceCtx{};
 
     LPALCCREATECONTEXT alcCreateContext{nullptr};
     LPALCMAKECONTEXTCURRENT alcMakeContextCurrent{nullptr};
@@ -122,8 +125,44 @@ struct DriverIface {
     LPALSPEEDOFSOUND alSpeedOfSound{nullptr};
     LPALDISTANCEMODEL alDistanceModel{nullptr};
 
-    DriverIface(std::wstring name, HMODULE mod)
-      : Name(std::move(name)), Module(mod)
+    /* Functions to load after first context creation. */
+    LPALGENFILTERS alGenFilters{nullptr};
+    LPALDELETEFILTERS alDeleteFilters{nullptr};
+    LPALISFILTER alIsFilter{nullptr};
+    LPALFILTERF alFilterf{nullptr};
+    LPALFILTERFV alFilterfv{nullptr};
+    LPALFILTERI alFilteri{nullptr};
+    LPALFILTERIV alFilteriv{nullptr};
+    LPALGETFILTERF alGetFilterf{nullptr};
+    LPALGETFILTERFV alGetFilterfv{nullptr};
+    LPALGETFILTERI alGetFilteri{nullptr};
+    LPALGETFILTERIV alGetFilteriv{nullptr};
+    LPALGENEFFECTS alGenEffects{nullptr};
+    LPALDELETEEFFECTS alDeleteEffects{nullptr};
+    LPALISEFFECT alIsEffect{nullptr};
+    LPALEFFECTF alEffectf{nullptr};
+    LPALEFFECTFV alEffectfv{nullptr};
+    LPALEFFECTI alEffecti{nullptr};
+    LPALEFFECTIV alEffectiv{nullptr};
+    LPALGETEFFECTF alGetEffectf{nullptr};
+    LPALGETEFFECTFV alGetEffectfv{nullptr};
+    LPALGETEFFECTI alGetEffecti{nullptr};
+    LPALGETEFFECTIV alGetEffectiv{nullptr};
+    LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots{nullptr};
+    LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots{nullptr};
+    LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot{nullptr};
+    LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf{nullptr};
+    LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv{nullptr};
+    LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti{nullptr};
+    LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv{nullptr};
+    LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf{nullptr};
+    LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv{nullptr};
+    LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti{nullptr};
+    LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv{nullptr};
+
+    template<typename T>
+    DriverIface(T&& name, HMODULE mod)
+      : Name(std::forward<T>(name)), Module(mod)
     { }
     ~DriverIface()
     {
@@ -132,17 +171,29 @@ struct DriverIface {
         Module = nullptr;
     }
 };
+using DriverIfacePtr = std::unique_ptr<DriverIface>;
 
-extern std::vector<DriverIface> DriverList;
+extern std::vector<DriverIfacePtr> DriverList;
 
 extern thread_local DriverIface *ThreadCtxDriver;
 extern std::atomic<DriverIface*> CurrentCtxDriver;
 
+/* HACK: MinGW generates bad code when accessing an extern thread_local object.
+ * Add a wrapper function for it that only accesses it where it's defined.
+ */
+#ifdef __MINGW32__
+DriverIface *GetThreadDriver() noexcept;
+void SetThreadDriver(DriverIface *driver) noexcept;
+#else
+inline DriverIface *GetThreadDriver() noexcept { return ThreadCtxDriver; }
+inline void SetThreadDriver(DriverIface *driver) noexcept { ThreadCtxDriver = driver; }
+#endif
+
 
 class PtrIntMap {
-    ALvoid **mKeys{nullptr};
+    void **mKeys{nullptr};
     /* Shares memory with keys. */
-    ALint *mValues{nullptr};
+    int *mValues{nullptr};
 
     ALsizei mSize{0};
     ALsizei mCapacity{0};
@@ -152,9 +203,9 @@ public:
     PtrIntMap() = default;
     ~PtrIntMap();
 
-    ALenum insert(ALvoid *key, ALint value);
-    ALint removeByKey(ALvoid *key);
-    ALint lookupByKey(ALvoid *key);
+    ALenum insert(void *key, int value);
+    int removeByKey(void *key);
+    int lookupByKey(void *key);
 };
 
 
diff --git a/utils/alsoft-config/CMakeLists.txt b/utils/alsoft-config/CMakeLists.txt
index 68b9e9de..c6a46075 100644
--- a/utils/alsoft-config/CMakeLists.txt
+++ b/utils/alsoft-config/CMakeLists.txt
@@ -1,62 +1,32 @@
 project(alsoft-config)
 
-option(ALSOFT_NO_QT5 "Use Qt4 instead of Qt5 for alsoft-config" FALSE)
-
-include_directories("${alsoft-config_BINARY_DIR}")
-
-set(alsoft-config_SRCS
-    main.cpp
-    mainwindow.cpp
-    mainwindow.h
-    verstr.cpp
-    verstr.h
-)
-set(alsoft-config_UIS  mainwindow.ui)
-set(alsoft-config_MOCS  mainwindow.h)
-
-find_package(Qt5Widgets)
-if(Qt5Widgets_FOUND AND NOT ALSOFT_NO_QT5)
-    qt5_wrap_ui(UIS ${alsoft-config_UIS})
-
-    qt5_wrap_cpp(MOCS ${alsoft-config_MOCS})
-
-    add_executable(alsoft-config ${alsoft-config_SRCS} ${UIS} ${RSCS} ${TRS} ${MOCS})
+if(Qt5Widgets_FOUND)
+    qt5_wrap_ui(UIS  mainwindow.ui)
+
+    qt5_wrap_cpp(MOCS  mainwindow.h)
+
+    add_executable(alsoft-config
+        main.cpp
+        mainwindow.cpp
+        mainwindow.h
+        verstr.cpp
+        verstr.h
+        ${UIS} ${RSCS} ${TRS} ${MOCS})
     target_link_libraries(alsoft-config Qt5::Widgets)
-    target_include_directories(alsoft-config PRIVATE "${OpenAL_BINARY_DIR}")
-    set_property(TARGET alsoft-config APPEND PROPERTY COMPILE_FLAGS ${EXTRA_CFLAGS})
-    set_target_properties(alsoft-config PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${OpenAL_BINARY_DIR})
+    target_include_directories(alsoft-config PRIVATE "${alsoft-config_BINARY_DIR}"
+        "${OpenAL_BINARY_DIR}")
+    set_target_properties(alsoft-config PROPERTIES ${DEFAULT_TARGET_PROPS}
+        RUNTIME_OUTPUT_DIRECTORY ${OpenAL_BINARY_DIR})
     if(TARGET build_version)
         add_dependencies(alsoft-config build_version)
     endif()
 
-    install(TARGETS alsoft-config
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    )
-else()
-    # Need Qt 4.8.0 or newer for the iconset theme attribute to work
-    find_package(Qt4 4.8.0 COMPONENTS QtCore QtGui)
-    if(QT4_FOUND)
-        include(${QT_USE_FILE})
-
-        qt4_wrap_ui(UIS ${alsoft-config_UIS})
-
-        qt4_wrap_cpp(MOCS ${alsoft-config_MOCS})
-
-        add_executable(alsoft-config ${alsoft-config_SRCS} ${UIS} ${RSCS} ${TRS} ${MOCS})
-        target_link_libraries(alsoft-config ${QT_LIBRARIES})
-        target_include_directories(alsoft-config PRIVATE "${OpenAL_BINARY_DIR}")
-        set_property(TARGET alsoft-config APPEND PROPERTY COMPILE_FLAGS ${EXTRA_CFLAGS})
-        set_target_properties(alsoft-config PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${OpenAL_BINARY_DIR})
-        if(TARGET build_version)
-            add_dependencies(alsoft-config build_version)
-        endif()
+    message(STATUS "Building configuration program")
 
+    if(ALSOFT_INSTALL_UTILS)
         install(TARGETS alsoft-config
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        )
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
     endif()
 endif()
diff --git a/utils/alsoft-config/mainwindow.cpp b/utils/alsoft-config/mainwindow.cpp
index fed9de59..bee7022f 100644
--- a/utils/alsoft-config/mainwindow.cpp
+++ b/utils/alsoft-config/mainwindow.cpp
@@ -21,13 +21,16 @@
 
 namespace {
 
-static const struct {
+const struct {
     char backend_name[16];
     char full_string[32];
 } backendList[] = {
 #ifdef HAVE_JACK
     { "jack", "JACK" },
 #endif
+#ifdef HAVE_PIPEWIRE
+    { "pipewire", "PipeWire" },
+#endif
 #ifdef HAVE_PULSEAUDIO
     { "pulse", "PulseAudio" },
 #endif
@@ -72,7 +75,7 @@ static const struct {
     { "", "" }
 };
 
-static const struct NameValuePair {
+const struct NameValuePair {
     const char name[64];
     const char value[16];
 } speakerModeList[] = {
@@ -80,10 +83,10 @@ static const struct NameValuePair {
     { "Mono", "mono" },
     { "Stereo", "stereo" },
     { "Quadraphonic", "quad" },
-    { "5.1 Surround (Side)", "surround51" },
-    { "5.1 Surround (Rear)", "surround51rear" },
+    { "5.1 Surround", "surround51" },
     { "6.1 Surround", "surround61" },
     { "7.1 Surround", "surround71" },
+    { "3D7.1 Surround", "surround3d71" },
 
     { "Ambisonic, 1st Order", "ambi1" },
     { "Ambisonic, 2nd Order", "ambi2" },
@@ -104,8 +107,8 @@ static const struct NameValuePair {
 }, resamplerList[] = {
     { "Point", "point" },
     { "Linear", "linear" },
-    { "Default (Linear)", "" },
     { "Cubic Spline", "cubic" },
+    { "Default (Cubic Spline)", "" },
     { "11th order Sinc (fast)", "fast_bsinc12" },
     { "11th order Sinc", "bsinc12" },
     { "23rd order Sinc (fast)", "fast_bsinc24" },
@@ -120,27 +123,30 @@ static const struct NameValuePair {
     { "", "" }
 }, stereoEncList[] = {
     { "Default", "" },
-    { "Pan Pot", "panpot" },
+    { "Basic", "panpot" },
     { "UHJ", "uhj" },
+    { "Binaural", "hrtf" },
 
     { "", "" }
 }, ambiFormatList[] = {
     { "Default", "" },
     { "AmbiX (ACN, SN3D)", "ambix" },
-    { "ACN, N3D", "acn+n3d" },
     { "Furse-Malham", "fuma" },
+    { "ACN, N3D", "acn+n3d" },
+    { "ACN, FuMa", "acn+fuma" },
 
     { "", "" }
 }, hrtfModeList[] = {
     { "1st Order Ambisonic", "ambi1" },
     { "2nd Order Ambisonic", "ambi2" },
+    { "3rd Order Ambisonic", "ambi3" },
     { "Default (Full)", "" },
     { "Full", "full" },
 
     { "", "" }
 };
 
-static QString getDefaultConfigName()
+QString getDefaultConfigName()
 {
 #ifdef Q_OS_WIN32
     static const char fname[] = "alsoft.ini";
@@ -167,7 +173,7 @@ static QString getDefaultConfigName()
     return fname;
 }
 
-static QString getBaseDataPath()
+QString getBaseDataPath()
 {
 #ifdef Q_OS_WIN32
     auto get_appdata_path = []() noexcept -> QString
@@ -190,7 +196,7 @@ static QString getBaseDataPath()
     return base;
 }
 
-static QStringList getAllDataPaths(const QString &append)
+QStringList getAllDataPaths(const QString &append)
 {
     QStringList list;
     list.append(getBaseDataPath());
@@ -200,8 +206,12 @@ static QStringList getAllDataPaths(const QString &append)
     QString paths = qgetenv("XDG_DATA_DIRS");
     if(paths.isEmpty())
         paths = "/usr/local/share/:/usr/share/";
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    list += paths.split(QChar(':'), Qt::SkipEmptyParts);
+#else
     list += paths.split(QChar(':'), QString::SkipEmptyParts);
 #endif
+#endif
     QStringList::iterator iter = list.begin();
     while(iter != list.end())
     {
@@ -217,7 +227,7 @@ static QStringList getAllDataPaths(const QString &append)
 }
 
 template<size_t N>
-static QString getValueFromName(const NameValuePair (&list)[N], const QString &str)
+QString getValueFromName(const NameValuePair (&list)[N], const QString &str)
 {
     for(size_t i = 0;i < N-1;i++)
     {
@@ -228,7 +238,7 @@ static QString getValueFromName(const NameValuePair (&list)[N], const QString &s
 }
 
 template<size_t N>
-static QString getNameFromValue(const NameValuePair (&list)[N], const QString &str)
+QString getNameFromValue(const NameValuePair (&list)[N], const QString &str)
 {
     for(size_t i = 0;i < N-1;i++)
     {
@@ -298,7 +308,6 @@ MainWindow::MainWindow(QWidget *parent) :
     for(count = 0;hrtfModeList[count].name[0];count++) {
     }
     ui->hrtfmodeSlider->setRange(0, count-1);
-    ui->hrtfStateComboBox->adjustSize();
 
 #if !defined(HAVE_NEON) && !defined(HAVE_SSE)
     ui->cpuExtDisabledLabel->move(ui->cpuExtDisabledLabel->x(), ui->cpuExtDisabledLabel->y() - 60);
@@ -340,6 +349,12 @@ MainWindow::MainWindow(QWidget *parent) :
 
 #endif
 
+#ifndef ALSOFT_EAX
+    ui->enableEaxCheck->setChecked(Qt::Unchecked);
+    ui->enableEaxCheck->setEnabled(false);
+    ui->enableEaxCheck->setVisible(false);
+#endif
+
     mPeriodSizeValidator = new QIntValidator{64, 8192, this};
     ui->periodSizeEdit->setValidator(mPeriodSizeValidator);
     mPeriodCountValidator = new QIntValidator{2, 16, this};
@@ -365,11 +380,11 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->closeCancelButton, &QPushButton::clicked, this, &MainWindow::cancelCloseAction);
     connect(ui->applyButton, &QPushButton::clicked, this, &MainWindow::saveCurrentConfig);
 
-    auto qcb_cicstr = static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged);
-    connect(ui->channelConfigCombo, qcb_cicstr, this, &MainWindow::enableApplyButton);
-    connect(ui->sampleFormatCombo, qcb_cicstr, this, &MainWindow::enableApplyButton);
-    connect(ui->stereoModeCombo, qcb_cicstr, this, &MainWindow::enableApplyButton);
-    connect(ui->sampleRateCombo, qcb_cicstr, this, &MainWindow::enableApplyButton);
+    auto qcb_cicint = static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged);
+    connect(ui->channelConfigCombo, qcb_cicint, this, &MainWindow::enableApplyButton);
+    connect(ui->sampleFormatCombo, qcb_cicint, this, &MainWindow::enableApplyButton);
+    connect(ui->stereoModeCombo, qcb_cicint, this, &MainWindow::enableApplyButton);
+    connect(ui->sampleRateCombo, qcb_cicint, this, &MainWindow::enableApplyButton);
     connect(ui->sampleRateCombo, &QComboBox::editTextChanged, this, &MainWindow::enableApplyButton);
 
     connect(ui->resamplerSlider, &QSlider::valueChanged, this, &MainWindow::updateResamplerLabel);
@@ -379,8 +394,8 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->periodCountSlider, &QSlider::valueChanged, this, &MainWindow::updatePeriodCountEdit);
     connect(ui->periodCountEdit, &QLineEdit::editingFinished, this, &MainWindow::updatePeriodCountSlider);
 
-    connect(ui->stereoEncodingComboBox, qcb_cicstr, this, &MainWindow::enableApplyButton);
-    connect(ui->ambiFormatComboBox, qcb_cicstr, this, &MainWindow::enableApplyButton);
+    connect(ui->stereoEncodingComboBox, qcb_cicint, this, &MainWindow::enableApplyButton);
+    connect(ui->ambiFormatComboBox, qcb_cicint, this, &MainWindow::enableApplyButton);
     connect(ui->outputLimiterCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->outputDitherCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
 
@@ -388,7 +403,7 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->decoderDistCompCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->decoderNFEffectsCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     auto qdsb_vcd = static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged);
-    connect(ui->decoderNFRefDelaySpinBox, qdsb_vcd, this, &MainWindow::enableApplyButton);
+    connect(ui->decoderSpeakerDistSpinBox, qdsb_vcd, this, &MainWindow::enableApplyButton);
     connect(ui->decoderQuadLineEdit, &QLineEdit::textChanged, this, &MainWindow::enableApplyButton);
     connect(ui->decoderQuadButton, &QPushButton::clicked, this, &MainWindow::selectQuadDecoderFile);
     connect(ui->decoder51LineEdit, &QLineEdit::textChanged, this, &MainWindow::enableApplyButton);
@@ -397,9 +412,10 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->decoder61Button, &QPushButton::clicked, this, &MainWindow::select61DecoderFile);
     connect(ui->decoder71LineEdit, &QLineEdit::textChanged, this, &MainWindow::enableApplyButton);
     connect(ui->decoder71Button, &QPushButton::clicked, this, &MainWindow::select71DecoderFile);
+    connect(ui->decoder3D71LineEdit, &QLineEdit::textChanged, this, &MainWindow::enableApplyButton);
+    connect(ui->decoder3D71Button, &QPushButton::clicked, this, &MainWindow::select3D71DecoderFile);
 
-    connect(ui->preferredHrtfComboBox, qcb_cicstr, this, &MainWindow::enableApplyButton);
-    connect(ui->hrtfStateComboBox, qcb_cicstr, this, &MainWindow::enableApplyButton);
+    connect(ui->preferredHrtfComboBox, qcb_cicint, this, &MainWindow::enableApplyButton);
     connect(ui->hrtfmodeSlider, &QSlider::valueChanged, this, &MainWindow::updateHrtfModeLabel);
 
     connect(ui->hrtfAddButton, &QPushButton::clicked, this, &MainWindow::addHrtfFile);
@@ -424,7 +440,7 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->disabledBackendList, &QListWidget::customContextMenuRequested, this, &MainWindow::showDisabledBackendMenu);
     connect(ui->backendCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
 
-    connect(ui->defaultReverbComboBox, qcb_cicstr, this, &MainWindow::enableApplyButton);
+    connect(ui->defaultReverbComboBox, qcb_cicint, this, &MainWindow::enableApplyButton);
     connect(ui->enableEaxReverbCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->enableStdReverbCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->enableAutowahCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
@@ -439,13 +455,21 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->enableDedicatedCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->enablePitchShifterCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->enableVocalMorpherCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+    connect(ui->enableEaxCheck, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
 
     connect(ui->pulseAutospawnCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->pulseAllowMovesCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->pulseFixRateCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->pulseAdjLatencyCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
 
+    connect(ui->pwireAssumeAudioCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+    connect(ui->pwireRtMixCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+
+    connect(ui->wasapiResamplerCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+
     connect(ui->jackAutospawnCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+    connect(ui->jackConnectPortsCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
+    connect(ui->jackRtMixCheckBox, &QCheckBox::stateChanged, this, &MainWindow::enableApplyButton);
     connect(ui->jackBufferSizeSlider, &QSlider::valueChanged, this, &MainWindow::updateJackBufferSizeEdit);
     connect(ui->jackBufferSizeLine, &QLineEdit::editingFinished, this, &MainWindow::updateJackBufferSizeSlider);
 
@@ -474,10 +498,9 @@ MainWindow::MainWindow(QWidget *parent) :
     for(int i = 0;backendList[i].backend_name[0];i++)
     {
         QList<QListWidgetItem*> items = ui->backendListWidget->findItems(
-            backendList[i].full_string, Qt::MatchFixedString
-        );
-        foreach(const QListWidgetItem *item, items)
-            ui->backendListWidget->setItemHidden(item, false);
+            backendList[i].full_string, Qt::MatchFixedString);
+        foreach(QListWidgetItem *item, items)
+            item->setHidden(false);
     }
 
     loadConfig(getDefaultConfigName());
@@ -601,8 +624,7 @@ QStringList MainWindow::collectHrtfs()
         }
 
 #ifdef ALSOFT_EMBED_HRTF_DATA
-        ret.push_back("Built-In 44100hz");
-        ret.push_back("Built-In 48000hz");
+        ret.push_back("Built-In HRTF");
 #endif
     }
     return ret;
@@ -636,6 +658,8 @@ void MainWindow::loadConfig(const QString &fname)
     ui->channelConfigCombo->setCurrentIndex(0);
     if(channelconfig.isEmpty() == false)
     {
+        if(channelconfig == "surround51rear")
+            channelconfig = "surround51";
         QString str{getNameFromValue(speakerModeList, channelconfig)};
         if(!str.isEmpty())
         {
@@ -736,17 +760,17 @@ void MainWindow::loadConfig(const QString &fname)
         }
     }
 
-    bool hqmode{settings.value("decoder/hq-mode", true).toBool()};
-    ui->decoderHQModeCheckBox->setChecked(hqmode);
+    ui->decoderHQModeCheckBox->setChecked(getCheckState(settings.value("decoder/hq-mode")));
     ui->decoderDistCompCheckBox->setCheckState(getCheckState(settings.value("decoder/distance-comp")));
     ui->decoderNFEffectsCheckBox->setCheckState(getCheckState(settings.value("decoder/nfc")));
-    double refdelay{settings.value("decoder/nfc-ref-delay", 0.0).toDouble()};
-    ui->decoderNFRefDelaySpinBox->setValue(refdelay);
+    double speakerdist{settings.value("decoder/speaker-dist", 1.0).toDouble()};
+    ui->decoderSpeakerDistSpinBox->setValue(speakerdist);
 
     ui->decoderQuadLineEdit->setText(settings.value("decoder/quad").toString());
     ui->decoder51LineEdit->setText(settings.value("decoder/surround51").toString());
     ui->decoder61LineEdit->setText(settings.value("decoder/surround61").toString());
     ui->decoder71LineEdit->setText(settings.value("decoder/surround71").toString());
+    ui->decoder3D71LineEdit->setText(settings.value("decoder/surround3d71").toString());
 
     QStringList disabledCpuExts{settings.value("disable-cpu-exts").toStringList()};
     if(disabledCpuExts.size() == 1)
@@ -761,11 +785,9 @@ void MainWindow::loadConfig(const QString &fname)
 
     QString hrtfmode{settings.value("hrtf-mode").toString().trimmed()};
     ui->hrtfmodeSlider->setValue(2);
-    ui->hrtfmodeLabel->setText(hrtfModeList[2].name);
-    /* The "basic" mode name is no longer supported, and "ambi3" is temporarily
-     * disabled. Use "ambi2" instead.
-     */
-    if(hrtfmode == "basic" || hrtfmode == "ambi3")
+    ui->hrtfmodeLabel->setText(hrtfModeList[3].name);
+    /* The "basic" mode name is no longer supported. Use "ambi2" instead. */
+    if(hrtfmode == "basic")
         hrtfmode = "ambi2";
     for(int i = 0;hrtfModeList[i].name[0];i++)
     {
@@ -794,14 +816,6 @@ void MainWindow::loadConfig(const QString &fname)
     ui->hrtfFileList->addItems(hrtf_paths);
     updateHrtfRemoveButton();
 
-    QString hrtfstate{settings.value("hrtf").toString().toLower()};
-    if(hrtfstate == "true")
-        ui->hrtfStateComboBox->setCurrentIndex(1);
-    else if(hrtfstate == "false")
-        ui->hrtfStateComboBox->setCurrentIndex(2);
-    else
-        ui->hrtfStateComboBox->setCurrentIndex(0);
-
     ui->preferredHrtfComboBox->clear();
     ui->preferredHrtfComboBox->addItem("- Any -");
     if(ui->defaultHrtfPathsCheckBox->isChecked())
@@ -830,7 +844,7 @@ void MainWindow::loadConfig(const QString &fname)
     ui->enabledBackendList->clear();
     ui->disabledBackendList->clear();
     QStringList drivers{settings.value("drivers").toStringList()};
-    if(drivers.size() == 0)
+    if(drivers.empty())
         ui->backendCheckBox->setChecked(true);
     else
     {
@@ -912,13 +926,22 @@ void MainWindow::loadConfig(const QString &fname)
     ui->enableDedicatedCheck->setChecked(!excludefx.contains("dedicated", Qt::CaseInsensitive));
     ui->enablePitchShifterCheck->setChecked(!excludefx.contains("pshifter", Qt::CaseInsensitive));
     ui->enableVocalMorpherCheck->setChecked(!excludefx.contains("vmorpher", Qt::CaseInsensitive));
+    if(ui->enableEaxCheck->isEnabled())
+        ui->enableEaxCheck->setChecked(getCheckState(settings.value("eax/enable")) != Qt::Unchecked);
 
     ui->pulseAutospawnCheckBox->setCheckState(getCheckState(settings.value("pulse/spawn-server")));
     ui->pulseAllowMovesCheckBox->setCheckState(getCheckState(settings.value("pulse/allow-moves")));
     ui->pulseFixRateCheckBox->setCheckState(getCheckState(settings.value("pulse/fix-rate")));
     ui->pulseAdjLatencyCheckBox->setCheckState(getCheckState(settings.value("pulse/adjust-latency")));
 
+    ui->pwireAssumeAudioCheckBox->setCheckState(getCheckState(settings.value("pipewire/assume-audio")));
+    ui->pwireRtMixCheckBox->setCheckState(getCheckState(settings.value("pipewire/rt-mix")));
+
+    ui->wasapiResamplerCheckBox->setCheckState(getCheckState(settings.value("wasapi/allow-resampler")));
+
     ui->jackAutospawnCheckBox->setCheckState(getCheckState(settings.value("jack/spawn-server")));
+    ui->jackConnectPortsCheckBox->setCheckState(getCheckState(settings.value("jack/connect-ports")));
+    ui->jackRtMixCheckBox->setCheckState(getCheckState(settings.value("jack/rt-mix")));
     ui->jackBufferSizeLine->setText(settings.value("jack/buffer-size", QString()).toString());
     updateJackBufferSizeSlider();
 
@@ -998,20 +1021,19 @@ void MainWindow::saveConfig(const QString &fname) const
     settings.setValue("output-limiter", getCheckValue(ui->outputLimiterCheckBox));
     settings.setValue("dither", getCheckValue(ui->outputDitherCheckBox));
 
-    settings.setValue("decoder/hq-mode",
-        ui->decoderHQModeCheckBox->isChecked() ? QString{/*"true"*/} : QString{"false"}
-    );
+    settings.setValue("decoder/hq-mode", getCheckValue(ui->decoderHQModeCheckBox));
     settings.setValue("decoder/distance-comp", getCheckValue(ui->decoderDistCompCheckBox));
     settings.setValue("decoder/nfc", getCheckValue(ui->decoderNFEffectsCheckBox));
-    double refdelay = ui->decoderNFRefDelaySpinBox->value();
-    settings.setValue("decoder/nfc-ref-delay",
-        (refdelay > 0.0) ? QString::number(refdelay) : QString{}
+    double speakerdist{ui->decoderSpeakerDistSpinBox->value()};
+    settings.setValue("decoder/speaker-dist",
+        (speakerdist != 1.0) ? QString::number(speakerdist) : QString{}
     );
 
     settings.setValue("decoder/quad", ui->decoderQuadLineEdit->text());
     settings.setValue("decoder/surround51", ui->decoder51LineEdit->text());
     settings.setValue("decoder/surround61", ui->decoder61LineEdit->text());
     settings.setValue("decoder/surround71", ui->decoder71LineEdit->text());
+    settings.setValue("decoder/surround3d71", ui->decoder3D71LineEdit->text());
 
     QStringList strlist;
     if(!ui->enableSSECheckBox->isChecked())
@@ -1028,13 +1050,6 @@ void MainWindow::saveConfig(const QString &fname) const
 
     settings.setValue("hrtf-mode", hrtfModeList[ui->hrtfmodeSlider->value()].value);
 
-    if(ui->hrtfStateComboBox->currentIndex() == 1)
-        settings.setValue("hrtf", "true");
-    else if(ui->hrtfStateComboBox->currentIndex() == 2)
-        settings.setValue("hrtf", "false");
-    else
-        settings.setValue("hrtf", QString{});
-
     if(ui->preferredHrtfComboBox->currentIndex() == 0)
         settings.setValue("default-hrtf", QString{});
     else
@@ -1076,7 +1091,7 @@ void MainWindow::saveConfig(const QString &fname) const
             }
         }
     }
-    if(strlist.size() == 0 && !ui->backendCheckBox->isChecked())
+    if(strlist.empty() && !ui->backendCheckBox->isChecked())
         strlist.append("-all");
     else if(ui->backendCheckBox->isChecked())
         strlist.append(QString{});
@@ -1121,6 +1136,14 @@ void MainWindow::saveConfig(const QString &fname) const
     if(!ui->enableVocalMorpherCheck->isChecked())
         strlist.append("vmorpher");
     settings.setValue("excludefx", strlist.join(QChar{','}));
+    settings.setValue("eax/enable",
+        (!ui->enableEaxCheck->isEnabled() || ui->enableEaxCheck->isChecked())
+        ? QString{/*"true"*/} : QString{"false"});
+
+    settings.setValue("pipewire/assume-audio", getCheckValue(ui->pwireAssumeAudioCheckBox));
+    settings.setValue("pipewire/rt-mix", getCheckValue(ui->pwireRtMixCheckBox));
+
+    settings.setValue("wasapi/allow-resampler", getCheckValue(ui->wasapiResamplerCheckBox));
 
     settings.setValue("pulse/spawn-server", getCheckValue(ui->pulseAutospawnCheckBox));
     settings.setValue("pulse/allow-moves", getCheckValue(ui->pulseAllowMovesCheckBox));
@@ -1128,6 +1151,8 @@ void MainWindow::saveConfig(const QString &fname) const
     settings.setValue("pulse/adjust-latency", getCheckValue(ui->pulseAdjLatencyCheckBox));
 
     settings.setValue("jack/spawn-server", getCheckValue(ui->jackAutospawnCheckBox));
+    settings.setValue("jack/connect-ports", getCheckValue(ui->jackConnectPortsCheckBox));
+    settings.setValue("jack/rt-mix", getCheckValue(ui->jackRtMixCheckBox));
     settings.setValue("jack/buffer-size", ui->jackBufferSizeLine->text());
 
     settings.setValue("alsa/device", ui->alsaDefaultDeviceLine->text());
@@ -1222,6 +1247,8 @@ void MainWindow::select61DecoderFile()
 { selectDecoderFile(ui->decoder61LineEdit, "Select 6.1 Surround Decoder");}
 void MainWindow::select71DecoderFile()
 { selectDecoderFile(ui->decoder71LineEdit, "Select 7.1 Surround Decoder");}
+void MainWindow::select3D71DecoderFile()
+{ selectDecoderFile(ui->decoder3D71LineEdit, "Select 3D7.1 Surround Decoder");}
 void MainWindow::selectDecoderFile(QLineEdit *line, const char *caption)
 {
     QString dir{line->text()};
@@ -1295,7 +1322,7 @@ void MainWindow::removeHrtfFile()
 
 void MainWindow::updateHrtfRemoveButton()
 {
-    ui->hrtfRemoveButton->setEnabled(ui->hrtfFileList->selectedItems().size() != 0);
+    ui->hrtfRemoveButton->setEnabled(!ui->hrtfFileList->selectedItems().empty());
 }
 
 void MainWindow::showEnabledBackendMenu(QPoint pt)
@@ -1306,7 +1333,7 @@ void MainWindow::showEnabledBackendMenu(QPoint pt)
 
     QMenu ctxmenu;
     QAction *removeAction{ctxmenu.addAction(QIcon::fromTheme("list-remove"), "Remove")};
-    if(ui->enabledBackendList->selectedItems().size() == 0)
+    if(ui->enabledBackendList->selectedItems().empty())
         removeAction->setEnabled(false);
     ctxmenu.addSeparator();
     for(size_t i = 0;backendList[i].backend_name[0];i++)
@@ -1314,8 +1341,8 @@ void MainWindow::showEnabledBackendMenu(QPoint pt)
         QString backend{backendList[i].full_string};
         QAction *action{ctxmenu.addAction(QString("Add ")+backend)};
         actionMap[action] = backend;
-        if(ui->enabledBackendList->findItems(backend, Qt::MatchFixedString).size() != 0 ||
-           ui->disabledBackendList->findItems(backend, Qt::MatchFixedString).size() != 0)
+        if(!ui->enabledBackendList->findItems(backend, Qt::MatchFixedString).empty() ||
+           !ui->disabledBackendList->findItems(backend, Qt::MatchFixedString).empty())
             action->setEnabled(false);
     }
 
@@ -1344,7 +1371,7 @@ void MainWindow::showDisabledBackendMenu(QPoint pt)
 
     QMenu ctxmenu;
     QAction *removeAction{ctxmenu.addAction(QIcon::fromTheme("list-remove"), "Remove")};
-    if(ui->disabledBackendList->selectedItems().size() == 0)
+    if(ui->disabledBackendList->selectedItems().empty())
         removeAction->setEnabled(false);
     ctxmenu.addSeparator();
     for(size_t i = 0;backendList[i].backend_name[0];i++)
@@ -1352,8 +1379,8 @@ void MainWindow::showDisabledBackendMenu(QPoint pt)
         QString backend{backendList[i].full_string};
         QAction *action{ctxmenu.addAction(QString("Add ")+backend)};
         actionMap[action] = backend;
-        if(ui->disabledBackendList->findItems(backend, Qt::MatchFixedString).size() != 0 ||
-           ui->enabledBackendList->findItems(backend, Qt::MatchFixedString).size() != 0)
+        if(!ui->disabledBackendList->findItems(backend, Qt::MatchFixedString).empty() ||
+           !ui->enabledBackendList->findItems(backend, Qt::MatchFixedString).empty())
             action->setEnabled(false);
     }
 
diff --git a/utils/alsoft-config/mainwindow.h b/utils/alsoft-config/mainwindow.h
index ca53582b..f7af8eac 100644
--- a/utils/alsoft-config/mainwindow.h
+++ b/utils/alsoft-config/mainwindow.h
@@ -39,6 +39,7 @@ private slots:
     void select51DecoderFile();
     void select61DecoderFile();
     void select71DecoderFile();
+    void select3D71DecoderFile();
 
     void updateJackBufferSizeEdit(int size);
     void updateJackBufferSizeSlider();
diff --git a/utils/alsoft-config/mainwindow.ui b/utils/alsoft-config/mainwindow.ui
index 0506304e..b959cf74 100644
--- a/utils/alsoft-config/mainwindow.ui
+++ b/utils/alsoft-config/mainwindow.ui
@@ -62,7 +62,7 @@
        <rect>
         <x>110</x>
         <y>50</y>
-        <width>76</width>
+        <width>80</width>
         <height>31</height>
        </rect>
       </property>
@@ -111,14 +111,14 @@ float and converted to the output sample type as needed.</string>
        <rect>
         <x>110</x>
         <y>20</y>
-        <width>76</width>
+        <width>80</width>
         <height>31</height>
        </rect>
       </property>
       <property name="toolTip">
-       <string>The output channel configuration. Note that not all backends
-can properly detect the channel configuration and may default
-to stereo output.</string>
+       <string>The default output channel configuration. Note that not all
+backends can properly detect the channel configuration and
+may default to stereo output.</string>
       </property>
       <property name="sizeAdjustPolicy">
        <enum>QComboBox::AdjustToContents</enum>
@@ -129,7 +129,7 @@ to stereo output.</string>
        <rect>
         <x>380</x>
         <y>20</y>
-        <width>96</width>
+        <width>100</width>
         <height>31</height>
        </rect>
       </property>
@@ -436,13 +436,16 @@ frames needed for each mixing update.</string>
         </rect>
        </property>
        <property name="toolTip">
-        <string>Pan Pot uses standard amplitude panning (aka
-pair-wise, stereo pair, etc) between -30 and +30
-degrees, while UHJ creates a stereo-compatible
-two-channel UHJ mix, which encodes some
-surround sound information into stereo output
-that can be decoded with a surround sound
-receiver.</string>
+        <string>Basic uses standard amplitude panning (aka
+pair-wise, stereo pair, etc).
+
+UHJ creates a stereo-compatible two-channel
+UHJ mix, which encodes some surround sound
+information into stereo output that can be
+decoded with a surround sound receiver.
+
+Binaural applies HRTF filters to create an
+illusion of 3D placement with headphones.</string>
        </property>
       </widget>
       <widget class="QLabel" name="label_19">
@@ -622,9 +625,7 @@ quantization with low-level whitenoise.</string>
        <string>Enables high-quality ambisonic rendering. This mode is
 capable of frequency-dependent processing, creating a
 better reproduction of 3D sound rendering over
-surround sound speakers. Enabling this also requires
-specifying decoder configuration files for the
-appropriate speaker configuration you intend to use.</string>
+surround sound speakers.</string>
       </property>
       <property name="layoutDirection">
        <enum>Qt::RightToLeft</enum>
@@ -632,6 +633,9 @@ appropriate speaker configuration you intend to use.</string>
       <property name="text">
        <string>High Quality Mode:</string>
       </property>
+      <property name="tristate">
+       <bool>true</bool>
+      </property>
      </widget>
      <widget class="QCheckBox" name="decoderDistCompCheckBox">
       <property name="geometry">
@@ -664,9 +668,9 @@ configuration file.</string>
       <property name="geometry">
        <rect>
         <x>-10</x>
-        <y>160</y>
+        <y>140</y>
         <width>551</width>
-        <height>161</height>
+        <height>231</height>
        </rect>
       </property>
       <property name="title">
@@ -678,10 +682,10 @@ configuration file.</string>
       <widget class="QLineEdit" name="decoderQuadLineEdit">
        <property name="geometry">
         <rect>
-         <x>120</x>
+         <x>130</x>
          <y>30</y>
-         <width>311</width>
-         <height>21</height>
+         <width>301</width>
+         <height>25</height>
         </rect>
        </property>
       </widget>
@@ -690,8 +694,8 @@ configuration file.</string>
         <rect>
          <x>20</x>
          <y>30</y>
-         <width>91</width>
-         <height>21</height>
+         <width>101</width>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -707,7 +711,7 @@ configuration file.</string>
          <x>440</x>
          <y>30</y>
          <width>91</width>
-         <height>21</height>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -717,10 +721,10 @@ configuration file.</string>
       <widget class="QLineEdit" name="decoder51LineEdit">
        <property name="geometry">
         <rect>
-         <x>120</x>
-         <y>60</y>
-         <width>311</width>
-         <height>21</height>
+         <x>130</x>
+         <y>70</y>
+         <width>301</width>
+         <height>25</height>
         </rect>
        </property>
       </widget>
@@ -728,9 +732,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>440</x>
-         <y>60</y>
+         <y>70</y>
          <width>91</width>
-         <height>21</height>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -741,9 +745,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>20</x>
-         <y>60</y>
-         <width>91</width>
-         <height>21</height>
+         <y>70</y>
+         <width>101</width>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -757,9 +761,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>20</x>
-         <y>90</y>
-         <width>91</width>
-         <height>21</height>
+         <y>110</y>
+         <width>101</width>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -772,10 +776,10 @@ configuration file.</string>
       <widget class="QLineEdit" name="decoder61LineEdit">
        <property name="geometry">
         <rect>
-         <x>120</x>
-         <y>90</y>
-         <width>311</width>
-         <height>21</height>
+         <x>130</x>
+         <y>110</y>
+         <width>301</width>
+         <height>25</height>
         </rect>
        </property>
       </widget>
@@ -783,9 +787,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>440</x>
-         <y>90</y>
+         <y>110</y>
          <width>91</width>
-         <height>21</height>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -796,9 +800,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>440</x>
-         <y>120</y>
+         <y>150</y>
          <width>91</width>
-         <height>21</height>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -808,10 +812,10 @@ configuration file.</string>
       <widget class="QLineEdit" name="decoder71LineEdit">
        <property name="geometry">
         <rect>
-         <x>120</x>
-         <y>120</y>
-         <width>311</width>
-         <height>21</height>
+         <x>130</x>
+         <y>150</y>
+         <width>301</width>
+         <height>25</height>
         </rect>
        </property>
       </widget>
@@ -819,9 +823,9 @@ configuration file.</string>
        <property name="geometry">
         <rect>
          <x>20</x>
-         <y>120</y>
-         <width>91</width>
-         <height>21</height>
+         <y>150</y>
+         <width>101</width>
+         <height>25</height>
         </rect>
        </property>
        <property name="text">
@@ -831,6 +835,45 @@ configuration file.</string>
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
+      <widget class="QLabel" name="label_33">
+       <property name="geometry">
+        <rect>
+         <x>20</x>
+         <y>190</y>
+         <width>101</width>
+         <height>25</height>
+        </rect>
+       </property>
+       <property name="text">
+        <string>3D7.1 Surround:</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+      </widget>
+      <widget class="QLineEdit" name="decoder3D71LineEdit">
+       <property name="geometry">
+        <rect>
+         <x>130</x>
+         <y>190</y>
+         <width>301</width>
+         <height>25</height>
+        </rect>
+       </property>
+      </widget>
+      <widget class="QPushButton" name="decoder3D71Button">
+       <property name="geometry">
+        <rect>
+         <x>440</x>
+         <y>190</y>
+         <width>91</width>
+         <height>25</height>
+        </rect>
+       </property>
+       <property name="text">
+        <string>Browse...</string>
+       </property>
+      </widget>
      </widget>
      <widget class="QCheckBox" name="decoderNFEffectsCheckBox">
       <property name="geometry">
@@ -863,60 +906,63 @@ are set in the decoder configuration file.</string>
      <widget class="QWidget" name="widget_3" native="true">
       <property name="geometry">
        <rect>
-        <x>-10</x>
+        <x>30</x>
         <y>110</y>
-        <width>281</width>
+        <width>471</width>
         <height>21</height>
        </rect>
       </property>
       <property name="toolTip">
-       <string>The reference delay value for ambisonic output. When
-Channels is set to one of the Ambisonic formats, this
-option enables NFC-HOA output with the specified
-Reference Delay parameter. The specified value can then
-be shared with an appropriate NFC-HOA decoder to
-reproduce correct near-field effects. Keep in mind that
-despite being designed for higher-order ambisonics, this
-applies to first-order output all the same. When left unset,
-normal output is created with no near-field simulation.</string>
+       <string>Specifies the speaker distance in meters, used by the near-field control
+filters with surround sound output. For ambisonic output modes, this value
+is the basis for the NFC-HOA Reference Delay parameter (calculated as
+delay_seconds = speaker_dist/343.3). This value is not used when a decoder
+configuration is set for the output mode (since they specify the per-speaker
+distances, overriding this setting), or when the NFC filters are off.</string>
       </property>
       <widget class="QLabel" name="label_27">
        <property name="geometry">
         <rect>
-         <x>20</x>
+         <x>45</x>
          <y>0</y>
-         <width>171</width>
+         <width>111</width>
          <height>21</height>
         </rect>
        </property>
        <property name="text">
-        <string>Near-Field Reference Delay:</string>
+        <string>Speaker Distance:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
-      <widget class="QDoubleSpinBox" name="decoderNFRefDelaySpinBox">
+      <widget class="QDoubleSpinBox" name="decoderSpeakerDistSpinBox">
        <property name="geometry">
         <rect>
-         <x>200</x>
+         <x>165</x>
          <y>0</y>
-         <width>81</width>
+         <width>101</width>
          <height>21</height>
         </rect>
        </property>
        <property name="suffix">
-        <string>sec</string>
+        <string> meters</string>
        </property>
        <property name="decimals">
-        <number>4</number>
+        <number>2</number>
+       </property>
+       <property name="minimum">
+        <double>0.100000000000000</double>
        </property>
        <property name="maximum">
-        <double>1000.000000000000000</double>
+        <double>10.000000000000000</double>
        </property>
        <property name="singleStep">
         <double>0.010000000000000</double>
        </property>
+       <property name="value">
+        <double>1.000000000000000</double>
+       </property>
       </widget>
      </widget>
     </widget>
@@ -1044,54 +1090,6 @@ listed above.</string>
        </widget>
       </widget>
      </widget>
-     <widget class="QLabel" name="label_16">
-      <property name="geometry">
-       <rect>
-        <x>50</x>
-        <y>60</y>
-        <width>71</width>
-        <height>31</height>
-       </rect>
-      </property>
-      <property name="text">
-       <string>HRTF Mode:</string>
-      </property>
-      <property name="alignment">
-       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-      </property>
-     </widget>
-     <widget class="QComboBox" name="hrtfStateComboBox">
-      <property name="geometry">
-       <rect>
-        <x>130</x>
-        <y>60</y>
-        <width>161</width>
-        <height>31</height>
-       </rect>
-      </property>
-      <property name="toolTip">
-       <string>Forces HRTF processing on or off, or leaves it to the
-application or system to determine if it should be used.</string>
-      </property>
-      <property name="sizeAdjustPolicy">
-       <enum>QComboBox::AdjustToContentsOnFirstShow</enum>
-      </property>
-      <item>
-       <property name="text">
-        <string>Application preference</string>
-       </property>
-      </item>
-      <item>
-       <property name="text">
-        <string>Force on</string>
-       </property>
-      </item>
-      <item>
-       <property name="text">
-        <string>Force off</string>
-       </property>
-      </item>
-     </widget>
      <widget class="QLabel" name="label_12">
       <property name="geometry">
        <rect>
@@ -1216,6 +1214,16 @@ application or system to determine if it should be used.</string>
       </item>
       <item>
        <property name="text">
+        <string>PipeWire</string>
+       </property>
+      </item>
+      <item>
+       <property name="text">
+        <string>WASAPI</string>
+       </property>
+      </item>
+      <item>
+       <property name="text">
         <string>PulseAudio</string>
        </property>
       </item>
@@ -1334,7 +1342,79 @@ duplicated names are ignored.</string>
         </property>
        </widget>
       </widget>
+      <widget class="QWidget" name="page_1">
+       <widget class="QCheckBox" name="pwireAssumeAudioCheckBox">
+        <property name="geometry">
+         <rect>
+          <x>20</x>
+          <y>10</y>
+          <width>161</width>
+          <height>21</height>
+         </rect>
+        </property>
+        <property name="toolTip">
+         <string>Assumes PipeWire has support for audio, allowing
+the backend to initialize even when no audio devices
+are reported.</string>
+        </property>
+        <property name="text">
+         <string>Assume audio support</string>
+        </property>
+        <property name="tristate">
+         <bool>true</bool>
+        </property>
+       </widget>
+       <widget class="QCheckBox" name="pwireRtMixCheckBox">
+        <property name="geometry">
+         <rect>
+          <x>20</x>
+          <y>40</y>
+          <width>161</width>
+          <height>21</height>
+         </rect>
+        </property>
+        <property name="toolTip">
+         <string>Renders samples directly in the real-time
+processing callback. This allows for lower
+latency and less overall CPU utilization, but
+can increase the risk of underruns when
+increasing the amount of processing the
+mixer needs to do.</string>
+        </property>
+        <property name="text">
+         <string>Real-time Mixing</string>
+        </property>
+        <property name="tristate">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </widget>
       <widget class="QWidget" name="page_2">
+       <widget class="QCheckBox" name="wasapiResamplerCheckBox">
+        <property name="geometry">
+         <rect>
+          <x>20</x>
+          <y>10</y>
+          <width>191</width>
+          <height>21</height>
+         </rect>
+        </property>
+        <property name="toolTip">
+         <string>Specifies whether to allow an extra resampler pass on the output. Enabling
+this will allow the playback device to be set to a different sample rate
+than the actual output can accept, causing the backend to apply its own
+resampling pass after OpenAL Soft mixes the sources and processes effects
+for output.</string>
+        </property>
+        <property name="text">
+         <string>Allow Resampler</string>
+        </property>
+        <property name="tristate">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </widget>
+      <widget class="QWidget" name="page_8">
        <widget class="QCheckBox" name="pulseAutospawnCheckBox">
         <property name="geometry">
          <rect>
@@ -1442,7 +1522,7 @@ drop-outs.</string>
         <property name="geometry">
          <rect>
           <x>10</x>
-          <y>40</y>
+          <y>110</y>
           <width>401</width>
           <height>80</height>
          </rect>
@@ -1450,7 +1530,8 @@ drop-outs.</string>
         <property name="toolTip">
          <string>The update buffer size, in samples, that the backend
 will keep buffered to handle the server's real-time
-processing requests. Must be a power of 2.</string>
+processing requests. Must be a power of 2. Ignored
+when Real-time Mixing is used.</string>
         </property>
         <property name="title">
          <string>Buffer Size</string>
@@ -1500,6 +1581,46 @@ processing requests. Must be a power of 2.</string>
          </property>
         </widget>
        </widget>
+       <widget class="QCheckBox" name="jackConnectPortsCheckBox">
+        <property name="geometry">
+         <rect>
+          <x>20</x>
+          <y>40</y>
+          <width>141</width>
+          <height>21</height>
+         </rect>
+        </property>
+        <property name="text">
+         <string>AutoConnect Ports</string>
+        </property>
+        <property name="tristate">
+         <bool>true</bool>
+        </property>
+       </widget>
+       <widget class="QCheckBox" name="jackRtMixCheckBox">
+        <property name="geometry">
+         <rect>
+          <x>20</x>
+          <y>70</y>
+          <width>141</width>
+          <height>21</height>
+         </rect>
+        </property>
+        <property name="toolTip">
+         <string>Renders samples directly in the real-time
+processing callback. This allows for lower
+latency and less overall CPU utilization, but
+can increase the risk of underruns when
+increasing the amount of processing the
+mixer needs to do.</string>
+        </property>
+        <property name="text">
+         <string>Real-time Mixing</string>
+        </property>
+        <property name="tristate">
+         <bool>true</bool>
+        </property>
+       </widget>
       </widget>
       <widget class="QWidget" name="page_3">
        <widget class="QLabel" name="label_17">
@@ -2038,7 +2159,7 @@ be useful for preventing those extensions from being used.</string>
       <property name="geometry">
        <rect>
         <x>10</x>
-        <y>100</y>
+        <y>60</y>
         <width>511</width>
         <height>241</height>
        </rect>
@@ -2301,7 +2422,7 @@ added by the ALC_EXT_DEDICATED extension.</string>
        <rect>
         <x>160</x>
         <y>20</y>
-        <width>131</width>
+        <width>135</width>
         <height>31</height>
        </rect>
       </property>
@@ -2444,6 +2565,22 @@ added by the ALC_EXT_DEDICATED extension.</string>
        </property>
       </item>
      </widget>
+     <widget class="QCheckBox" name="enableEaxCheck">
+      <property name="geometry">
+       <rect>
+        <x>30</x>
+        <y>320</y>
+        <width>231</width>
+        <height>21</height>
+       </rect>
+      </property>
+      <property name="toolTip">
+       <string>Enables legacy EAX API support.</string>
+      </property>
+      <property name="text">
+       <string>Enable EAX API support</string>
+      </property>
+     </widget>
     </widget>
    </widget>
    <widget class="QPushButton" name="closeCancelButton">
diff --git a/utils/makemhr/loaddef.cpp b/utils/makemhr/loaddef.cpp
index 619f5104..e8092363 100644
--- a/utils/makemhr/loaddef.cpp
+++ b/utils/makemhr/loaddef.cpp
@@ -26,18 +26,22 @@
 #include <algorithm>
 #include <cctype>
 #include <cmath>
-#include <cstring>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <iterator>
 #include <limits>
 #include <memory>
+#include <cstdarg>
 #include <vector>
 
 #include "alfstream.h"
+#include "aloptional.h"
+#include "alspan.h"
 #include "alstring.h"
 #include "makemhr.h"
+#include "polyphase_resampler.h"
 
 #include "mysofa.h"
 
@@ -1235,7 +1239,8 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
     double distances[MAX_FD_COUNT];
     uint fdCount = 0;
     uint evCounts[MAX_FD_COUNT];
-    std::vector<uint> azCounts(MAX_FD_COUNT * MAX_EV_COUNT);
+    auto azCounts = std::vector<std::array<uint,MAX_EV_COUNT>>(MAX_FD_COUNT);
+    for(auto &azs : azCounts) azs.fill(0u);
 
     TrIndication(tr, &line, &col);
     while(TrIsIdent(tr))
@@ -1384,7 +1389,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             {
                 if(!TrReadInt(tr, MIN_AZ_COUNT, MAX_AZ_COUNT, &intVal))
                     return 0;
-                azCounts[(count * MAX_EV_COUNT) + evCounts[count]++] = static_cast<uint>(intVal);
+                azCounts[count][evCounts[count]++] = static_cast<uint>(intVal);
                 if(TrIsOperator(tr, ","))
                 {
                     if(evCounts[count] >= MAX_EV_COUNT)
@@ -1401,7 +1406,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
                         TrErrorAt(tr, line, col, "Did not reach the minimum of %d azimuth counts.\n", MIN_EV_COUNT);
                         return 0;
                     }
-                    if(azCounts[count * MAX_EV_COUNT] != 1 || azCounts[(count * MAX_EV_COUNT) + evCounts[count] - 1] != 1)
+                    if(azCounts[count][0] != 1 || azCounts[count][evCounts[count] - 1] != 1)
                     {
                         TrError(tr, "Poles are not singular for field %d.\n", count - 1);
                         return 0;
@@ -1446,7 +1451,8 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
     }
     if(hData->mChannelType == CT_NONE)
         hData->mChannelType = CT_MONO;
-    if(!PrepareHrirData(fdCount, distances, evCounts, azCounts.data(), hData))
+    const auto azs = al::as_span(azCounts).first<MAX_FD_COUNT>();
+    if(!PrepareHrirData({distances, fdCount}, evCounts, azs, hData))
     {
         fprintf(stderr, "Error:  Out of memory.\n");
         exit(-1);
@@ -1459,9 +1465,9 @@ static int ReadIndexTriplet(TokenReaderT *tr, const HrirDataT *hData, uint *fi,
 {
     int intVal;
 
-    if(hData->mFdCount > 1)
+    if(hData->mFds.size() > 1)
     {
-        if(!TrReadInt(tr, 0, static_cast<int>(hData->mFdCount) - 1, &intVal))
+        if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds.size()-1), &intVal))
             return 0;
         *fi = static_cast<uint>(intVal);
         if(!TrReadOperator(tr, ","))
@@ -1471,12 +1477,12 @@ static int ReadIndexTriplet(TokenReaderT *tr, const HrirDataT *hData, uint *fi,
     {
         *fi = 0;
     }
-    if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvCount) - 1, &intVal))
+    if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvs.size()-1), &intVal))
         return 0;
     *ei = static_cast<uint>(intVal);
     if(!TrReadOperator(tr, ","))
         return 0;
-    if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvs[*ei].mAzCount) - 1, &intVal))
+    if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvs[*ei].mAzs.size()-1), &intVal))
         return 0;
     *ai = static_cast<uint>(intVal);
     return 1;
@@ -1706,27 +1712,16 @@ static int MatchTargetEar(const char *ident)
 
 // Calculate the onset time of an HRIR and average it with any existing
 // timing for its field, elevation, azimuth, and ear.
-static double AverageHrirOnset(const uint rate, const uint n, const double *hrir, const double f, const double onset)
+static constexpr int OnsetRateMultiple{10};
+static double AverageHrirOnset(PPhaseResampler &rs, al::span<double> upsampled, const uint rate,
+    const uint n, const double *hrir, const double f, const double onset)
 {
-    std::vector<double> upsampled(10 * n);
-    {
-        ResamplerT rs;
-        ResamplerSetup(&rs, rate, 10 * rate);
-        ResamplerRun(&rs, n, hrir, 10 * n, upsampled.data());
-    }
-
-    double mag{0.0};
-    for(uint i{0u};i < 10*n;i++)
-        mag = std::max(std::abs(upsampled[i]), mag);
+    rs.process(n, hrir, static_cast<uint>(upsampled.size()), upsampled.data());
 
-    mag *= 0.15;
-    uint i{0u};
-    for(;i < 10*n;i++)
-    {
-        if(std::abs(upsampled[i]) >= mag)
-            break;
-    }
-    return Lerp(onset, static_cast<double>(i) / (10*rate), f);
+    auto abs_lt = [](const double &lhs, const double &rhs) -> bool
+    { return std::abs(lhs) < std::abs(rhs); };
+    auto iter = std::max_element(upsampled.cbegin(), upsampled.cend(), abs_lt);
+    return Lerp(onset, static_cast<double>(std::distance(upsampled.cbegin(), iter))/(10*rate), f);
 }
 
 // Calculate the magnitude response of an HRIR and average it with any
@@ -1738,9 +1733,9 @@ static void AverageHrirMagnitude(const uint points, const uint n, const double *
     std::vector<double> r(n);
 
     for(i = 0;i < points;i++)
-        h[i] = complex_d{hrir[i], 0.0};
+        h[i] = hrir[i];
     for(;i < n;i++)
-        h[i] = complex_d{0.0, 0.0};
+        h[i] = 0.0;
     FftForward(n, h.data());
     MagnitudeResponse(n, h.data(), r.data());
     for(i = 0;i < m;i++)
@@ -1748,18 +1743,29 @@ static void AverageHrirMagnitude(const uint points, const uint n, const double *
 }
 
 // Process the list of sources in the data set definition.
-static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
+static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate)
 {
-    uint channels = (hData->mChannelType == CT_STEREO) ? 2 : 1;
+    const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
     hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize);
     double *hrirs = hData->mHrirsBase.data();
-    std::vector<double> hrir(hData->mIrPoints);
+    auto hrir = std::make_unique<double[]>(hData->mIrSize);
     uint line, col, fi, ei, ai;
-    int count;
+
+    std::vector<double> onsetSamples(OnsetRateMultiple * hData->mIrPoints);
+    PPhaseResampler onsetResampler;
+    onsetResampler.init(hData->mIrRate, OnsetRateMultiple*hData->mIrRate);
+
+    al::optional<PPhaseResampler> resampler;
+    if(outRate && outRate != hData->mIrRate)
+        resampler.emplace().init(hData->mIrRate, outRate);
+    const double rateScale{outRate ? static_cast<double>(outRate) / hData->mIrRate : 1.0};
+    const uint irPoints{outRate
+        ? std::min(static_cast<uint>(std::ceil(hData->mIrPoints*rateScale)), hData->mIrPoints)
+        : hData->mIrPoints};
 
     printf("Loading sources...");
     fflush(stdout);
-    count = 0;
+    int count{0};
     while(TrIsOperator(tr, "["))
     {
         double factor[2]{ 1.0, 1.0 };
@@ -1841,45 +1847,53 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
                 else
                     aer[0] = std::fmod(360.0f - aer[0], 360.0f);
 
-                for(fi = 0;fi < hData->mFdCount;fi++)
-                {
-                    double delta = aer[2] - hData->mFds[fi].mDistance;
-                    if(std::abs(delta) < 0.001) break;
-                }
-                if(fi >= hData->mFdCount)
+                auto field = std::find_if(hData->mFds.cbegin(), hData->mFds.cend(),
+                    [&aer](const HrirFdT &fld) -> bool
+                    { return (std::abs(aer[2] - fld.mDistance) < 0.001); });
+                if(field == hData->mFds.cend())
                     continue;
+                fi = static_cast<uint>(std::distance(hData->mFds.cbegin(), field));
 
-                double ef{(90.0 + aer[1]) / 180.0 * (hData->mFds[fi].mEvCount - 1)};
+                const double evscale{180.0 / static_cast<double>(field->mEvs.size()-1)};
+                double ef{(90.0 + aer[1]) / evscale};
                 ei = static_cast<uint>(std::round(ef));
-                ef = (ef - ei) * 180.0 / (hData->mFds[fi].mEvCount - 1);
+                ef = (ef - ei) * evscale;
                 if(std::abs(ef) >= 0.1)
                     continue;
 
-                double af{aer[0] / 360.0 * hData->mFds[fi].mEvs[ei].mAzCount};
+                const double azscale{360.0 / static_cast<double>(field->mEvs[ei].mAzs.size())};
+                double af{aer[0] / azscale};
                 ai = static_cast<uint>(std::round(af));
-                af = (af - ai) * 360.0 / hData->mFds[fi].mEvs[ei].mAzCount;
-                ai = ai % hData->mFds[fi].mEvs[ei].mAzCount;
+                af = (af - ai) * azscale;
+                ai %= static_cast<uint>(field->mEvs[ei].mAzs.size());
                 if(std::abs(af) >= 0.1)
                     continue;
 
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
+                HrirAzT *azd = &field->mEvs[ei].mAzs[ai];
                 if(azd->mIrs[0] != nullptr)
                 {
                     TrErrorAt(tr, line, col, "Redefinition of source [ %d, %d, %d ].\n", fi, ei, ai);
                     return 0;
                 }
 
-                ExtractSofaHrir(sofa, si, 0, src.mOffset, hData->mIrPoints, hrir.data());
+                ExtractSofaHrir(sofa, si, 0, src.mOffset, hData->mIrPoints, hrir.get());
                 azd->mIrs[0] = &hrirs[hData->mIrSize * azd->mIndex];
-                azd->mDelays[0] = AverageHrirOnset(hData->mIrRate, hData->mIrPoints, hrir.data(), 1.0, azd->mDelays[0]);
-                AverageHrirMagnitude(hData->mIrPoints, hData->mFftSize, hrir.data(), 1.0, azd->mIrs[0]);
+                azd->mDelays[0] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
+                    hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[0]);
+                if(resampler)
+                    resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
+                AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[0]);
 
                 if(src.mChannel == 1)
                 {
-                    ExtractSofaHrir(sofa, si, 1, src.mOffset, hData->mIrPoints, hrir.data());
+                    ExtractSofaHrir(sofa, si, 1, src.mOffset, hData->mIrPoints, hrir.get());
                     azd->mIrs[1] = &hrirs[hData->mIrSize * (hData->mIrCount + azd->mIndex)];
-                    azd->mDelays[1] = AverageHrirOnset(hData->mIrRate, hData->mIrPoints, hrir.data(), 1.0, azd->mDelays[1]);
-                    AverageHrirMagnitude(hData->mIrPoints, hData->mFftSize, hrir.data(), 1.0, azd->mIrs[1]);
+                    azd->mDelays[1] = AverageHrirOnset(onsetResampler, onsetSamples,
+                        hData->mIrRate, hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[1]);
+                    if(resampler)
+                        resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize,
+                            hrir.get());
+                    AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[1]);
                 }
 
                 // TODO: Since some SOFA files contain minimum phase HRIRs,
@@ -1918,7 +1932,7 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
             printf("\rLoading sources... %d file%s", count, (count==1)?"":"s");
             fflush(stdout);
 
-            if(!LoadSource(&src, hData->mIrRate, hData->mIrPoints, hrir.data()))
+            if(!LoadSource(&src, hData->mIrRate, hData->mIrPoints, hrir.get()))
                 return 0;
 
             uint ti{0};
@@ -1936,8 +1950,12 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
                 }
             }
             azd->mIrs[ti] = &hrirs[hData->mIrSize * (ti * hData->mIrCount + azd->mIndex)];
-            azd->mDelays[ti] = AverageHrirOnset(hData->mIrRate, hData->mIrPoints, hrir.data(), 1.0 / factor[ti], azd->mDelays[ti]);
-            AverageHrirMagnitude(hData->mIrPoints, hData->mFftSize, hrir.data(), 1.0 / factor[ti], azd->mIrs[ti]);
+            azd->mDelays[ti] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
+                hData->mIrPoints, hrir.get(), 1.0 / factor[ti], azd->mDelays[ti]);
+            if(resampler)
+                resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
+            AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0 / factor[ti],
+                azd->mIrs[ti]);
             factor[ti] += 1.0;
             if(!TrIsOperator(tr, "+"))
                 break;
@@ -1958,28 +1976,35 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
         }
     }
     printf("\n");
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    hrir = nullptr;
+    if(resampler)
+    {
+        hData->mIrRate = outRate;
+        hData->mIrPoints = irPoints;
+        resampler.reset();
+    }
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = 0;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
                 if(azd->mIrs[0] != nullptr)
                     break;
             }
-            if(ai < hData->mFds[fi].mEvs[ei].mAzCount)
+            if(ai < hData->mFds[fi].mEvs[ei].mAzs.size())
                 break;
         }
-        if(ei >= hData->mFds[fi].mEvCount)
+        if(ei >= hData->mFds[fi].mEvs.size())
         {
             TrError(tr, "Missing source references [ %d, *, * ].\n", fi);
             return 0;
         }
         hData->mFds[fi].mEvStart = ei;
-        for(;ei < hData->mFds[fi].mEvCount;ei++)
+        for(;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
 
@@ -1993,11 +2018,11 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
     }
     for(uint ti{0};ti < channels;ti++)
     {
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(fi = 0;fi < hData->mFds.size();fi++)
         {
-            for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+            for(ei = 0;ei < hData->mFds[fi].mEvs.size();ei++)
             {
-                for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+                for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
                 {
                     HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
 
@@ -2019,14 +2044,14 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData)
 
 
 bool LoadDefInput(std::istream &istream, const char *startbytes, std::streamsize startbytecount,
-    const char *filename, const uint fftSize, const uint truncSize, const ChannelModeT chanMode,
-    HrirDataT *hData)
+    const char *filename, const uint fftSize, const uint truncSize, const uint outRate,
+    const ChannelModeT chanMode, HrirDataT *hData)
 {
     TokenReaderT tr{istream};
 
     TrSetup(startbytes, startbytecount, filename, &tr);
     if(!ProcessMetrics(&tr, fftSize, truncSize, chanMode, hData)
-        || !ProcessSources(&tr, hData))
+        || !ProcessSources(&tr, hData, outRate))
         return false;
 
     return true;
diff --git a/utils/makemhr/loaddef.h b/utils/makemhr/loaddef.h
index 34fbb832..63600dcd 100644
--- a/utils/makemhr/loaddef.h
+++ b/utils/makemhr/loaddef.h
@@ -7,7 +7,7 @@
 
 
 bool LoadDefInput(std::istream &istream, const char *startbytes, std::streamsize startbytecount,
-    const char *filename, const uint fftSize, const uint truncSize, const ChannelModeT chanMode,
-    HrirDataT *hData);
+    const char *filename, const uint fftSize, const uint truncSize, const uint outRate,
+    const ChannelModeT chanMode, HrirDataT *hData);
 
 #endif /* LOADDEF_H */
diff --git a/utils/makemhr/loadsofa.cpp b/utils/makemhr/loadsofa.cpp
index c91613c8..dcb0a35e 100644
--- a/utils/makemhr/loadsofa.cpp
+++ b/utils/makemhr/loadsofa.cpp
@@ -24,146 +24,29 @@
 #include "loadsofa.h"
 
 #include <algorithm>
-#include <array>
+#include <atomic>
+#include <chrono>
 #include <cmath>
 #include <cstdio>
+#include <functional>
+#include <future>
 #include <iterator>
 #include <memory>
 #include <numeric>
 #include <string>
+#include <thread>
 #include <vector>
 
+#include "aloptional.h"
+#include "alspan.h"
 #include "makemhr.h"
+#include "polyphase_resampler.h"
+#include "sofa-support.h"
 
 #include "mysofa.h"
 
 
-using double3 = std::array<double,3>;
-
-static const char *SofaErrorStr(int err)
-{
-    switch(err)
-    {
-    case MYSOFA_OK: return "OK";
-    case MYSOFA_INVALID_FORMAT: return "Invalid format";
-    case MYSOFA_UNSUPPORTED_FORMAT: return "Unsupported format";
-    case MYSOFA_INTERNAL_ERROR: return "Internal error";
-    case MYSOFA_NO_MEMORY: return "Out of memory";
-    case MYSOFA_READ_ERROR: return "Read error";
-    }
-    return "Unknown";
-}
-
-
-/* Produces a sorted array of unique elements from a particular axis of the
- * triplets array.  The filters are used to focus on particular coordinates
- * of other axes as necessary.  The epsilons are used to constrain the
- * equality of unique elements.
- */
-static uint GetUniquelySortedElems(const uint m, const double3 *aers, const uint axis,
-    const double *const (&filters)[3], const double (&epsilons)[3], double *elems)
-{
-    uint count{0u};
-    for(uint i{0u};i < m;++i)
-    {
-        const double elem{aers[i][axis]};
-
-        uint j;
-        for(j = 0;j < 3;j++)
-        {
-            if(filters[j] && std::fabs(aers[i][j] - *filters[j]) > epsilons[j])
-                break;
-        }
-        if(j < 3)
-            continue;
-
-        for(j = 0;j < count;j++)
-        {
-            const double delta{elem - elems[j]};
-
-            if(delta > epsilons[axis])
-                continue;
-
-            if(delta >= -epsilons[axis])
-                break;
-
-            for(uint k{count};k > j;k--)
-                elems[k] = elems[k - 1];
-
-            elems[j] = elem;
-            count++;
-            break;
-        }
-
-        if(j >= count)
-            elems[count++] = elem;
-    }
-
-    return count;
-}
-
-/* Given a list of elements, this will produce the smallest step size that
- * can uniformly cover a fair portion of the list.  Ideally this will be over
- * half, but in degenerate cases this can fall to a minimum of 5 (the lower
- * limit on elevations necessary to build a layout).
- */
-static double GetUniformStepSize(const double epsilon, const uint m, const double *elems)
-{
-    auto steps = std::vector<double>(m, 0.0);
-    auto counts = std::vector<uint>(m, 0u);
-    uint count{0u};
-
-    for(uint stride{1u};stride < m/2;stride++)
-    {
-        for(uint i{0u};i < m-stride;i++)
-        {
-            const double step{elems[i + stride] - elems[i]};
-
-            uint j;
-            for(j = 0;j < count;j++)
-            {
-                if(std::fabs(step - steps[j]) < epsilon)
-                {
-                    counts[j]++;
-                    break;
-                }
-            }
-
-            if(j >= count)
-            {
-                steps[j] = step;
-                counts[j] = 1;
-                count++;
-            }
-        }
-
-        for(uint i{1u};i < count;i++)
-        {
-            if(counts[i] > counts[0])
-            {
-                steps[0] = steps[i];
-                counts[0] = counts[i];
-            }
-        }
-
-        count = 1;
-
-        if(counts[0] > m/2)
-            break;
-    }
-
-    if(counts[0] > 255)
-    {
-        uint i{2u};
-        while(counts[0]/i > 255 && (counts[0]%i) != 0)
-            ++i;
-        counts[0] /= i;
-        steps[0] *= i;
-    }
-    if(counts[0] > 5)
-        return steps[0];
-    return 0.0;
-}
+using uint = unsigned int;
 
 /* Attempts to produce a compatible layout.  Most data sets tend to be
  * uniform and have the same major axis as used by OpenAL Soft's HRTF model.
@@ -173,21 +56,10 @@ static double GetUniformStepSize(const double epsilon, const uint m, const doubl
  */
 static bool PrepareLayout(const uint m, const float *xyzs, HrirDataT *hData)
 {
-    auto aers = std::vector<double3>(m, double3{});
-    auto elems = std::vector<double>(m, 0.0);
+    fprintf(stdout, "Detecting compatible layout...\n");
 
-    for(uint i{0u};i < m;++i)
-    {
-        float aer[3]{xyzs[i*3], xyzs[i*3 + 1], xyzs[i*3 + 2]};
-        mysofa_c2s(&aer[0]);
-        aers[i][0] = aer[0];
-        aers[i][1] = aer[1];
-        aers[i][2] = aer[2];
-    }
-
-    const uint fdCount{GetUniquelySortedElems(m, aers.data(), 2, { nullptr, nullptr, nullptr },
-        { 0.1, 0.1, 0.001 }, elems.data())};
-    if(fdCount > MAX_FD_COUNT)
+    auto fds = GetCompatibleLayout(m, xyzs);
+    if(fds.size() > MAX_FD_COUNT)
     {
         fprintf(stdout, "Incompatible layout (inumerable radii).\n");
         return false;
@@ -195,107 +67,32 @@ static bool PrepareLayout(const uint m, const float *xyzs, HrirDataT *hData)
 
     double distances[MAX_FD_COUNT]{};
     uint evCounts[MAX_FD_COUNT]{};
-    auto azCounts = std::vector<uint>(MAX_FD_COUNT*MAX_EV_COUNT, 0u);
-    for(uint fi{0u};fi < fdCount;fi++)
-    {
-        distances[fi] = elems[fi];
-        if(fi > 0 && distances[fi] <= distances[fi-1])
-        {
-            fprintf(stderr, "Distances must increase.\n");
-            return 0;
-        }
-    }
-    if(distances[0] < hData->mRadius)
-    {
-        fprintf(stderr, "Distance cannot start below head radius.\n");
-        return 0;
-    }
+    auto azCounts = std::vector<std::array<uint,MAX_EV_COUNT>>(MAX_FD_COUNT);
+    for(auto &azs : azCounts) azs.fill(0u);
 
-    for(uint fi{0u};fi < fdCount;fi++)
+    uint fi{0u}, ir_total{0u};
+    for(const auto &field : fds)
     {
-        const double dist{distances[fi]};
-        uint evCount{GetUniquelySortedElems(m, aers.data(), 1, { nullptr, nullptr, &dist },
-            { 0.1, 0.1, 0.001 }, elems.data())};
-
-        if(evCount > MAX_EV_COUNT)
-        {
-            fprintf(stderr, "Incompatible layout (innumerable elevations).\n");
-            return false;
-        }
-
-        double step{GetUniformStepSize(0.1, evCount, elems.data())};
-        if(step <= 0.0)
-        {
-            fprintf(stderr, "Incompatible layout (non-uniform elevations).\n");
-            return false;
-        }
+        distances[fi] = field.mDistance;
+        evCounts[fi] = field.mEvCount;
 
-        uint evStart{0u};
-        for(uint ei{0u};ei < evCount;ei++)
+        for(uint ei{0u};ei < field.mEvStart;ei++)
+            azCounts[fi][ei] = field.mAzCounts[field.mEvCount-ei-1];
+        for(uint ei{field.mEvStart};ei < field.mEvCount;ei++)
         {
-            double ev{90.0 + elems[ei]};
-            double eif{std::round(ev / step)};
-            const uint ei_start{static_cast<uint>(eif)};
-
-            if(std::fabs(eif - static_cast<double>(ei_start)) < (0.1/step))
-            {
-                evStart = ei_start;
-                break;
-            }
-        }
-
-        evCount = static_cast<uint>(std::round(180.0 / step)) + 1;
-        if(evCount < 5)
-        {
-            fprintf(stderr, "Incompatible layout (too few uniform elevations).\n");
-            return false;
-        }
-
-        evCounts[fi] = evCount;
-
-        for(uint ei{evStart};ei < evCount;ei++)
-        {
-            const double ev{-90.0 + ei*180.0/(evCount - 1)};
-            const uint azCount{GetUniquelySortedElems(m, aers.data(), 0, { nullptr, &ev, &dist },
-                { 0.1, 0.1, 0.001 }, elems.data())};
-
-            if(ei > 0 && ei < (evCount - 1))
-            {
-                step = GetUniformStepSize(0.1, azCount, elems.data());
-                if(step <= 0.0)
-                {
-                    fprintf(stderr, "Incompatible layout (non-uniform azimuths).\n");
-                    return false;
-                }
-
-                azCounts[fi*MAX_EV_COUNT + ei] = static_cast<uint>(std::round(360.0 / step));
-                if(azCounts[fi*MAX_EV_COUNT + ei] > MAX_AZ_COUNT)
-                {
-                    fprintf(stderr,
-                        "Incompatible layout (too many azimuths on elev=%f, rad=%f, %u > %u).\n",
-                         ev, dist, azCounts[fi*MAX_EV_COUNT + ei], MAX_AZ_COUNT);
-                    return false;
-                }
-            }
-            else if(azCount != 1)
-            {
-                fprintf(stderr, "Incompatible layout (non-singular poles).\n");
-                return false;
-            }
-            else
-            {
-                azCounts[fi*MAX_EV_COUNT + ei] = 1;
-            }
+            azCounts[fi][ei] = field.mAzCounts[ei];
+            ir_total += field.mAzCounts[ei];
         }
 
-        for(uint ei{0u};ei < evStart;ei++)
-            azCounts[fi*MAX_EV_COUNT + ei] = azCounts[fi*MAX_EV_COUNT + evCount - ei - 1];
+        ++fi;
     }
-    return PrepareHrirData(fdCount, distances, evCounts, azCounts.data(), hData) != 0;
+    fprintf(stdout, "Using %u of %u IRs.\n", ir_total, m);
+    const auto azs = al::as_span(azCounts).first<MAX_FD_COUNT>();
+    return PrepareHrirData({distances, fi}, evCounts, azs, hData);
 }
 
 
-bool PrepareSampleRate(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
+float GetSampleRate(MYSOFA_HRTF *sofaHrtf)
 {
     const char *srate_dim{nullptr};
     const char *srate_units{nullptr};
@@ -308,7 +105,7 @@ bool PrepareSampleRate(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
             if(srate_dim)
             {
                 fprintf(stderr, "Duplicate SampleRate.DIMENSION_LIST\n");
-                return false;
+                return 0.0f;
             }
             srate_dim = srate_attrs->value;
         }
@@ -317,7 +114,7 @@ bool PrepareSampleRate(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
             if(srate_units)
             {
                 fprintf(stderr, "Duplicate SampleRate.Units\n");
-                return false;
+                return 0.0f;
             }
             srate_units = srate_attrs->value;
         }
@@ -329,35 +126,40 @@ bool PrepareSampleRate(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
     if(!srate_dim)
     {
         fprintf(stderr, "Missing sample rate dimensions\n");
-        return false;
+        return 0.0f;
     }
     if(srate_dim != std::string{"I"})
     {
         fprintf(stderr, "Unsupported sample rate dimensions: %s\n", srate_dim);
-        return false;
+        return 0.0f;
     }
     if(!srate_units)
     {
         fprintf(stderr, "Missing sample rate unit type\n");
-        return false;
+        return 0.0f;
     }
     if(srate_units != std::string{"hertz"})
     {
         fprintf(stderr, "Unsupported sample rate unit type: %s\n", srate_units);
-        return false;
+        return 0.0f;
     }
     /* I dimensions guarantees 1 element, so just extract it. */
-    hData->mIrRate = static_cast<uint>(srate_array->values[0] + 0.5f);
-    if(hData->mIrRate < MIN_RATE || hData->mIrRate > MAX_RATE)
+    if(srate_array->values[0] < MIN_RATE || srate_array->values[0] > MAX_RATE)
     {
-        fprintf(stderr, "Sample rate out of range: %u (expected %u to %u)", hData->mIrRate,
+        fprintf(stderr, "Sample rate out of range: %f (expected %u to %u)", srate_array->values[0],
             MIN_RATE, MAX_RATE);
-        return false;
+        return 0.0f;
     }
-    return true;
+    return srate_array->values[0];
 }
 
-bool PrepareDelay(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
+enum class DelayType : uint8_t {
+    None,
+    I_R, /* [1][Channels] */
+    M_R, /* [HRIRs][Channels] */
+    Invalid,
+};
+DelayType PrepareDelay(MYSOFA_HRTF *sofaHrtf)
 {
     const char *delay_dim{nullptr};
     MYSOFA_ARRAY *delay_array{&sofaHrtf->DataDelay};
@@ -369,38 +171,27 @@ bool PrepareDelay(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
             if(delay_dim)
             {
                 fprintf(stderr, "Duplicate Delay.DIMENSION_LIST\n");
-                return false;
+                return DelayType::Invalid;
             }
             delay_dim = delay_attrs->value;
         }
         else
             fprintf(stderr, "Unexpected delay attribute: %s = %s\n", delay_attrs->name,
-                delay_attrs->value);
+                delay_attrs->value ? delay_attrs->value : "<null>");
         delay_attrs = delay_attrs->next;
     }
     if(!delay_dim)
     {
         fprintf(stderr, "Missing delay dimensions\n");
-        /*return false;*/
-    }
-    else if(delay_dim != std::string{"I,R"})
-    {
-        fprintf(stderr, "Unsupported delay dimensions: %s\n", delay_dim);
-        return false;
-    }
-    else if(hData->mChannelType == CT_STEREO)
-    {
-        /* I,R is 1xChannelCount. Makemhr currently removes any delay constant,
-         * so we can ignore this as long as it's equal.
-         */
-        if(delay_array->values[0] != delay_array->values[1])
-        {
-            fprintf(stderr, "Mismatched delays not supported: %f, %f\n", delay_array->values[0],
-                delay_array->values[1]);
-            return false;
-        }
+        return DelayType::None;
     }
-    return true;
+    if(delay_dim == std::string{"I,R"})
+        return DelayType::I_R;
+    else if(delay_dim == std::string{"M,R"})
+        return DelayType::M_R;
+
+    fprintf(stderr, "Unsupported delay dimensions: %s\n", delay_dim);
+    return DelayType::Invalid;
 }
 
 bool CheckIrData(MYSOFA_HRTF *sofaHrtf)
@@ -421,7 +212,7 @@ bool CheckIrData(MYSOFA_HRTF *sofaHrtf)
         }
         else
             fprintf(stderr, "Unexpected IR attribute: %s = %s\n", ir_attrs->name,
-                ir_attrs->value);
+                ir_attrs->value ? ir_attrs->value : "<null>");
         ir_attrs = ir_attrs->next;
     }
     if(!ir_dim)
@@ -439,120 +230,183 @@ bool CheckIrData(MYSOFA_HRTF *sofaHrtf)
 
 
 /* Calculate the onset time of a HRIR. */
-static double CalcHrirOnset(const uint rate, const uint n, std::vector<double> &upsampled,
-    const double *hrir)
+static constexpr int OnsetRateMultiple{10};
+static double CalcHrirOnset(PPhaseResampler &rs, const uint rate, const uint n,
+    al::span<double> upsampled, const double *hrir)
 {
-    {
-        ResamplerT rs;
-        ResamplerSetup(&rs, rate, 10 * rate);
-        ResamplerRun(&rs, n, hrir, 10 * n, upsampled.data());
-    }
-
-    double mag{std::accumulate(upsampled.cbegin(), upsampled.cend(), double{0.0},
-        [](const double magnitude, const double sample) -> double
-        { return std::max(magnitude, std::abs(sample)); })};
+    rs.process(n, hrir, static_cast<uint>(upsampled.size()), upsampled.data());
 
-    mag *= 0.15;
-    auto iter = std::find_if(upsampled.cbegin(), upsampled.cend(),
-        [mag](const double sample) -> bool { return (std::abs(sample) >= mag); });
-    return static_cast<double>(std::distance(upsampled.cbegin(), iter)) / (10.0*rate);
+    auto abs_lt = [](const double &lhs, const double &rhs) -> bool
+    { return std::abs(lhs) < std::abs(rhs); };
+    auto iter = std::max_element(upsampled.cbegin(), upsampled.cend(), abs_lt);
+    return static_cast<double>(std::distance(upsampled.cbegin(), iter)) /
+        (double{OnsetRateMultiple}*rate);
 }
 
 /* Calculate the magnitude response of a HRIR. */
-static void CalcHrirMagnitude(const uint points, const uint n, std::vector<complex_d> &h,
-    const double *hrir, double *mag)
+static void CalcHrirMagnitude(const uint points, const uint n, al::span<complex_d> h, double *hrir)
 {
     auto iter = std::copy_n(hrir, points, h.begin());
     std::fill(iter, h.end(), complex_d{0.0, 0.0});
 
     FftForward(n, h.data());
-    MagnitudeResponse(n, h.data(), mag);
+    MagnitudeResponse(n, h.data(), hrir);
 }
 
-static bool LoadResponses(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData)
+static bool LoadResponses(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData, const DelayType delayType,
+    const uint outRate)
 {
-    const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
-    hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize);
-    double *hrirs = hData->mHrirsBase.data();
-
-    /* Temporary buffers used to calculate the IR's onset and frequency
-     * magnitudes.
-     */
-    auto upsampled = std::vector<double>(10 * hData->mIrPoints);
-    auto htemp = std::vector<complex_d>(hData->mFftSize);
-    auto hrir = std::vector<double>(hData->mFftSize);
+    std::atomic<uint> loaded_count{0u};
 
-    for(uint si{0u};si < sofaHrtf->M;si++)
+    auto load_proc = [sofaHrtf,hData,delayType,outRate,&loaded_count]() -> bool
     {
-        printf("\rLoading HRIRs... %d of %d", si+1, sofaHrtf->M);
-        fflush(stdout);
+        const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
+        hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize, 0.0);
+        double *hrirs = hData->mHrirsBase.data();
+
+        std::unique_ptr<double[]> restmp;
+        al::optional<PPhaseResampler> resampler;
+        if(outRate && outRate != hData->mIrRate)
+        {
+            resampler.emplace().init(hData->mIrRate, outRate);
+            restmp = std::make_unique<double[]>(sofaHrtf->N);
+        }
 
-        float aer[3]{
-            sofaHrtf->SourcePosition.values[3*si],
-            sofaHrtf->SourcePosition.values[3*si + 1],
-            sofaHrtf->SourcePosition.values[3*si + 2]
-        };
-        mysofa_c2s(aer);
+        for(uint si{0u};si < sofaHrtf->M;++si)
+        {
+            loaded_count.fetch_add(1u);
 
-        if(std::abs(aer[1]) >= 89.999f)
-            aer[0] = 0.0f;
-        else
-            aer[0] = std::fmod(360.0f - aer[0], 360.0f);
+            float aer[3]{
+                sofaHrtf->SourcePosition.values[3*si],
+                sofaHrtf->SourcePosition.values[3*si + 1],
+                sofaHrtf->SourcePosition.values[3*si + 2]
+            };
+            mysofa_c2s(aer);
 
-        auto field = std::find_if(hData->mFds.cbegin(), hData->mFds.cend(),
-            [&aer](const HrirFdT &fld) -> bool
+            if(std::abs(aer[1]) >= 89.999f)
+                aer[0] = 0.0f;
+            else
+                aer[0] = std::fmod(360.0f - aer[0], 360.0f);
+
+            auto field = std::find_if(hData->mFds.cbegin(), hData->mFds.cend(),
+                [&aer](const HrirFdT &fld) -> bool
+                { return (std::abs(aer[2] - fld.mDistance) < 0.001); });
+            if(field == hData->mFds.cend())
+                continue;
+
+            const double evscale{180.0 / static_cast<double>(field->mEvs.size()-1)};
+            double ef{(90.0 + aer[1]) / evscale};
+            auto ei = static_cast<uint>(std::round(ef));
+            ef = (ef - ei) * evscale;
+            if(std::abs(ef) >= 0.1) continue;
+
+            const double azscale{360.0 / static_cast<double>(field->mEvs[ei].mAzs.size())};
+            double af{aer[0] / azscale};
+            auto ai = static_cast<uint>(std::round(af));
+            af = (af-ai) * azscale;
+            ai %= static_cast<uint>(field->mEvs[ei].mAzs.size());
+            if(std::abs(af) >= 0.1) continue;
+
+            HrirAzT *azd = &field->mEvs[ei].mAzs[ai];
+            if(azd->mIrs[0] != nullptr)
             {
-                double delta = aer[2] - fld.mDistance;
-                return (std::abs(delta) < 0.001);
-            });
-        if(field == hData->mFds.cend())
-            continue;
-
-        double ef{(90.0+aer[1]) / 180.0 * (field->mEvCount-1)};
-        auto ei = static_cast<int>(std::round(ef));
-        ef = (ef-ei) * 180.0 / (field->mEvCount-1);
-        if(std::abs(ef) >= 0.1) continue;
-
-        double af{aer[0] / 360.0 * field->mEvs[ei].mAzCount};
-        auto ai = static_cast<int>(std::round(af));
-        af = (af-ai) * 360.0 / field->mEvs[ei].mAzCount;
-        ai %= field->mEvs[ei].mAzCount;
-        if(std::abs(af) >= 0.1) continue;
-
-        HrirAzT *azd = &field->mEvs[ei].mAzs[ai];
-        if(azd->mIrs[0] != nullptr)
-        {
-            fprintf(stderr, "Multiple measurements near [ a=%f, e=%f, r=%f ].\n",
-                aer[0], aer[1], aer[2]);
-            return false;
+                fprintf(stderr, "\nMultiple measurements near [ a=%f, e=%f, r=%f ].\n",
+                    aer[0], aer[1], aer[2]);
+                return false;
+            }
+
+            for(uint ti{0u};ti < channels;++ti)
+            {
+                azd->mIrs[ti] = &hrirs[hData->mIrSize * (hData->mIrCount*ti + azd->mIndex)];
+                if(!resampler)
+                    std::copy_n(&sofaHrtf->DataIR.values[(si*sofaHrtf->R + ti)*sofaHrtf->N],
+                        sofaHrtf->N, azd->mIrs[ti]);
+                else
+                {
+                    std::copy_n(&sofaHrtf->DataIR.values[(si*sofaHrtf->R + ti)*sofaHrtf->N],
+                        sofaHrtf->N, restmp.get());
+                    resampler->process(sofaHrtf->N, restmp.get(), hData->mIrSize, azd->mIrs[ti]);
+                }
+            }
+
+            /* Include any per-channel or per-HRIR delays. */
+            if(delayType == DelayType::I_R)
+            {
+                const float *delayValues{sofaHrtf->DataDelay.values};
+                for(uint ti{0u};ti < channels;++ti)
+                    azd->mDelays[ti] = delayValues[ti] / static_cast<float>(hData->mIrRate);
+            }
+            else if(delayType == DelayType::M_R)
+            {
+                const float *delayValues{sofaHrtf->DataDelay.values};
+                for(uint ti{0u};ti < channels;++ti)
+                    azd->mDelays[ti] = delayValues[si*sofaHrtf->R + ti] /
+                        static_cast<float>(hData->mIrRate);
+            }
         }
 
-        for(uint ti{0u};ti < channels;++ti)
+        if(outRate && outRate != hData->mIrRate)
         {
-            std::copy_n(&sofaHrtf->DataIR.values[(si*sofaHrtf->R + ti)*sofaHrtf->N],
-                hData->mIrPoints, hrir.begin());
-            azd->mIrs[ti] = &hrirs[hData->mIrSize * (hData->mIrCount*ti + azd->mIndex)];
-            azd->mDelays[ti] = CalcHrirOnset(hData->mIrRate, hData->mIrPoints, upsampled,
-                hrir.data());
-            CalcHrirMagnitude(hData->mIrPoints, hData->mFftSize, htemp, hrir.data(),
-                azd->mIrs[ti]);
+            const double scale{static_cast<double>(outRate) / hData->mIrRate};
+            hData->mIrRate = outRate;
+            hData->mIrPoints = std::min(static_cast<uint>(std::ceil(hData->mIrPoints*scale)),
+                hData->mIrSize);
         }
-
-        // TODO: Since some SOFA files contain minimum phase HRIRs,
-        // it would be beneficial to check for per-measurement delays
-        // (when available) to reconstruct the HRTDs.
-    }
-    printf("\n");
-    return true;
+        return true;
+    };
+
+    std::future_status load_status{};
+    auto load_future = std::async(std::launch::async, load_proc);
+    do {
+        load_status = load_future.wait_for(std::chrono::milliseconds{50});
+        printf("\rLoading HRIRs... %u of %u", loaded_count.load(), sofaHrtf->M);
+        fflush(stdout);
+    } while(load_status != std::future_status::ready);
+    fputc('\n', stdout);
+    return load_future.get();
 }
 
-struct MySofaHrtfDeleter {
-    void operator()(MYSOFA_HRTF *ptr) { mysofa_free(ptr); }
+
+/* Calculates the frequency magnitudes of the HRIR set. Work is delegated to
+ * this struct, which runs asynchronously on one or more threads (sharing the
+ * same calculator object).
+ */
+struct MagCalculator {
+    const uint mFftSize{};
+    const uint mIrPoints{};
+    std::vector<double*> mIrs{};
+    std::atomic<size_t> mCurrent{};
+    std::atomic<size_t> mDone{};
+
+    void Worker()
+    {
+        auto htemp = std::vector<complex_d>(mFftSize);
+
+        while(1)
+        {
+            /* Load the current index to process. */
+            size_t idx{mCurrent.load()};
+            do {
+                /* If the index is at the end, we're done. */
+                if(idx >= mIrs.size())
+                    return;
+                /* Otherwise, increment the current index atomically so other
+                 * threads know to go to the next one. If this call fails, the
+                 * current index was just changed by another thread and the new
+                 * value is loaded into idx, which we'll recheck.
+                 */
+            } while(!mCurrent.compare_exchange_weak(idx, idx+1, std::memory_order_relaxed));
+
+            CalcHrirMagnitude(mIrPoints, mFftSize, htemp, mIrs[idx]);
+
+            /* Increment the number of IRs done. */
+            mDone.fetch_add(1);
+        }
+    }
 };
-using MySofaHrtfPtr = std::unique_ptr<MYSOFA_HRTF,MySofaHrtfDeleter>;
 
-bool LoadSofaFile(const char *filename, const uint fftSize, const uint truncSize,
-    const ChannelModeT chanMode, HrirDataT *hData)
+bool LoadSofaFile(const char *filename, const uint numThreads, const uint fftSize,
+    const uint truncSize, const uint outRate, const ChannelModeT chanMode, HrirDataT *hData)
 {
     int err;
     MySofaHrtfPtr sofaHrtf{mysofa_load(filename, &err)};
@@ -605,39 +459,45 @@ bool LoadSofaFile(const char *filename, const uint fftSize, const uint truncSize
     /* Assume a default head radius of 9cm. */
     hData->mRadius = 0.09;
 
-    if(!PrepareSampleRate(sofaHrtf.get(), hData) || !PrepareDelay(sofaHrtf.get(), hData)
-        || !CheckIrData(sofaHrtf.get()))
+    hData->mIrRate = static_cast<uint>(GetSampleRate(sofaHrtf.get()) + 0.5f);
+    if(!hData->mIrRate)
         return false;
-    if(!PrepareLayout(sofaHrtf->M, sofaHrtf->SourcePosition.values, hData))
+
+    DelayType delayType = PrepareDelay(sofaHrtf.get());
+    if(delayType == DelayType::Invalid)
         return false;
 
-    if(!LoadResponses(sofaHrtf.get(), hData))
+    if(!CheckIrData(sofaHrtf.get()))
+        return false;
+    if(!PrepareLayout(sofaHrtf->M, sofaHrtf->SourcePosition.values, hData))
+        return false;
+    if(!LoadResponses(sofaHrtf.get(), hData, delayType, outRate))
         return false;
     sofaHrtf = nullptr;
 
-    for(uint fi{0u};fi < hData->mFdCount;fi++)
+    for(uint fi{0u};fi < hData->mFds.size();fi++)
     {
         uint ei{0u};
-        for(;ei < hData->mFds[fi].mEvCount;ei++)
+        for(;ei < hData->mFds[fi].mEvs.size();ei++)
         {
             uint ai{0u};
-            for(;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT &azd = hData->mFds[fi].mEvs[ei].mAzs[ai];
                 if(azd.mIrs[0] != nullptr) break;
             }
-            if(ai < hData->mFds[fi].mEvs[ei].mAzCount)
+            if(ai < hData->mFds[fi].mEvs[ei].mAzs.size())
                 break;
         }
-        if(ei >= hData->mFds[fi].mEvCount)
+        if(ei >= hData->mFds[fi].mEvs.size())
         {
             fprintf(stderr, "Missing source references [ %d, *, * ].\n", fi);
             return false;
         }
         hData->mFds[fi].mEvStart = ei;
-        for(;ei < hData->mFds[fi].mEvCount;ei++)
+        for(;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(uint ai{0u};ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(uint ai{0u};ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT &azd = hData->mFds[fi].mEvs[ei].mAzs[ai];
                 if(azd.mIrs[0] == nullptr)
@@ -649,20 +509,95 @@ bool LoadSofaFile(const char *filename, const uint fftSize, const uint truncSize
         }
     }
 
+
+    size_t hrir_total{0};
     const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
     double *hrirs = hData->mHrirsBase.data();
-    for(uint fi{0u};fi < hData->mFdCount;fi++)
+    for(uint fi{0u};fi < hData->mFds.size();fi++)
     {
-        for(uint ei{0u};ei < hData->mFds[fi].mEvCount;ei++)
+        for(uint ei{0u};ei < hData->mFds[fi].mEvStart;ei++)
         {
-            for(uint ai{0u};ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(uint ai{0u};ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT &azd = hData->mFds[fi].mEvs[ei].mAzs[ai];
                 for(uint ti{0u};ti < channels;ti++)
                     azd.mIrs[ti] = &hrirs[hData->mIrSize * (hData->mIrCount*ti + azd.mIndex)];
             }
         }
+
+        for(uint ei{hData->mFds[fi].mEvStart};ei < hData->mFds[fi].mEvs.size();ei++)
+            hrir_total += hData->mFds[fi].mEvs[ei].mAzs.size() * channels;
     }
 
+    std::atomic<size_t> hrir_done{0};
+    auto onset_proc = [hData,channels,&hrir_done]() -> bool
+    {
+        /* Temporary buffer used to calculate the IR's onset. */
+        auto upsampled = std::vector<double>(OnsetRateMultiple * hData->mIrPoints);
+        /* This resampler is used to help detect the response onset. */
+        PPhaseResampler rs;
+        rs.init(hData->mIrRate, OnsetRateMultiple*hData->mIrRate);
+
+        for(auto &field : hData->mFds)
+        {
+            for(auto &elev : field.mEvs.subspan(field.mEvStart))
+            {
+                for(auto &azd : elev.mAzs)
+                {
+                    for(uint ti{0};ti < channels;ti++)
+                    {
+                        hrir_done.fetch_add(1u, std::memory_order_acq_rel);
+                        azd.mDelays[ti] += CalcHrirOnset(rs, hData->mIrRate, hData->mIrPoints,
+                            upsampled, azd.mIrs[ti]);
+                    }
+                }
+            }
+        }
+        return true;
+    };
+
+    std::future_status load_status{};
+    auto load_future = std::async(std::launch::async, onset_proc);
+    do {
+        load_status = load_future.wait_for(std::chrono::milliseconds{50});
+        printf("\rCalculating HRIR onsets... %zu of %zu", hrir_done.load(), hrir_total);
+        fflush(stdout);
+    } while(load_status != std::future_status::ready);
+    fputc('\n', stdout);
+    if(!load_future.get())
+        return false;
+
+    MagCalculator calculator{hData->mFftSize, hData->mIrPoints};
+    for(auto &field : hData->mFds)
+    {
+        for(auto &elev : field.mEvs.subspan(field.mEvStart))
+        {
+            for(auto &azd : elev.mAzs)
+            {
+                for(uint ti{0};ti < channels;ti++)
+                    calculator.mIrs.push_back(azd.mIrs[ti]);
+            }
+        }
+    }
+
+    std::vector<std::thread> thrds;
+    thrds.reserve(numThreads);
+    for(size_t i{0};i < numThreads;++i)
+        thrds.emplace_back(std::mem_fn(&MagCalculator::Worker), &calculator);
+    size_t count;
+    do {
+        std::this_thread::sleep_for(std::chrono::milliseconds{50});
+        count = calculator.mDone.load();
+
+        printf("\rCalculating HRIR magnitudes... %zu of %zu", count, calculator.mIrs.size());
+        fflush(stdout);
+    } while(count != calculator.mIrs.size());
+    fputc('\n', stdout);
+
+    for(auto &thrd : thrds)
+    {
+        if(thrd.joinable())
+            thrd.join();
+    }
     return true;
 }
diff --git a/utils/makemhr/loadsofa.h b/utils/makemhr/loadsofa.h
index 93bf1704..82dce85a 100644
--- a/utils/makemhr/loadsofa.h
+++ b/utils/makemhr/loadsofa.h
@@ -4,7 +4,7 @@
 #include "makemhr.h"
 
 
-bool LoadSofaFile(const char *filename, const uint fftSize, const uint truncSize,
-    const ChannelModeT chanMode, HrirDataT *hData);
+bool LoadSofaFile(const char *filename, const uint numThreads, const uint fftSize,
+    const uint truncSize, const uint outRate, const ChannelModeT chanMode, HrirDataT *hData);
 
 #endif /* LOADSOFA_H */
diff --git a/utils/makemhr/makemhr.cpp b/utils/makemhr/makemhr.cpp
index 1e28ca4b..ae301dc3 100644
--- a/utils/makemhr/makemhr.cpp
+++ b/utils/makemhr/makemhr.cpp
@@ -88,7 +88,9 @@
 #include "../getopt.h"
 #endif
 
+#include "alcomplex.h"
 #include "alfstream.h"
+#include "alspan.h"
 #include "alstring.h"
 #include "loaddef.h"
 #include "loadsofa.h"
@@ -107,6 +109,8 @@ using namespace std::placeholders;
 #endif
 
 
+HrirDataT::~HrirDataT() = default;
+
 // Head model used for calculating the impulse delays.
 enum HeadModelT {
     HM_NONE,
@@ -128,22 +132,18 @@ enum HeadModelT {
 
 // The limits to the truncation window size on the command line.
 #define MIN_TRUNCSIZE                (16)
-#define MAX_TRUNCSIZE                (512)
+#define MAX_TRUNCSIZE                (128)
 
 // The limits to the custom head radius on the command line.
 #define MIN_CUSTOM_RADIUS            (0.05)
 #define MAX_CUSTOM_RADIUS            (0.15)
 
-// The truncation window size must be a multiple of the below value to allow
-// for vectorized convolution.
-#define MOD_TRUNCSIZE                (8)
-
 // The defaults for the command line options.
 #define DEFAULT_FFTSIZE              (65536)
 #define DEFAULT_EQUALIZE             (1)
 #define DEFAULT_SURFACE              (1)
 #define DEFAULT_LIMIT                (24.0)
-#define DEFAULT_TRUNCSIZE            (32)
+#define DEFAULT_TRUNCSIZE            (64)
 #define DEFAULT_HEAD_MODEL           (HM_DATASET)
 #define DEFAULT_CUSTOM_RADIUS        (0.0)
 
@@ -151,8 +151,8 @@ enum HeadModelT {
 #define MAX_HRTD                     (63.0)
 
 // The OpenAL Soft HRTF format marker.  It stands for minimum-phase head
-// response protocol 02.
-#define MHR_FORMAT                   ("MinPHR02")
+// response protocol 03.
+#define MHR_FORMAT                   ("MinPHR03")
 
 /* Channel index enums. Mono uses LeftChannel only. */
 enum ChannelIndex : uint {
@@ -165,42 +165,31 @@ enum ChannelIndex : uint {
  * pattern string are replaced with the replacement string.  The result is
  * truncated if necessary.
  */
-static int StrSubst(const char *in, const char *pat, const char *rep, const size_t maxLen, char *out)
+static std::string StrSubst(al::span<const char> in, const al::span<const char> pat,
+    const al::span<const char> rep)
 {
-    size_t inLen, patLen, repLen;
-    size_t si, di;
-    int truncated;
-
-    inLen = strlen(in);
-    patLen = strlen(pat);
-    repLen = strlen(rep);
-    si = 0;
-    di = 0;
-    truncated = 0;
-    while(si < inLen && di < maxLen)
+    std::string ret;
+    ret.reserve(in.size() + pat.size());
+
+    while(in.size() >= pat.size())
     {
-        if(patLen <= inLen-si)
+        if(al::strncasecmp(in.data(), pat.data(), pat.size()) == 0)
         {
-            if(al::strncasecmp(&in[si], pat, patLen) == 0)
-            {
-                if(repLen > maxLen-di)
-                {
-                    repLen = maxLen - di;
-                    truncated = 1;
-                }
-                strncpy(&out[di], rep, repLen);
-                si += patLen;
-                di += repLen;
-            }
+            in = in.subspan(pat.size());
+            ret.append(rep.data(), rep.size());
+        }
+        else
+        {
+            size_t endpos{1};
+            while(endpos < in.size() && in[endpos] != pat.front())
+                ++endpos;
+            ret.append(in.data(), endpos);
+            in = in.subspan(endpos);
         }
-        out[di] = in[si];
-        si++;
-        di++;
     }
-    if(si < inLen)
-        truncated = 1;
-    out[di] = '\0';
-    return !truncated;
+    ret.append(in.data(), in.size());
+
+    return ret;
 }
 
 
@@ -236,94 +225,14 @@ static void TpdfDither(double *RESTRICT out, const double *RESTRICT in, const do
     }
 }
 
-/* Fast Fourier transform routines. The number of points must be a power of
- * two.
- */
-
-// Performs bit-reversal ordering.
-static void FftArrange(const uint n, complex_d *inout)
-{
-    // Handle in-place arrangement.
-    uint rk{0u};
-    for(uint k{0u};k < n;k++)
-    {
-        if(rk > k)
-            std::swap(inout[rk], inout[k]);
-
-        uint m{n};
-        while(rk&(m >>= 1))
-            rk &= ~m;
-        rk |= m;
-    }
-}
-
-// Performs the summation.
-static void FftSummation(const uint n, const double s, complex_d *cplx)
-{
-    double pi;
-    uint m, m2;
-    uint i, k, mk;
-
-    pi = s * M_PI;
-    for(m = 1, m2 = 2;m < n; m <<= 1, m2 <<= 1)
-    {
-        // v = Complex (-2.0 * sin (0.5 * pi / m) * sin (0.5 * pi / m), -sin (pi / m))
-        double sm = std::sin(0.5 * pi / m);
-        auto v = complex_d{-2.0*sm*sm, -std::sin(pi / m)};
-        auto w = complex_d{1.0, 0.0};
-        for(i = 0;i < m;i++)
-        {
-            for(k = i;k < n;k += m2)
-            {
-                mk = k + m;
-                auto t = w * cplx[mk];
-                cplx[mk] = cplx[k] - t;
-                cplx[k] = cplx[k] + t;
-            }
-            w += v*w;
-        }
-    }
-}
-
-// Performs a forward FFT.
-void FftForward(const uint n, complex_d *inout)
-{
-    FftArrange(n, inout);
-    FftSummation(n, 1.0, inout);
-}
-
-// Performs an inverse FFT.
-void FftInverse(const uint n, complex_d *inout)
-{
-    FftArrange(n, inout);
-    FftSummation(n, -1.0, inout);
-    double f{1.0 / n};
-    for(uint i{0};i < n;i++)
-        inout[i] *= f;
-}
 
 /* Calculate the complex helical sequence (or discrete-time analytical signal)
  * of the given input using the Hilbert transform. Given the natural logarithm
  * of a signal's magnitude response, the imaginary components can be used as
  * the angles for minimum-phase reconstruction.
  */
-static void Hilbert(const uint n, complex_d *inout)
-{
-    uint i;
-
-    // Handle in-place operation.
-    for(i = 0;i < n;i++)
-        inout[i].imag(0.0);
-
-    FftInverse(n, inout);
-    for(i = 1;i < (n+1)/2;i++)
-        inout[i] *= 2.0;
-    /* Increment i if n is even. */
-    i += (n&1)^1;
-    for(;i < n;i++)
-        inout[i] = complex_d{0.0, 0.0};
-    FftForward(n, inout);
-}
+inline static void Hilbert(const uint n, complex_d *inout)
+{ complex_hilbert({inout, n}); }
 
 /* Calculate the magnitude response of the given input.  This is used in
  * place of phase decomposition, since the phase residuals are discarded for
@@ -372,17 +281,13 @@ static void LimitMagnitudeResponse(const uint n, const uint m, const double limi
  * residuals (which were discarded).  The mirrored half of the response is
  * reconstructed.
  */
-static void MinimumPhase(const uint n, const double *in, complex_d *out)
+static void MinimumPhase(const uint n, double *mags, complex_d *out)
 {
-    const uint m = 1 + (n / 2);
-    std::vector<double> mags(n);
+    const uint m{(n/2) + 1};
 
     uint i;
     for(i = 0;i < m;i++)
-    {
-        mags[i] = std::max(EPSILON, in[i]);
-        out[i] = complex_d{std::log(mags[i]), 0.0};
-    }
+        out[i] = std::log(mags[i]);
     for(;i < n;i++)
     {
         mags[i] = mags[n - i];
@@ -394,238 +299,7 @@ static void MinimumPhase(const uint n, const double *in, complex_d *out)
     for(i = 0;i < n;i++)
     {
         auto a = std::exp(complex_d{0.0, out[i].imag()});
-        out[i] = complex_d{mags[i], 0.0} * a;
-    }
-}
-
-
-/***************************
- *** Resampler functions ***
- ***************************/
-
-/* This is the normalized cardinal sine (sinc) function.
- *
- *   sinc(x) = { 1,                   x = 0
- *             { sin(pi x) / (pi x),  otherwise.
- */
-static double Sinc(const double x)
-{
-    if(std::abs(x) < EPSILON)
-        return 1.0;
-    return std::sin(M_PI * x) / (M_PI * x);
-}
-
-/* The zero-order modified Bessel function of the first kind, used for the
- * Kaiser window.
- *
- *   I_0(x) = sum_{k=0}^inf (1 / k!)^2 (x / 2)^(2 k)
- *          = sum_{k=0}^inf ((x / 2)^k / k!)^2
- */
-static double BesselI_0(const double x)
-{
-    double term, sum, x2, y, last_sum;
-    int k;
-
-    // Start at k=1 since k=0 is trivial.
-    term = 1.0;
-    sum = 1.0;
-    x2 = x/2.0;
-    k = 1;
-
-    // Let the integration converge until the term of the sum is no longer
-    // significant.
-    do {
-        y = x2 / k;
-        k++;
-        last_sum = sum;
-        term *= y * y;
-        sum += term;
-    } while(sum != last_sum);
-    return sum;
-}
-
-/* Calculate a Kaiser window from the given beta value and a normalized k
- * [-1, 1].
- *
- *   w(k) = { I_0(B sqrt(1 - k^2)) / I_0(B),  -1 <= k <= 1
- *          { 0,                              elsewhere.
- *
- * Where k can be calculated as:
- *
- *   k = i / l,         where -l <= i <= l.
- *
- * or:
- *
- *   k = 2 i / M - 1,   where 0 <= i <= M.
- */
-static double Kaiser(const double b, const double k)
-{
-    if(!(k >= -1.0 && k <= 1.0))
-        return 0.0;
-    return BesselI_0(b * std::sqrt(1.0 - k*k)) / BesselI_0(b);
-}
-
-// Calculates the greatest common divisor of a and b.
-static uint Gcd(uint x, uint y)
-{
-    while(y > 0)
-    {
-        uint z{y};
-        y = x % y;
-        x = z;
-    }
-    return x;
-}
-
-/* Calculates the size (order) of the Kaiser window.  Rejection is in dB and
- * the transition width is normalized frequency (0.5 is nyquist).
- *
- *   M = { ceil((r - 7.95) / (2.285 2 pi f_t)),  r > 21
- *       { ceil(5.79 / 2 pi f_t),                r <= 21.
- *
- */
-static uint CalcKaiserOrder(const double rejection, const double transition)
-{
-    double w_t = 2.0 * M_PI * transition;
-    if(rejection > 21.0)
-        return static_cast<uint>(std::ceil((rejection - 7.95) / (2.285 * w_t)));
-    return static_cast<uint>(std::ceil(5.79 / w_t));
-}
-
-// Calculates the beta value of the Kaiser window.  Rejection is in dB.
-static double CalcKaiserBeta(const double rejection)
-{
-    if(rejection > 50.0)
-        return 0.1102 * (rejection - 8.7);
-    if(rejection >= 21.0)
-        return (0.5842 * std::pow(rejection - 21.0, 0.4)) +
-               (0.07886 * (rejection - 21.0));
-    return 0.0;
-}
-
-/* Calculates a point on the Kaiser-windowed sinc filter for the given half-
- * width, beta, gain, and cutoff.  The point is specified in non-normalized
- * samples, from 0 to M, where M = (2 l + 1).
- *
- *   w(k) 2 p f_t sinc(2 f_t x)
- *
- *   x    -- centered sample index (i - l)
- *   k    -- normalized and centered window index (x / l)
- *   w(k) -- window function (Kaiser)
- *   p    -- gain compensation factor when sampling
- *   f_t  -- normalized center frequency (or cutoff; 0.5 is nyquist)
- */
-static double SincFilter(const uint l, const double b, const double gain, const double cutoff, const uint i)
-{
-    return Kaiser(b, static_cast<double>(i - l) / l) * 2.0 * gain * cutoff * Sinc(2.0 * cutoff * (i - l));
-}
-
-/* This is a polyphase sinc-filtered resampler.
- *
- *              Upsample                      Downsample
- *
- *              p/q = 3/2                     p/q = 3/5
- *
- *          M-+-+-+->                     M-+-+-+->
- *         -------------------+          ---------------------+
- *   p  s * f f f f|f|        |    p  s * f f f f f           |
- *   |  0 *   0 0 0|0|0       |    |  0 *   0 0 0 0|0|        |
- *   v  0 *     0 0|0|0 0     |    v  0 *     0 0 0|0|0       |
- *      s *       f|f|f f f   |       s *       f f|f|f f     |
- *      0 *        |0|0 0 0 0 |       0 *         0|0|0 0 0   |
- *         --------+=+--------+       0 *          |0|0 0 0 0 |
- *          d . d .|d|. d . d            ----------+=+--------+
- *                                        d . . . .|d|. . . .
- *          q->
- *                                        q-+-+-+->
- *
- *   P_f(i,j) = q i mod p + pj
- *   P_s(i,j) = floor(q i / p) - j
- *   d[i=0..N-1] = sum_{j=0}^{floor((M - 1) / p)} {
- *                   { f[P_f(i,j)] s[P_s(i,j)],  P_f(i,j) < M
- *                   { 0,                        P_f(i,j) >= M. }
- */
-
-// Calculate the resampling metrics and build the Kaiser-windowed sinc filter
-// that's used to cut frequencies above the destination nyquist.
-void ResamplerSetup(ResamplerT *rs, const uint srcRate, const uint dstRate)
-{
-    const uint gcd{Gcd(srcRate, dstRate)};
-    rs->mP = dstRate / gcd;
-    rs->mQ = srcRate / gcd;
-
-    /* The cutoff is adjusted by half the transition width, so the transition
-     * ends before the nyquist (0.5).  Both are scaled by the downsampling
-     * factor.
-     */
-    double cutoff, width;
-    if(rs->mP > rs->mQ)
-    {
-        cutoff = 0.475 / rs->mP;
-        width = 0.05 / rs->mP;
-    }
-    else
-    {
-        cutoff = 0.475 / rs->mQ;
-        width = 0.05 / rs->mQ;
-    }
-    // A rejection of -180 dB is used for the stop band. Round up when
-    // calculating the left offset to avoid increasing the transition width.
-    const uint l{(CalcKaiserOrder(180.0, width)+1) / 2};
-    const double beta{CalcKaiserBeta(180.0)};
-    rs->mM = l*2 + 1;
-    rs->mL = l;
-    rs->mF.resize(rs->mM);
-    for(uint i{0};i < rs->mM;i++)
-        rs->mF[i] = SincFilter(l, beta, rs->mP, cutoff, i);
-}
-
-// Perform the upsample-filter-downsample resampling operation using a
-// polyphase filter implementation.
-void ResamplerRun(ResamplerT *rs, const uint inN, const double *in, const uint outN, double *out)
-{
-    const uint p = rs->mP, q = rs->mQ, m = rs->mM, l = rs->mL;
-    std::vector<double> workspace;
-    const double *f = rs->mF.data();
-    uint j_f, j_s;
-    double *work;
-    uint i;
-
-    if(outN == 0)
-        return;
-
-    // Handle in-place operation.
-    if(in == out)
-    {
-        workspace.resize(outN);
-        work = workspace.data();
-    }
-    else
-        work = out;
-    // Resample the input.
-    for(i = 0;i < outN;i++)
-    {
-        double r = 0.0;
-        // Input starts at l to compensate for the filter delay.  This will
-        // drop any build-up from the first half of the filter.
-        j_f = (l + (q * i)) % p;
-        j_s = (l + (q * i)) / p;
-        while(j_f < m)
-        {
-            // Only take input when 0 <= j_s < inN.  This single unsigned
-            // comparison catches both cases.
-            if(j_s < inN)
-                r += f[j_f] * in[j_s];
-            j_f += p;
-            j_s--;
-        }
-        work[i] = r;
-    }
-    // Clean up after in-place operation.
-    if(work != out)
-    {
-        for(i = 0;i < outN;i++)
-            out[i] = work[i];
+        out[i] = a * mags[i];
     }
 }
 
@@ -670,11 +344,11 @@ static int WriteBin4(const uint bytes, const uint32_t in, FILE *fp, const char *
 // Store the OpenAL Soft HRTF data set.
 static int StoreMhr(const HrirDataT *hData, const char *filename)
 {
-    uint channels = (hData->mChannelType == CT_STEREO) ? 2 : 1;
-    uint n = hData->mIrPoints;
-    FILE *fp;
+    const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
+    const uint n{hData->mIrPoints};
+    uint dither_seed{22222};
     uint fi, ei, ai, i;
-    uint dither_seed = 22222;
+    FILE *fp;
 
     if((fp=fopen(filename, "wb")) == nullptr)
     {
@@ -685,38 +359,35 @@ static int StoreMhr(const HrirDataT *hData, const char *filename)
         return 0;
     if(!WriteBin4(4, hData->mIrRate, fp, filename))
         return 0;
-    if(!WriteBin4(1, static_cast<uint32_t>(hData->mSampleType), fp, filename))
-        return 0;
     if(!WriteBin4(1, static_cast<uint32_t>(hData->mChannelType), fp, filename))
         return 0;
     if(!WriteBin4(1, hData->mIrPoints, fp, filename))
         return 0;
-    if(!WriteBin4(1, hData->mFdCount, fp, filename))
+    if(!WriteBin4(1, static_cast<uint>(hData->mFds.size()), fp, filename))
         return 0;
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = static_cast<uint>(hData->mFds.size()-1);fi < hData->mFds.size();fi--)
     {
         auto fdist = static_cast<uint32_t>(std::round(1000.0 * hData->mFds[fi].mDistance));
         if(!WriteBin4(2, fdist, fp, filename))
             return 0;
-        if(!WriteBin4(1, hData->mFds[fi].mEvCount, fp, filename))
+        if(!WriteBin4(1, static_cast<uint32_t>(hData->mFds[fi].mEvs.size()), fp, filename))
             return 0;
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = 0;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            if(!WriteBin4(1, hData->mFds[fi].mEvs[ei].mAzCount, fp, filename))
+            const auto &elev = hData->mFds[fi].mEvs[ei];
+            if(!WriteBin4(1, static_cast<uint32_t>(elev.mAzs.size()), fp, filename))
                 return 0;
         }
     }
 
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = static_cast<uint>(hData->mFds.size()-1);fi < hData->mFds.size();fi--)
     {
-        const double scale = (hData->mSampleType == ST_S16) ? 32767.0 :
-                             ((hData->mSampleType == ST_S24) ? 8388607.0 : 0.0);
-        const uint bps = (hData->mSampleType == ST_S16) ? 2 :
-                         ((hData->mSampleType == ST_S24) ? 3 : 0);
+        constexpr double scale{8388607.0};
+        constexpr uint bps{3u};
 
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = 0;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
                 double out[2 * MAX_TRUNCSIZE];
@@ -726,30 +397,27 @@ static int StoreMhr(const HrirDataT *hData, const char *filename)
                     TpdfDither(out+1, azd->mIrs[1], scale, n, channels, &dither_seed);
                 for(i = 0;i < (channels * n);i++)
                 {
-                    int v = static_cast<int>(Clamp(out[i], -scale-1.0, scale));
+                    const auto v = static_cast<int>(Clamp(out[i], -scale-1.0, scale));
                     if(!WriteBin4(bps, static_cast<uint32_t>(v), fp, filename))
                         return 0;
                 }
             }
         }
     }
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = static_cast<uint>(hData->mFds.size()-1);fi < hData->mFds.size();fi--)
     {
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        /* Delay storage has 2 bits of extra precision. */
+        constexpr double DelayPrecScale{4.0};
+        for(ei = 0;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(const auto &azd : hData->mFds[fi].mEvs[ei].mAzs)
             {
-                const HrirAzT &azd = hData->mFds[fi].mEvs[ei].mAzs[ai];
-                int v = static_cast<int>(std::min(std::round(hData->mIrRate * azd.mDelays[0]), MAX_HRTD));
-
-                if(!WriteBin4(1, static_cast<uint32_t>(v), fp, filename))
-                    return 0;
+                auto v = static_cast<uint>(std::round(azd.mDelays[0]*DelayPrecScale));
+                if(!WriteBin4(1, v, fp, filename)) return 0;
                 if(hData->mChannelType == CT_STEREO)
                 {
-                    v = static_cast<int>(std::min(std::round(hData->mIrRate * azd.mDelays[1]), MAX_HRTD));
-
-                    if(!WriteBin4(1, static_cast<uint32_t>(v), fp, filename))
-                        return 0;
+                    v = static_cast<uint>(std::round(azd.mDelays[1]*DelayPrecScale));
+                    if(!WriteBin4(1, v, fp, filename)) return 0;
                 }
             }
         }
@@ -770,22 +438,21 @@ static int StoreMhr(const HrirDataT *hData, const char *filename)
 static void BalanceFieldMagnitudes(const HrirDataT *hData, const uint channels, const uint m)
 {
     double maxMags[MAX_FD_COUNT];
-    uint fi, ei, ai, ti, i;
+    uint fi, ei, ti, i;
 
     double maxMag{0.0};
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
         maxMags[fi] = 0.0;
 
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(const auto &azd : hData->mFds[fi].mEvs[ei].mAzs)
             {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
                 for(ti = 0;ti < channels;ti++)
                 {
                     for(i = 0;i < m;i++)
-                        maxMags[fi] = std::max(azd->mIrs[ti][i], maxMags[fi]);
+                        maxMags[fi] = std::max(azd.mIrs[ti][i], maxMags[fi]);
                 }
             }
         }
@@ -793,19 +460,18 @@ static void BalanceFieldMagnitudes(const HrirDataT *hData, const uint channels,
         maxMag = std::max(maxMags[fi], maxMag);
     }
 
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
         const double magFactor{maxMag / maxMags[fi]};
 
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(const auto &azd : hData->mFds[fi].mEvs[ei].mAzs)
             {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
                 for(ti = 0;ti < channels;ti++)
                 {
                     for(i = 0;i < m;i++)
-                        azd->mIrs[ti][i] *= magFactor;
+                        azd.mIrs[ti][i] *= magFactor;
                 }
             }
         }
@@ -825,30 +491,32 @@ static void CalculateDfWeights(const HrirDataT *hData, double *weights)
     sum = 0.0;
     // The head radius acts as the limit for the inner radius.
     innerRa = hData->mRadius;
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
         // Each volume ends half way between progressive field measurements.
-        if((fi + 1) < hData->mFdCount)
+        if((fi + 1) < hData->mFds.size())
             outerRa = 0.5f * (hData->mFds[fi].mDistance + hData->mFds[fi + 1].mDistance);
         // The final volume has its limit extended to some practical value.
         // This is done to emphasize the far-field responses in the average.
         else
             outerRa = 10.0f;
 
-        evs = M_PI / 2.0 / (hData->mFds[fi].mEvCount - 1);
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+        const double raPowDiff{std::pow(outerRa, 3.0) - std::pow(innerRa, 3.0)};
+        evs = M_PI / 2.0 / static_cast<double>(hData->mFds[fi].mEvs.size() - 1);
+        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
         {
+            const auto &elev = hData->mFds[fi].mEvs[ei];
             // For each elevation, calculate the upper and lower limits of
             // the patch band.
-            ev = hData->mFds[fi].mEvs[ei].mElevation;
+            ev = elev.mElevation;
             lowerEv = std::max(-M_PI / 2.0, ev - evs);
             upperEv = std::min(M_PI / 2.0, ev + evs);
             // Calculate the surface area of the patch band.
             solidAngle = 2.0 * M_PI * (std::sin(upperEv) - std::sin(lowerEv));
             // Then the volume of the extruded patch band.
-            solidVolume = solidAngle * (std::pow(outerRa, 3.0) - std::pow(innerRa, 3.0)) / 3.0;
+            solidVolume = solidAngle * raPowDiff / 3.0;
             // Each weight is the volume of one extruded patch.
-            weights[(fi * MAX_EV_COUNT) + ei] = solidVolume / hData->mFds[fi].mEvs[ei].mAzCount;
+            weights[(fi*MAX_EV_COUNT) + ei] = solidVolume / static_cast<double>(elev.mAzs.size());
             // Sum the total coverage volume of the HRIRs for all fields.
             sum += solidAngle;
         }
@@ -856,11 +524,11 @@ static void CalculateDfWeights(const HrirDataT *hData, double *weights)
         innerRa = outerRa;
     }
 
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
         // Normalize the weights given the total surface coverage for all
         // fields.
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
             weights[(fi * MAX_EV_COUNT) + ei] /= sum;
     }
 }
@@ -870,9 +538,10 @@ static void CalculateDfWeights(const HrirDataT *hData, double *weights)
  * coverage of each HRIR.  The final average can then be limited by the
  * specified magnitude range (in positive dB; 0.0 to skip).
  */
-static void CalculateDiffuseFieldAverage(const HrirDataT *hData, const uint channels, const uint m, const int weighted, const double limit, double *dfa)
+static void CalculateDiffuseFieldAverage(const HrirDataT *hData, const uint channels, const uint m,
+    const int weighted, const double limit, double *dfa)
 {
-    std::vector<double> weights(hData->mFdCount * MAX_EV_COUNT);
+    std::vector<double> weights(hData->mFds.size() * MAX_EV_COUNT);
     uint count, ti, fi, ei, i, ai;
 
     if(weighted)
@@ -887,16 +556,16 @@ static void CalculateDiffuseFieldAverage(const HrirDataT *hData, const uint chan
         // If coverage weighting is not used, the weights still need to be
         // averaged by the number of existing HRIRs.
         count = hData->mIrCount;
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(fi = 0;fi < hData->mFds.size();fi++)
         {
             for(ei = 0;ei < hData->mFds[fi].mEvStart;ei++)
-                count -= hData->mFds[fi].mEvs[ei].mAzCount;
+                count -= static_cast<uint>(hData->mFds[fi].mEvs[ei].mAzs.size());
         }
         weight = 1.0 / count;
 
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(fi = 0;fi < hData->mFds.size();fi++)
         {
-            for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+            for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
                 weights[(fi * MAX_EV_COUNT) + ei] = weight;
         }
     }
@@ -904,11 +573,11 @@ static void CalculateDiffuseFieldAverage(const HrirDataT *hData, const uint chan
     {
         for(i = 0;i < m;i++)
             dfa[(ti * m) + i] = 0.0;
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(fi = 0;fi < hData->mFds.size();fi++)
         {
-            for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+            for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
             {
-                for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+                for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
                 {
                     HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
                     // Get the weight for this HRIR's contribution.
@@ -934,167 +603,36 @@ static void CalculateDiffuseFieldAverage(const HrirDataT *hData, const uint chan
 // set using the given average response.
 static void DiffuseFieldEqualize(const uint channels, const uint m, const double *dfa, const HrirDataT *hData)
 {
-    uint ti, fi, ei, ai, i;
+    uint ti, fi, ei, i;
 
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    for(fi = 0;fi < hData->mFds.size();fi++)
     {
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
+        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvs.size();ei++)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(auto &azd : hData->mFds[fi].mEvs[ei].mAzs)
             {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
-
                 for(ti = 0;ti < channels;ti++)
                 {
                     for(i = 0;i < m;i++)
-                        azd->mIrs[ti][i] /= dfa[(ti * m) + i];
+                        azd.mIrs[ti][i] /= dfa[(ti * m) + i];
                 }
             }
         }
     }
 }
 
-/* Perform minimum-phase reconstruction using the magnitude responses of the
- * HRIR set. Work is delegated to this struct, which runs asynchronously on one
- * or more threads (sharing the same reconstructor object).
- */
-struct HrirReconstructor {
-    std::vector<double*> mIrs;
-    std::atomic<size_t> mCurrent;
-    std::atomic<size_t> mDone;
-    uint mFftSize;
-    uint mIrPoints;
-
-    void Worker()
-    {
-        auto h = std::vector<complex_d>(mFftSize);
-
-        while(1)
-        {
-            /* Load the current index to process. */
-            size_t idx{mCurrent.load()};
-            do {
-                /* If the index is at the end, we're done. */
-                if(idx >= mIrs.size())
-                    return;
-                /* Otherwise, increment the current index atomically so other
-                 * threads know to go to the next one. If this call fails, the
-                 * current index was just changed by another thread and the new
-                 * value is loaded into idx, which we'll recheck.
-                 */
-            } while(!mCurrent.compare_exchange_weak(idx, idx+1, std::memory_order_relaxed));
-
-            /* Now do the reconstruction, and apply the inverse FFT to get the
-             * time-domain response.
-             */
-            MinimumPhase(mFftSize, mIrs[idx], h.data());
-            FftInverse(mFftSize, h.data());
-            for(uint i{0u};i < mIrPoints;++i)
-                mIrs[idx][i] = h[i].real();
-
-            /* Increment the number of IRs done. */
-            mDone.fetch_add(1);
-        }
-    }
-};
-
-static void ReconstructHrirs(const HrirDataT *hData)
-{
-    const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
-
-    /* Count the number of IRs to process (excluding elevations that will be
-     * synthesized later).
-     */
-    size_t total{hData->mIrCount};
-    for(uint fi{0u};fi < hData->mFdCount;fi++)
-    {
-        for(uint ei{0u};ei < hData->mFds[fi].mEvStart;ei++)
-            total -= hData->mFds[fi].mEvs[ei].mAzCount;
-    }
-    total *= channels;
-
-    /* Set up the reconstructor with the needed size info and pointers to the
-     * IRs to process.
-     */
-    HrirReconstructor reconstructor;
-    reconstructor.mIrs.reserve(total);
-    reconstructor.mCurrent.store(0, std::memory_order_relaxed);
-    reconstructor.mDone.store(0, std::memory_order_relaxed);
-    reconstructor.mFftSize = hData->mFftSize;
-    reconstructor.mIrPoints = hData->mIrPoints;
-    for(uint fi{0u};fi < hData->mFdCount;fi++)
-    {
-        const HrirFdT &field = hData->mFds[fi];
-        for(uint ei{field.mEvStart};ei < field.mEvCount;ei++)
-        {
-            const HrirEvT &elev = field.mEvs[ei];
-            for(uint ai{0u};ai < elev.mAzCount;ai++)
-            {
-                const HrirAzT &azd = elev.mAzs[ai];
-                for(uint ti{0u};ti < channels;ti++)
-                    reconstructor.mIrs.push_back(azd.mIrs[ti]);
-            }
-        }
-    }
-
-    /* Launch two threads to work on reconstruction. */
-    std::thread thrd1{std::mem_fn(&HrirReconstructor::Worker), &reconstructor};
-    std::thread thrd2{std::mem_fn(&HrirReconstructor::Worker), &reconstructor};
-
-    /* Keep track of the number of IRs done, periodically reporting it. */
-    size_t count;
-    while((count=reconstructor.mDone.load()) != total)
-    {
-        size_t pcdone{count * 100 / total};
-
-        printf("\r%3zu%% done (%zu of %zu)", pcdone, count, total);
-        fflush(stdout);
-
-        std::this_thread::sleep_for(std::chrono::milliseconds{50});
-    }
-    size_t pcdone{count * 100 / total};
-    printf("\r%3zu%% done (%zu of %zu)\n", pcdone, count, total);
-
-    if(thrd2.joinable()) thrd2.join();
-    if(thrd1.joinable()) thrd1.join();
-}
-
-// Resamples the HRIRs for use at the given sampling rate.
-static void ResampleHrirs(const uint rate, HrirDataT *hData)
-{
-    uint channels = (hData->mChannelType == CT_STEREO) ? 2 : 1;
-    uint n = hData->mIrPoints;
-    uint ti, fi, ei, ai;
-    ResamplerT rs;
-
-    ResamplerSetup(&rs, hData->mIrRate, rate);
-    for(fi = 0;fi < hData->mFdCount;fi++)
-    {
-        for(ei = hData->mFds[fi].mEvStart;ei < hData->mFds[fi].mEvCount;ei++)
-        {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
-            {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
-                for(ti = 0;ti < channels;ti++)
-                    ResamplerRun(&rs, n, azd->mIrs[ti], n, azd->mIrs[ti]);
-            }
-        }
-    }
-    hData->mIrRate = rate;
-}
-
 /* Given field and elevation indices and an azimuth, calculate the indices of
  * the two HRIRs that bound the coordinate along with a factor for
  * calculating the continuous HRIR using interpolation.
  */
 static void CalcAzIndices(const HrirFdT &field, const uint ei, const double az, uint *a0, uint *a1, double *af)
 {
-    double f{(2.0*M_PI + az) * field.mEvs[ei].mAzCount / (2.0*M_PI)};
-    uint i{static_cast<uint>(f) % field.mEvs[ei].mAzCount};
+    double f{(2.0*M_PI + az) * static_cast<double>(field.mEvs[ei].mAzs.size()) / (2.0*M_PI)};
+    const uint i{static_cast<uint>(f) % static_cast<uint>(field.mEvs[ei].mAzs.size())};
 
     f -= std::floor(f);
     *a0 = i;
-    *a1 = (i + 1) % field.mEvs[ei].mAzCount;
+    *a1 = (i + 1) % static_cast<uint>(field.mEvs[ei].mAzs.size());
     *af = f;
 }
 
@@ -1124,13 +662,13 @@ static void SynthesizeOnsets(HrirDataT *hData)
             /* Take the polar opposite position of the desired measurement and
              * swap the ears.
              */
-            field.mEvs[0].mAzs[0].mDelays[0] = field.mEvs[field.mEvCount-1].mAzs[0].mDelays[1];
-            field.mEvs[0].mAzs[0].mDelays[1] = field.mEvs[field.mEvCount-1].mAzs[0].mDelays[0];
+            field.mEvs[0].mAzs[0].mDelays[0] = field.mEvs[field.mEvs.size()-1].mAzs[0].mDelays[1];
+            field.mEvs[0].mAzs[0].mDelays[1] = field.mEvs[field.mEvs.size()-1].mAzs[0].mDelays[0];
             for(ei = 1u;ei < (upperElevReal+1)/2;++ei)
             {
-                const uint topElev{field.mEvCount-ei-1};
+                const uint topElev{static_cast<uint>(field.mEvs.size()-ei-1)};
 
-                for(uint ai{0u};ai < field.mEvs[ei].mAzCount;ai++)
+                for(uint ai{0u};ai < field.mEvs[ei].mAzs.size();ai++)
                 {
                     uint a0, a1;
                     double af;
@@ -1154,12 +692,12 @@ static void SynthesizeOnsets(HrirDataT *hData)
         }
         else
         {
-            field.mEvs[0].mAzs[0].mDelays[0] = field.mEvs[field.mEvCount-1].mAzs[0].mDelays[0];
+            field.mEvs[0].mAzs[0].mDelays[0] = field.mEvs[field.mEvs.size()-1].mAzs[0].mDelays[0];
             for(ei = 1u;ei < (upperElevReal+1)/2;++ei)
             {
-                const uint topElev{field.mEvCount-ei-1};
+                const uint topElev{static_cast<uint>(field.mEvs.size()-ei-1)};
 
-                for(uint ai{0u};ai < field.mEvs[ei].mAzCount;ai++)
+                for(uint ai{0u};ai < field.mEvs[ei].mAzs.size();ai++)
                 {
                     uint a0, a1;
                     double af;
@@ -1192,7 +730,7 @@ static void SynthesizeOnsets(HrirDataT *hData)
             const double ef{(field.mEvs[upperElevReal].mElevation - field.mEvs[ei].mElevation) /
                 (field.mEvs[upperElevReal].mElevation - field.mEvs[lowerElevFake].mElevation)};
 
-            for(uint ai{0u};ai < field.mEvs[ei].mAzCount;ai++)
+            for(uint ai{0u};ai < field.mEvs[ei].mAzs.size();ai++)
             {
                 uint a0, a1, a2, a3;
                 double af0, af1;
@@ -1218,103 +756,222 @@ static void SynthesizeOnsets(HrirDataT *hData)
             }
         }
     };
-    std::for_each(hData->mFds.begin(), hData->mFds.begin()+hData->mFdCount, proc_field);
+    std::for_each(hData->mFds.begin(), hData->mFds.end(), proc_field);
 }
 
 /* Attempt to synthesize any missing HRIRs at the bottom elevations of each
  * field.  Right now this just blends the lowest elevation HRIRs together and
- * applies some attenuation and high frequency damping.  It is a simple, if
+ * applies a low-pass filter to simulate body occlusion.  It is a simple, if
  * inaccurate model.
  */
 static void SynthesizeHrirs(HrirDataT *hData)
 {
     const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
-    const uint irSize{hData->mIrPoints};
+    auto htemp = std::vector<complex_d>(hData->mFftSize);
+    const uint m{hData->mFftSize/2u + 1u};
+    auto filter = std::vector<double>(m);
     const double beta{3.5e-6 * hData->mIrRate};
 
-    auto proc_field = [channels,irSize,beta](HrirFdT &field) -> void
+    auto proc_field = [channels,m,beta,&htemp,&filter](HrirFdT &field) -> void
     {
         const uint oi{field.mEvStart};
         if(oi <= 0) return;
 
         for(uint ti{0u};ti < channels;ti++)
         {
-            for(uint i{0u};i < irSize;i++)
-                field.mEvs[0].mAzs[0].mIrs[ti][i] = 0.0;
-            /* Blend the lowest defined elevation's responses for an average
-             * -90 degree elevation response.
+            uint a0, a1;
+            double af;
+
+            /* Use the lowest immediate-left response for the left ear and
+             * lowest immediate-right response for the right ear. Given no comb
+             * effects as a result of the left response reaching the right ear
+             * and vice-versa, this produces a decent phantom-center response
+             * underneath the head.
              */
-            double blend_count{0.0};
-            for(uint ai{0u};ai < field.mEvs[oi].mAzCount;ai++)
+            CalcAzIndices(field, oi, ((ti==0) ? -M_PI : M_PI) / 2.0, &a0, &a1, &af);
+            for(uint i{0u};i < m;i++)
             {
-                /* Only include the left responses for the left ear, and the
-                 * right responses for the right ear. This removes the cross-
-                 * talk that shouldn't exist for the -90 degree elevation
-                 * response (and would be mistimed anyway). NOTE: Azimuth goes
-                 * from 0...2pi rather than -pi...+pi (0 in front, clockwise).
-                 */
-                if(std::abs(field.mEvs[oi].mAzs[ai].mAzimuth) < EPSILON ||
-                   (ti == LeftChannel && field.mEvs[oi].mAzs[ai].mAzimuth > M_PI-EPSILON) ||
-                   (ti == RightChannel && field.mEvs[oi].mAzs[ai].mAzimuth < M_PI+EPSILON))
-                {
-                    for(uint i{0u};i < irSize;i++)
-                        field.mEvs[0].mAzs[0].mIrs[ti][i] += field.mEvs[oi].mAzs[ai].mIrs[ti][i];
-                    blend_count += 1.0;
-                }
+                field.mEvs[0].mAzs[0].mIrs[ti][i] = Lerp(field.mEvs[oi].mAzs[a0].mIrs[ti][i],
+                    field.mEvs[oi].mAzs[a1].mIrs[ti][i], af);
             }
-            if(blend_count > 0.0)
+        }
+
+        for(uint ei{1u};ei < field.mEvStart;ei++)
+        {
+            const double of{static_cast<double>(ei) / field.mEvStart};
+            const double b{(1.0 - of) * beta};
+            double lp[4]{};
+
+            /* Calculate a low-pass filter to simulate body occlusion. */
+            lp[0] = Lerp(1.0, lp[0], b);
+            lp[1] = Lerp(lp[0], lp[1], b);
+            lp[2] = Lerp(lp[1], lp[2], b);
+            lp[3] = Lerp(lp[2], lp[3], b);
+            htemp[0] = lp[3];
+            for(size_t i{1u};i < htemp.size();i++)
             {
-                for(uint i{0u};i < irSize;i++)
-                    field.mEvs[0].mAzs[0].mIrs[ti][i] /= blend_count;
+                lp[0] = Lerp(0.0, lp[0], b);
+                lp[1] = Lerp(lp[0], lp[1], b);
+                lp[2] = Lerp(lp[1], lp[2], b);
+                lp[3] = Lerp(lp[2], lp[3], b);
+                htemp[i] = lp[3];
             }
+            /* Get the filter's frequency-domain response and extract the
+             * frequency magnitudes (phase will be reconstructed later)).
+             */
+            FftForward(static_cast<uint>(htemp.size()), htemp.data());
+            std::transform(htemp.cbegin(), htemp.cbegin()+m, filter.begin(),
+                [](const complex_d &c) -> double { return std::abs(c); });
 
-            for(uint ei{1u};ei < field.mEvStart;ei++)
+            for(uint ai{0u};ai < field.mEvs[ei].mAzs.size();ai++)
             {
-                const double of{static_cast<double>(ei) / field.mEvStart};
-                const double b{(1.0 - of) * beta};
-                for(uint ai{0u};ai < field.mEvs[ei].mAzCount;ai++)
-                {
-                    uint a0, a1;
-                    double af;
+                uint a0, a1;
+                double af;
 
-                    CalcAzIndices(field, oi, field.mEvs[ei].mAzs[ai].mAzimuth, &a0, &a1, &af);
-                    double lp[4]{};
-                    for(uint i{0u};i < irSize;i++)
+                CalcAzIndices(field, oi, field.mEvs[ei].mAzs[ai].mAzimuth, &a0, &a1, &af);
+                for(uint ti{0u};ti < channels;ti++)
+                {
+                    for(uint i{0u};i < m;i++)
                     {
                         /* Blend the two defined HRIRs closest to this azimuth,
                          * then blend that with the synthesized -90 elevation.
                          */
                         const double s1{Lerp(field.mEvs[oi].mAzs[a0].mIrs[ti][i],
                             field.mEvs[oi].mAzs[a1].mIrs[ti][i], af)};
-                        const double s0{Lerp(field.mEvs[0].mAzs[0].mIrs[ti][i], s1, of)};
-                        /* Apply a low-pass to simulate body occlusion. */
-                        lp[0] = Lerp(s0, lp[0], b);
-                        lp[1] = Lerp(lp[0], lp[1], b);
-                        lp[2] = Lerp(lp[1], lp[2], b);
-                        lp[3] = Lerp(lp[2], lp[3], b);
-                        field.mEvs[ei].mAzs[ai].mIrs[ti][i] = lp[3];
+                        const double s{Lerp(field.mEvs[0].mAzs[0].mIrs[ti][i], s1, of)};
+                        field.mEvs[ei].mAzs[ai].mIrs[ti][i] = s * filter[i];
                     }
                 }
             }
-            const double b{beta};
-            double lp[4]{};
-            for(uint i{0u};i < irSize;i++)
-            {
-                const double s0{field.mEvs[0].mAzs[0].mIrs[ti][i]};
-                lp[0] = Lerp(s0, lp[0], b);
-                lp[1] = Lerp(lp[0], lp[1], b);
-                lp[2] = Lerp(lp[1], lp[2], b);
-                lp[3] = Lerp(lp[2], lp[3], b);
-                field.mEvs[0].mAzs[0].mIrs[ti][i] = lp[3];
-            }
         }
-        field.mEvStart = 0;
+        const double b{beta};
+        double lp[4]{};
+        lp[0] = Lerp(1.0, lp[0], b);
+        lp[1] = Lerp(lp[0], lp[1], b);
+        lp[2] = Lerp(lp[1], lp[2], b);
+        lp[3] = Lerp(lp[2], lp[3], b);
+        htemp[0] = lp[3];
+        for(size_t i{1u};i < htemp.size();i++)
+        {
+            lp[0] = Lerp(0.0, lp[0], b);
+            lp[1] = Lerp(lp[0], lp[1], b);
+            lp[2] = Lerp(lp[1], lp[2], b);
+            lp[3] = Lerp(lp[2], lp[3], b);
+            htemp[i] = lp[3];
+        }
+        FftForward(static_cast<uint>(htemp.size()), htemp.data());
+        std::transform(htemp.cbegin(), htemp.cbegin()+m, filter.begin(),
+            [](const complex_d &c) -> double { return std::abs(c); });
+
+        for(uint ti{0u};ti < channels;ti++)
+        {
+            for(uint i{0u};i < m;i++)
+                field.mEvs[0].mAzs[0].mIrs[ti][i] *= filter[i];
+        }
     };
-    std::for_each(hData->mFds.begin(), hData->mFds.begin()+hData->mFdCount, proc_field);
+    std::for_each(hData->mFds.begin(), hData->mFds.end(), proc_field);
 }
 
 // The following routines assume a full set of HRIRs for all elevations.
 
+/* Perform minimum-phase reconstruction using the magnitude responses of the
+ * HRIR set. Work is delegated to this struct, which runs asynchronously on one
+ * or more threads (sharing the same reconstructor object).
+ */
+struct HrirReconstructor {
+    std::vector<double*> mIrs;
+    std::atomic<size_t> mCurrent;
+    std::atomic<size_t> mDone;
+    uint mFftSize;
+    uint mIrPoints;
+
+    void Worker()
+    {
+        auto h = std::vector<complex_d>(mFftSize);
+        auto mags = std::vector<double>(mFftSize);
+        size_t m{(mFftSize/2) + 1};
+
+        while(1)
+        {
+            /* Load the current index to process. */
+            size_t idx{mCurrent.load()};
+            do {
+                /* If the index is at the end, we're done. */
+                if(idx >= mIrs.size())
+                    return;
+                /* Otherwise, increment the current index atomically so other
+                 * threads know to go to the next one. If this call fails, the
+                 * current index was just changed by another thread and the new
+                 * value is loaded into idx, which we'll recheck.
+                 */
+            } while(!mCurrent.compare_exchange_weak(idx, idx+1, std::memory_order_relaxed));
+
+            /* Now do the reconstruction, and apply the inverse FFT to get the
+             * time-domain response.
+             */
+            for(size_t i{0};i < m;++i)
+                mags[i] = std::max(mIrs[idx][i], EPSILON);
+            MinimumPhase(mFftSize, mags.data(), h.data());
+            FftInverse(mFftSize, h.data());
+            for(uint i{0u};i < mIrPoints;++i)
+                mIrs[idx][i] = h[i].real();
+
+            /* Increment the number of IRs done. */
+            mDone.fetch_add(1);
+        }
+    }
+};
+
+static void ReconstructHrirs(const HrirDataT *hData, const uint numThreads)
+{
+    const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
+
+    /* Set up the reconstructor with the needed size info and pointers to the
+     * IRs to process.
+     */
+    HrirReconstructor reconstructor;
+    reconstructor.mCurrent.store(0, std::memory_order_relaxed);
+    reconstructor.mDone.store(0, std::memory_order_relaxed);
+    reconstructor.mFftSize = hData->mFftSize;
+    reconstructor.mIrPoints = hData->mIrPoints;
+    for(const auto &field : hData->mFds)
+    {
+        for(auto &elev : field.mEvs)
+        {
+            for(const auto &azd : elev.mAzs)
+            {
+                for(uint ti{0u};ti < channels;ti++)
+                    reconstructor.mIrs.push_back(azd.mIrs[ti]);
+            }
+        }
+    }
+
+    /* Launch threads to work on reconstruction. */
+    std::vector<std::thread> thrds;
+    thrds.reserve(numThreads);
+    for(size_t i{0};i < numThreads;++i)
+        thrds.emplace_back(std::mem_fn(&HrirReconstructor::Worker), &reconstructor);
+
+    /* Keep track of the number of IRs done, periodically reporting it. */
+    size_t count;
+    do {
+        std::this_thread::sleep_for(std::chrono::milliseconds{50});
+
+        count = reconstructor.mDone.load();
+        size_t pcdone{count * 100 / reconstructor.mIrs.size()};
+
+        printf("\r%3zu%% done (%zu of %zu)", pcdone, count, reconstructor.mIrs.size());
+        fflush(stdout);
+    } while(count < reconstructor.mIrs.size());
+    fputc('\n', stdout);
+
+    for(auto &thrd : thrds)
+    {
+        if(thrd.joinable())
+            thrd.join();
+    }
+}
+
 // Normalize the HRIR set and slightly attenuate the result.
 static void NormalizeHrirs(HrirDataT *hData)
 {
@@ -1323,35 +980,28 @@ static void NormalizeHrirs(HrirDataT *hData)
 
     /* Find the maximum amplitude and RMS out of all the IRs. */
     struct LevelPair { double amp, rms; };
-    auto proc0_field = [channels,irSize](const LevelPair levels0, const HrirFdT &field) -> LevelPair
+    auto mesasure_channel = [irSize](const LevelPair levels, const double *ir)
     {
-        auto proc_elev = [channels,irSize](const LevelPair levels1, const HrirEvT &elev) -> LevelPair
-        {
-            auto proc_azi = [channels,irSize](const LevelPair levels2, const HrirAzT &azi) -> LevelPair
+        /* Calculate the peak amplitude and RMS of this IR. */
+        auto current = std::accumulate(ir, ir+irSize, LevelPair{0.0, 0.0},
+            [](const LevelPair cur, const double impulse)
             {
-                auto proc_channel = [irSize](const LevelPair levels3, const double *ir) -> LevelPair
-                {
-                    /* Calculate the peak amplitude and RMS of this IR. */
-                    auto current = std::accumulate(ir, ir+irSize, LevelPair{0.0, 0.0},
-                        [](const LevelPair cur, const double impulse) -> LevelPair
-                        {
-                            return {std::max(std::abs(impulse), cur.amp),
-                                cur.rms + impulse*impulse};
-                        });
-                    current.rms = std::sqrt(current.rms / irSize);
-
-                    /* Accumulate levels by taking the maximum amplitude and RMS. */
-                    return LevelPair{std::max(current.amp, levels3.amp),
-                        std::max(current.rms, levels3.rms)};
-                };
-                return std::accumulate(azi.mIrs, azi.mIrs+channels, levels2, proc_channel);
-            };
-            return std::accumulate(elev.mAzs, elev.mAzs+elev.mAzCount, levels1, proc_azi);
-        };
-        return std::accumulate(field.mEvs, field.mEvs+field.mEvCount, levels0, proc_elev);
+                return LevelPair{std::max(std::abs(impulse), cur.amp), cur.rms + impulse*impulse};
+            });
+        current.rms = std::sqrt(current.rms / irSize);
+
+        /* Accumulate levels by taking the maximum amplitude and RMS. */
+        return LevelPair{std::max(current.amp, levels.amp), std::max(current.rms, levels.rms)};
     };
-    const auto maxlev = std::accumulate(hData->mFds.begin(), hData->mFds.begin()+hData->mFdCount,
-        LevelPair{0.0, 0.0}, proc0_field);
+    auto measure_azi = [channels,mesasure_channel](const LevelPair levels, const HrirAzT &azi)
+    { return std::accumulate(azi.mIrs, azi.mIrs+channels, levels, mesasure_channel); };
+    auto measure_elev = [measure_azi](const LevelPair levels, const HrirEvT &elev)
+    { return std::accumulate(elev.mAzs.cbegin(), elev.mAzs.cend(), levels, measure_azi); };
+    auto measure_field = [measure_elev](const LevelPair levels, const HrirFdT &field)
+    { return std::accumulate(field.mEvs.cbegin(), field.mEvs.cend(), levels, measure_elev); };
+
+    const auto maxlev = std::accumulate(hData->mFds.begin(), hData->mFds.end(),
+        LevelPair{0.0, 0.0}, measure_field);
 
     /* Normalize using the maximum RMS of the HRIRs. The RMS measure for the
      * non-filtered signal is of an impulse with equal length (to the filter):
@@ -1368,24 +1018,16 @@ static void NormalizeHrirs(HrirDataT *hData)
     factor = std::min(factor, 0.99/maxlev.amp);
 
     /* Now scale all IRs by the given factor. */
-    auto proc1_field = [channels,irSize,factor](HrirFdT &field) -> void
-    {
-        auto proc_elev = [channels,irSize,factor](HrirEvT &elev) -> void
-        {
-            auto proc_azi = [channels,irSize,factor](HrirAzT &azi) -> void
-            {
-                auto proc_channel = [irSize,factor](double *ir) -> void
-                {
-                    std::transform(ir, ir+irSize, ir,
-                        std::bind(std::multiplies<double>{}, _1, factor));
-                };
-                std::for_each(azi.mIrs, azi.mIrs+channels, proc_channel);
-            };
-            std::for_each(elev.mAzs, elev.mAzs+elev.mAzCount, proc_azi);
-        };
-        std::for_each(field.mEvs, field.mEvs+field.mEvCount, proc_elev);
-    };
-    std::for_each(hData->mFds.begin(), hData->mFds.begin()+hData->mFdCount, proc1_field);
+    auto proc_channel = [irSize,factor](double *ir)
+    { std::transform(ir, ir+irSize, ir, [factor](double s){ return s * factor; }); };
+    auto proc_azi = [channels,proc_channel](HrirAzT &azi)
+    { std::for_each(azi.mIrs, azi.mIrs+channels, proc_channel); };
+    auto proc_elev = [proc_azi](HrirEvT &elev)
+    { std::for_each(elev.mAzs.begin(), elev.mAzs.end(), proc_azi); };
+    auto proc1_field = [proc_elev](HrirFdT &field)
+    { std::for_each(field.mEvs.begin(), field.mEvs.end(), proc_elev); };
+
+    std::for_each(hData->mFds.begin(), hData->mFds.end(), proc1_field);
 }
 
 // Calculate the left-ear time delay using a spherical head model.
@@ -1408,111 +1050,115 @@ static void CalculateHrtds(const HeadModelT model, const double radius, HrirData
 {
     uint channels = (hData->mChannelType == CT_STEREO) ? 2 : 1;
     double customRatio{radius / hData->mRadius};
-    uint ti, fi, ei, ai;
+    uint ti;
 
     if(model == HM_SPHERE)
     {
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(auto &field : hData->mFds)
         {
-            for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+            for(auto &elev : field.mEvs)
             {
-                HrirEvT *evd = &hData->mFds[fi].mEvs[ei];
-
-                for(ai = 0;ai < evd->mAzCount;ai++)
+                for(auto &azd : elev.mAzs)
                 {
-                    HrirAzT *azd = &evd->mAzs[ai];
-
                     for(ti = 0;ti < channels;ti++)
-                        azd->mDelays[ti] = CalcLTD(evd->mElevation, azd->mAzimuth, radius, hData->mFds[fi].mDistance);
+                        azd.mDelays[ti] = CalcLTD(elev.mElevation, azd.mAzimuth, radius, field.mDistance);
                 }
             }
         }
     }
     else if(customRatio != 1.0)
     {
-        for(fi = 0;fi < hData->mFdCount;fi++)
+        for(auto &field : hData->mFds)
         {
-            for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+            for(auto &elev : field.mEvs)
             {
-                HrirEvT *evd = &hData->mFds[fi].mEvs[ei];
-
-                for(ai = 0;ai < evd->mAzCount;ai++)
+                for(auto &azd : elev.mAzs)
                 {
-                    HrirAzT *azd = &evd->mAzs[ai];
                     for(ti = 0;ti < channels;ti++)
-                        azd->mDelays[ti] *= customRatio;
+                        azd.mDelays[ti] *= customRatio;
                 }
             }
         }
     }
 
-    for(fi = 0;fi < hData->mFdCount;fi++)
+    double maxHrtd{0.0};
+    for(auto &field : hData->mFds)
     {
         double minHrtd{std::numeric_limits<double>::infinity()};
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        for(auto &elev : field.mEvs)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(auto &azd : elev.mAzs)
             {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
-
                 for(ti = 0;ti < channels;ti++)
-                    minHrtd = std::min(azd->mDelays[ti], minHrtd);
+                    minHrtd = std::min(azd.mDelays[ti], minHrtd);
             }
         }
 
-        for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
+        for(auto &elev : field.mEvs)
         {
-            for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
+            for(auto &azd : elev.mAzs)
             {
-                HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
-
                 for(ti = 0;ti < channels;ti++)
-                    azd->mDelays[ti] -= minHrtd;
+                {
+                    azd.mDelays[ti] = (azd.mDelays[ti]-minHrtd) * hData->mIrRate;
+                    maxHrtd = std::max(maxHrtd, azd.mDelays[ti]);
+                }
+            }
+        }
+    }
+    if(maxHrtd > MAX_HRTD)
+    {
+        fprintf(stdout, "  Scaling for max delay of %f samples to %f\n...\n", maxHrtd, MAX_HRTD);
+        const double scale{MAX_HRTD / maxHrtd};
+        for(auto &field : hData->mFds)
+        {
+            for(auto &elev : field.mEvs)
+            {
+                for(auto &azd : elev.mAzs)
+                {
+                    for(ti = 0;ti < channels;ti++)
+                        azd.mDelays[ti] *= scale;
+                }
             }
         }
     }
 }
 
 // Allocate and configure dynamic HRIR structures.
-int PrepareHrirData(const uint fdCount, const double (&distances)[MAX_FD_COUNT],
-    const uint (&evCounts)[MAX_FD_COUNT], const uint azCounts[MAX_FD_COUNT * MAX_EV_COUNT],
-    HrirDataT *hData)
+bool PrepareHrirData(const al::span<const double> distances,
+    const al::span<const uint,MAX_FD_COUNT> evCounts,
+    const al::span<const std::array<uint,MAX_EV_COUNT>,MAX_FD_COUNT> azCounts, HrirDataT *hData)
 {
-    uint evTotal = 0, azTotal = 0, fi, ei, ai;
+    uint evTotal{0}, azTotal{0};
 
-    for(fi = 0;fi < fdCount;fi++)
+    for(size_t fi{0};fi < distances.size();++fi)
     {
         evTotal += evCounts[fi];
-        for(ei = 0;ei < evCounts[fi];ei++)
-            azTotal += azCounts[(fi * MAX_EV_COUNT) + ei];
+        for(size_t ei{0};ei < evCounts[fi];++ei)
+            azTotal += azCounts[fi][ei];
     }
-    if(!fdCount || !evTotal || !azTotal)
-        return 0;
+    if(!evTotal || !azTotal)
+        return false;
 
     hData->mEvsBase.resize(evTotal);
     hData->mAzsBase.resize(azTotal);
-    hData->mFds.resize(fdCount);
+    hData->mFds.resize(distances.size());
     hData->mIrCount = azTotal;
-    hData->mFdCount = fdCount;
     evTotal = 0;
     azTotal = 0;
-    for(fi = 0;fi < fdCount;fi++)
+    for(size_t fi{0};fi < distances.size();++fi)
     {
         hData->mFds[fi].mDistance = distances[fi];
-        hData->mFds[fi].mEvCount = evCounts[fi];
         hData->mFds[fi].mEvStart = 0;
-        hData->mFds[fi].mEvs = &hData->mEvsBase[evTotal];
+        hData->mFds[fi].mEvs = {&hData->mEvsBase[evTotal], evCounts[fi]};
         evTotal += evCounts[fi];
-        for(ei = 0;ei < evCounts[fi];ei++)
+        for(uint ei{0};ei < evCounts[fi];++ei)
         {
-            uint azCount = azCounts[(fi * MAX_EV_COUNT) + ei];
+            uint azCount = azCounts[fi][ei];
 
-            hData->mFds[fi].mIrCount += azCount;
             hData->mFds[fi].mEvs[ei].mElevation = -M_PI / 2.0 + M_PI * ei / (evCounts[fi] - 1);
-            hData->mFds[fi].mEvs[ei].mIrCount += azCount;
-            hData->mFds[fi].mEvs[ei].mAzCount = azCount;
-            hData->mFds[fi].mEvs[ei].mAzs = &hData->mAzsBase[azTotal];
-            for(ai = 0;ai < azCount;ai++)
+            hData->mFds[fi].mEvs[ei].mAzs = {&hData->mAzsBase[azTotal], azCount};
+            for(uint ai{0};ai < azCount;ai++)
             {
                 hData->mFds[fi].mEvs[ei].mAzs[ai].mAzimuth = 2.0 * M_PI * ai / azCount;
                 hData->mFds[fi].mEvs[ei].mAzs[ai].mIndex = azTotal + ai;
@@ -1524,7 +1170,7 @@ int PrepareHrirData(const uint fdCount, const double (&distances)[MAX_FD_COUNT],
             azTotal += azCount;
         }
     }
-    return 1;
+    return true;
 }
 
 
@@ -1533,17 +1179,18 @@ int PrepareHrirData(const uint fdCount, const double (&distances)[MAX_FD_COUNT],
  * from standard input.
  */
 static int ProcessDefinition(const char *inName, const uint outRate, const ChannelModeT chanMode,
-    const uint fftSize, const int equalize, const int surface, const double limit,
-    const uint truncSize, const HeadModelT model, const double radius, const char *outName)
+    const bool farfield, const uint numThreads, const uint fftSize, const int equalize,
+    const int surface, const double limit, const uint truncSize, const HeadModelT model,
+    const double radius, const char *outName)
 {
-    char rateStr[8+1], expName[MAX_PATH_LEN];
     HrirDataT hData;
 
+    fprintf(stdout, "Using %u thread%s.\n", numThreads, (numThreads==1)?"":"s");
     if(!inName)
     {
         inName = "stdin";
         fprintf(stdout, "Reading HRIR definition from %s...\n", inName);
-        if(!LoadDefInput(std::cin, nullptr, 0, inName, fftSize, truncSize, chanMode, &hData))
+        if(!LoadDefInput(std::cin, nullptr, 0, inName, fftSize, truncSize, outRate, chanMode, &hData))
             return 0;
     }
     else
@@ -1569,13 +1216,13 @@ static int ProcessDefinition(const char *inName, const uint outRate, const Chann
         {
             input = nullptr;
             fprintf(stdout, "Reading HRTF data from %s...\n", inName);
-            if(!LoadSofaFile(inName, fftSize, truncSize, chanMode, &hData))
+            if(!LoadSofaFile(inName, numThreads, fftSize, truncSize, outRate, chanMode, &hData))
                 return 0;
         }
         else
         {
             fprintf(stdout, "Reading HRIR definition from %s...\n", inName);
-            if(!LoadDefInput(*input, startbytes, startbytecount, inName, fftSize, truncSize, chanMode, &hData))
+            if(!LoadDefInput(*input, startbytes, startbytecount, inName, fftSize, truncSize, outRate, chanMode, &hData))
                 return 0;
         }
     }
@@ -1586,7 +1233,7 @@ static int ProcessDefinition(const char *inName, const uint outRate, const Chann
         uint m{hData.mFftSize/2u + 1u};
         auto dfa = std::vector<double>(c * m);
 
-        if(hData.mFdCount > 1)
+        if(hData.mFds.size() > 1)
         {
             fprintf(stdout, "Balancing field magnitudes...\n");
             BalanceFieldMagnitudes(&hData, c, m);
@@ -1596,27 +1243,37 @@ static int ProcessDefinition(const char *inName, const uint outRate, const Chann
         fprintf(stdout, "Performing diffuse-field equalization...\n");
         DiffuseFieldEqualize(c, m, dfa.data(), &hData);
     }
-    fprintf(stdout, "Performing minimum phase reconstruction...\n");
-    ReconstructHrirs(&hData);
-    if(outRate != 0 && outRate != hData.mIrRate)
+    if(hData.mFds.size() > 1)
     {
-        fprintf(stdout, "Resampling HRIRs...\n");
-        ResampleHrirs(outRate, &hData);
+        fprintf(stdout, "Sorting %zu fields...\n", hData.mFds.size());
+        std::sort(hData.mFds.begin(), hData.mFds.end(),
+            [](const HrirFdT &lhs, const HrirFdT &rhs) noexcept
+            { return lhs.mDistance < rhs.mDistance; });
+        if(farfield)
+        {
+            fprintf(stdout, "Clearing %zu near field%s...\n", hData.mFds.size()-1,
+                (hData.mFds.size()-1 != 1) ? "s" : "");
+            hData.mFds.erase(hData.mFds.cbegin(), hData.mFds.cend()-1);
+        }
     }
-    fprintf(stdout, "Truncating minimum-phase HRIRs...\n");
-    hData.mIrPoints = truncSize;
     fprintf(stdout, "Synthesizing missing elevations...\n");
     if(model == HM_DATASET)
         SynthesizeOnsets(&hData);
     SynthesizeHrirs(&hData);
+    fprintf(stdout, "Performing minimum phase reconstruction...\n");
+    ReconstructHrirs(&hData, numThreads);
+    fprintf(stdout, "Truncating minimum-phase HRIRs...\n");
+    hData.mIrPoints = truncSize;
     fprintf(stdout, "Normalizing final HRIRs...\n");
     NormalizeHrirs(&hData);
     fprintf(stdout, "Calculating impulse delays...\n");
     CalculateHrtds(model, (radius > DEFAULT_CUSTOM_RADIUS) ? radius : hData.mRadius, &hData);
-    snprintf(rateStr, sizeof(rateStr), "%u", hData.mIrRate);
-    StrSubst(outName, "%r", rateStr, sizeof(expName), expName);
-    fprintf(stdout, "Creating MHR data set %s...\n", expName);
-    return StoreMhr(&hData, expName);
+
+    const auto rateStr = std::to_string(hData.mIrRate);
+    const auto expName = StrSubst({outName, strlen(outName)}, {"%r", 2},
+        {rateStr.data(), rateStr.size()});
+    fprintf(stdout, "Creating MHR data set %s...\n", expName.c_str());
+    return StoreMhr(&hData, expName.c_str());
 }
 
 static void PrintHelp(const char *argv0, FILE *ofile)
@@ -1627,6 +1284,8 @@ static void PrintHelp(const char *argv0, FILE *ofile)
     fprintf(ofile, "                 resample the HRIRs accordingly.\n");
     fprintf(ofile, " -m              Change the data set to mono, mirroring the left ear for the\n");
     fprintf(ofile, "                 right ear.\n");
+    fprintf(ofile, " -a              Change the data set to single field, using the farthest field.\n");
+    fprintf(ofile, " -j <threads>    Number of threads used to process HRIRs (default: 2).\n");
     fprintf(ofile, " -f <points>     Override the FFT window size (default: %u).\n", DEFAULT_FFTSIZE);
     fprintf(ofile, " -e {on|off}     Toggle diffuse-field equalization (default: %s).\n", (DEFAULT_EQUALIZE ? "on" : "off"));
     fprintf(ofile, " -s {on|off}     Toggle surface-weighted diffuse-field average (default: %s).\n", (DEFAULT_SURFACE ? "on" : "off"));
@@ -1651,13 +1310,13 @@ int main(int argc, char *argv[])
     char *end = nullptr;
     ChannelModeT chanMode;
     HeadModelT model;
+    uint numThreads;
     uint truncSize;
     double radius;
+    bool farfield;
     double limit;
     int opt;
 
-    GET_UNICODE_ARGS(&argc, &argv);
-
     if(argc < 2)
     {
         fprintf(stdout, "HRTF Processing and Composition Utility\n\n");
@@ -1672,11 +1331,13 @@ int main(int argc, char *argv[])
     equalize = DEFAULT_EQUALIZE;
     surface = DEFAULT_SURFACE;
     limit = DEFAULT_LIMIT;
+    numThreads = 2;
     truncSize = DEFAULT_TRUNCSIZE;
     model = DEFAULT_HEAD_MODEL;
     radius = DEFAULT_CUSTOM_RADIUS;
+    farfield = false;
 
-    while((opt=getopt(argc, argv, "r:mf:e:s:l:w:d:c:e:i:o:h")) != -1)
+    while((opt=getopt(argc, argv, "r:maj:f:e:s:l:w:d:c:e:i:o:h")) != -1)
     {
         switch(opt)
         {
@@ -1693,6 +1354,21 @@ int main(int argc, char *argv[])
             chanMode = CM_ForceMono;
             break;
 
+        case 'a':
+            farfield = true;
+            break;
+
+        case 'j':
+            numThreads = static_cast<uint>(strtoul(optarg, &end, 10));
+            if(end[0] != '\0' || numThreads > 64)
+            {
+                fprintf(stderr, "\nError: Got unexpected value \"%s\" for option -%c, expected between %u to %u.\n", optarg, opt, 0, 64);
+                exit(EXIT_FAILURE);
+            }
+            if(numThreads == 0)
+                numThreads = std::thread::hardware_concurrency();
+            break;
+
         case 'f':
             fftSize = static_cast<uint>(strtoul(optarg, &end, 10));
             if(end[0] != '\0' || (fftSize&(fftSize-1)) || fftSize < MIN_FFTSIZE || fftSize > MAX_FFTSIZE)
@@ -1742,9 +1418,9 @@ int main(int argc, char *argv[])
 
         case 'w':
             truncSize = static_cast<uint>(strtoul(optarg, &end, 10));
-            if(end[0] != '\0' || truncSize < MIN_TRUNCSIZE || truncSize > MAX_TRUNCSIZE || (truncSize%MOD_TRUNCSIZE))
+            if(end[0] != '\0' || truncSize < MIN_TRUNCSIZE || truncSize > MAX_TRUNCSIZE)
             {
-                fprintf(stderr, "\nError: Got unexpected value \"%s\" for option -%c, expected multiple of %u between %u to %u.\n", optarg, opt, MOD_TRUNCSIZE, MIN_TRUNCSIZE, MAX_TRUNCSIZE);
+                fprintf(stderr, "\nError: Got unexpected value \"%s\" for option -%c, expected between %u to %u.\n", optarg, opt, MIN_TRUNCSIZE, MAX_TRUNCSIZE);
                 exit(EXIT_FAILURE);
             }
             break;
@@ -1788,8 +1464,8 @@ int main(int argc, char *argv[])
         }
     }
 
-    int ret = ProcessDefinition(inName, outRate, chanMode, fftSize, equalize, surface, limit,
-        truncSize, model, radius, outName);
+    int ret = ProcessDefinition(inName, outRate, chanMode, farfield, numThreads, fftSize, equalize,
+        surface, limit, truncSize, model, radius, outName);
     if(!ret) return -1;
     fprintf(stdout, "Operation completed.\n");
 
diff --git a/utils/makemhr/makemhr.h b/utils/makemhr/makemhr.h
index ba19efbe..13b5b2d1 100644
--- a/utils/makemhr/makemhr.h
+++ b/utils/makemhr/makemhr.h
@@ -4,6 +4,9 @@
 #include <vector>
 #include <complex>
 
+#include "alcomplex.h"
+#include "polyphase_resampler.h"
+
 
 // The maximum path length used when processing filenames.
 #define MAX_PATH_LEN                 (256)
@@ -71,17 +74,13 @@ struct HrirAzT {
 
 struct HrirEvT {
     double mElevation{0.0};
-    uint mIrCount{0u};
-    uint mAzCount{0u};
-    HrirAzT *mAzs{nullptr};
+    al::span<HrirAzT> mAzs;
 };
 
 struct HrirFdT {
     double mDistance{0.0};
-    uint mIrCount{0u};
-    uint mEvCount{0u};
     uint mEvStart{0u};
-    HrirEvT *mEvs{nullptr};
+    al::span<HrirEvT> mEvs;
 };
 
 // The HRIR metrics and data set used when loading, processing, and storing
@@ -95,31 +94,35 @@ struct HrirDataT {
     uint mIrSize{0u};
     double mRadius{0.0};
     uint mIrCount{0u};
-    uint mFdCount{0u};
 
     std::vector<double> mHrirsBase;
     std::vector<HrirEvT> mEvsBase;
     std::vector<HrirAzT> mAzsBase;
 
     std::vector<HrirFdT> mFds;
+
+    /* GCC warns when it tries to inline this. */
+    ~HrirDataT();
 };
 
 
-int PrepareHrirData(const uint fdCount, const double (&distances)[MAX_FD_COUNT], const uint (&evCounts)[MAX_FD_COUNT], const uint azCounts[MAX_FD_COUNT * MAX_EV_COUNT], HrirDataT *hData);
+bool PrepareHrirData(const al::span<const double> distances,
+    const al::span<const uint,MAX_FD_COUNT> evCounts,
+    const al::span<const std::array<uint,MAX_EV_COUNT>,MAX_FD_COUNT> azCounts, HrirDataT *hData);
 void MagnitudeResponse(const uint n, const complex_d *in, double *out);
-void FftForward(const uint n, complex_d *inout);
-void FftInverse(const uint n, complex_d *inout);
-
-
-// The resampler metrics and FIR filter.
-struct ResamplerT {
-    uint mP, mQ, mM, mL;
-    std::vector<double> mF;
-};
-
-void ResamplerSetup(ResamplerT *rs, const uint srcRate, const uint dstRate);
-void ResamplerRun(ResamplerT *rs, const uint inN, const double *in, const uint outN, double *out);
 
+// Performs a forward FFT.
+inline void FftForward(const uint n, complex_d *inout)
+{ forward_fft(al::as_span(inout, n)); }
+
+// Performs an inverse FFT.
+inline void FftInverse(const uint n, complex_d *inout)
+{
+    inverse_fft(al::as_span(inout, n));
+    double f{1.0 / n};
+    for(uint i{0};i < n;i++)
+        inout[i] *= f;
+}
 
 // Performs linear interpolation.
 inline double Lerp(const double a, const double b, const double f)
diff --git a/utils/openal-info.c b/utils/openal-info.c
index cdce77e0..b646693c 100644
--- a/utils/openal-info.c
+++ b/utils/openal-info.c
@@ -22,90 +22,29 @@
  * THE SOFTWARE.
  */
 
+#include <assert.h>
+#include <stdarg.h>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "AL/alc.h"
 #include "AL/al.h"
 #include "AL/alext.h"
 
-#ifndef ALC_ENUMERATE_ALL_EXT
-#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
-#define ALC_ALL_DEVICES_SPECIFIER                0x1013
-#endif
+#include "win_main_utf8.h"
 
-#ifndef ALC_EXT_EFX
-#define ALC_EFX_MAJOR_VERSION                    0x20001
-#define ALC_EFX_MINOR_VERSION                    0x20002
-#define ALC_MAX_AUXILIARY_SENDS                  0x20003
-#endif
-
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-static WCHAR *FromUTF8(const char *str)
-{
-    WCHAR *out = NULL;
-    int len;
-
-    if((len=MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) > 0)
-    {
-        out = calloc(sizeof(WCHAR), (unsigned int)(len));
-        MultiByteToWideChar(CP_UTF8, 0, str, -1, out, len);
-    }
-    return out;
-}
-
-/* Override printf, fprintf, and fwrite so we can print UTF-8 strings. */
-static void al_fprintf(FILE *file, const char *fmt, ...)
-{
-    char str[1024];
-    WCHAR *wstr;
-    va_list ap;
-
-    va_start(ap, fmt);
-    vsnprintf(str, sizeof(str), fmt, ap);
-    va_end(ap);
-
-    str[sizeof(str)-1] = 0;
-    wstr = FromUTF8(str);
-    if(!wstr)
-        fprintf(file, "<UTF-8 error> %s", str);
-    else
-        fprintf(file, "%ls", wstr);
-    free(wstr);
-}
-#define fprintf al_fprintf
-#define printf(...) al_fprintf(stdout, __VA_ARGS__)
-
-static size_t al_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *file)
-{
-    char str[1024];
-    WCHAR *wstr;
-    size_t len;
-
-    len = size * nmemb;
-    if(len > sizeof(str)-1)
-        len = sizeof(str)-1;
-    memcpy(str, ptr, len);
-    str[len] = 0;
-
-    wstr = FromUTF8(str);
-    if(!wstr)
-        fprintf(file, "<UTF-8 error> %s", str);
-    else
-        fprintf(file, "%ls", wstr);
-    free(wstr);
-
-    return len / size;
-}
-#define fwrite al_fwrite
+/* C doesn't allow casting between function and non-function pointer types, so
+ * with C99 we need to use a union to reinterpret the pointer type. Pre-C99
+ * still needs to use a normal cast and live with the warning (C++ is fine with
+ * a regular reinterpret_cast).
+ */
+#if __STDC_VERSION__ >= 199901L
+#define FUNCTION_CAST(T, ptr) (union{void *p; T f;}){ptr}.f
+#else
+#define FUNCTION_CAST(T, ptr) (T)(ptr)
 #endif
 
-
 #define MAX_WIDTH  80
 
 static void printList(const char *list, char separator)
@@ -223,7 +162,8 @@ static void printHRTFInfo(ALCdevice *device)
         return;
     }
 
-    alcGetStringiSOFT = (LPALCGETSTRINGISOFT)alcGetProcAddress(device, "alcGetStringiSOFT");
+    alcGetStringiSOFT = FUNCTION_CAST(LPALCGETSTRINGISOFT,
+        alcGetProcAddress(device, "alcGetStringiSOFT"));
 
     alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtfs);
     if(!num_hrtfs)
@@ -241,6 +181,40 @@ static void printHRTFInfo(ALCdevice *device)
     checkALCErrors(device);
 }
 
+static void printModeInfo(ALCdevice *device)
+{
+    ALCint srate = 0;
+
+    if(alcIsExtensionPresent(device, "ALC_SOFT_output_mode"))
+    {
+        const char *modename = "(error)";
+        ALCenum mode = 0;
+
+        alcGetIntegerv(device, ALC_OUTPUT_MODE_SOFT, 1, &mode);
+        checkALCErrors(device);
+        switch(mode)
+        {
+        case ALC_ANY_SOFT: modename = "Unknown / unspecified"; break;
+        case ALC_MONO_SOFT: modename = "Mono"; break;
+        case ALC_STEREO_SOFT: modename = "Stereo (unspecified encoding)"; break;
+        case ALC_STEREO_BASIC_SOFT: modename = "Stereo (basic)"; break;
+        case ALC_STEREO_UHJ_SOFT: modename = "Stereo (UHJ)"; break;
+        case ALC_STEREO_HRTF_SOFT: modename = "Stereo (HRTF)"; break;
+        case ALC_QUAD_SOFT: modename = "Quadraphonic"; break;
+        case ALC_SURROUND_5_1_SOFT: modename = "5.1 Surround"; break;
+        case ALC_SURROUND_6_1_SOFT: modename = "6.1 Surround"; break;
+        case ALC_SURROUND_7_1_SOFT: modename = "7.1 Surround"; break;
+        }
+        printf("Device output mode: %s\n", modename);
+    }
+    else
+        printf("Output mode extension not available\n");
+
+    alcGetIntegerv(device, ALC_FREQUENCY, 1, &srate);
+    if(checkALCErrors(device) == ALC_NO_ERROR)
+        printf("Device sample rate: %dhz\n", srate);
+}
+
 static void printALInfo(void)
 {
     printf("OpenAL vendor string: %s\n", alGetString(AL_VENDOR));
@@ -263,7 +237,7 @@ static void printResamplerInfo(void)
         return;
     }
 
-    alGetStringiSOFT = (LPALGETSTRINGISOFT)alGetProcAddress("alGetStringiSOFT");
+    alGetStringiSOFT = FUNCTION_CAST(LPALGETSTRINGISOFT, alGetProcAddress("alGetStringiSOFT"));
 
     num_resamplers = alGetInteger(AL_NUM_RESAMPLERS_SOFT);
     def_resampler = alGetInteger(AL_DEFAULT_RESAMPLER_SOFT);
@@ -285,26 +259,35 @@ static void printResamplerInfo(void)
 
 static void printEFXInfo(ALCdevice *device)
 {
-    ALCint major, minor, sends;
-    static const ALchar filters[][32] = {
-        "AL_FILTER_LOWPASS", "AL_FILTER_HIGHPASS", "AL_FILTER_BANDPASS", ""
+    static LPALGENFILTERS palGenFilters;
+    static LPALDELETEFILTERS palDeleteFilters;
+    static LPALFILTERI palFilteri;
+    static LPALGENEFFECTS palGenEffects;
+    static LPALDELETEEFFECTS palDeleteEffects;
+    static LPALEFFECTI palEffecti;
+
+    static const ALint filters[] = {
+        AL_FILTER_LOWPASS, AL_FILTER_HIGHPASS, AL_FILTER_BANDPASS,
+        AL_FILTER_NULL
     };
     char filterNames[] = "Low-pass,High-pass,Band-pass,";
-    static const ALchar effects[][32] = {
-        "AL_EFFECT_EAXREVERB", "AL_EFFECT_REVERB", "AL_EFFECT_CHORUS",
-        "AL_EFFECT_DISTORTION", "AL_EFFECT_ECHO", "AL_EFFECT_FLANGER",
-        "AL_EFFECT_FREQUENCY_SHIFTER", "AL_EFFECT_VOCAL_MORPHER",
-        "AL_EFFECT_PITCH_SHIFTER", "AL_EFFECT_RING_MODULATOR",
-        "AL_EFFECT_AUTOWAH", "AL_EFFECT_COMPRESSOR", "AL_EFFECT_EQUALIZER", ""
+    static const ALint effects[] = {
+        AL_EFFECT_EAXREVERB, AL_EFFECT_REVERB, AL_EFFECT_CHORUS,
+        AL_EFFECT_DISTORTION, AL_EFFECT_ECHO, AL_EFFECT_FLANGER,
+        AL_EFFECT_FREQUENCY_SHIFTER, AL_EFFECT_VOCAL_MORPHER,
+        AL_EFFECT_PITCH_SHIFTER, AL_EFFECT_RING_MODULATOR,
+        AL_EFFECT_AUTOWAH, AL_EFFECT_COMPRESSOR, AL_EFFECT_EQUALIZER,
+        AL_EFFECT_NULL
     };
-    static const ALchar dedeffects[][64] = {
-        "AL_EFFECT_DEDICATED_DIALOGUE",
-        "AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT", ""
+    static const ALint dedeffects[] = {
+        AL_EFFECT_DEDICATED_DIALOGUE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT,
+        AL_EFFECT_NULL
     };
     char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger,"
-                         "Frequency Shifter,Vocal Morpher,Pitch Shifter,"
-                         "Ring Modulator,Autowah,Compressor,Equalizer,"
-                         "Dedicated Dialog,Dedicated LFE,";
+        "Frequency Shifter,Vocal Morpher,Pitch Shifter,Ring Modulator,Autowah,"
+        "Compressor,Equalizer,Dedicated Dialog,Dedicated LFE,";
+    ALCint major, minor, sends;
+    ALuint object;
     char *current;
     int i;
 
@@ -314,6 +297,13 @@ static void printEFXInfo(ALCdevice *device)
         return;
     }
 
+    palGenFilters = FUNCTION_CAST(LPALGENFILTERS, alGetProcAddress("alGenFilters"));
+    palDeleteFilters = FUNCTION_CAST(LPALDELETEFILTERS, alGetProcAddress("alDeleteFilters"));
+    palFilteri = FUNCTION_CAST(LPALFILTERI, alGetProcAddress("alFilteri"));
+    palGenEffects = FUNCTION_CAST(LPALGENEFFECTS, alGetProcAddress("alGenEffects"));
+    palDeleteEffects = FUNCTION_CAST(LPALDELETEEFFECTS, alGetProcAddress("alDeleteEffects"));
+    palEffecti = FUNCTION_CAST(LPALEFFECTI, alGetProcAddress("alEffecti"));
+
     alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
     alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
     if(checkALCErrors(device) == ALC_NO_ERROR)
@@ -322,14 +312,17 @@ static void printEFXInfo(ALCdevice *device)
     if(checkALCErrors(device) == ALC_NO_ERROR)
         printf("Max auxiliary sends: %d\n", sends);
 
+    palGenFilters(1, &object);
+    checkALErrors();
+
     current = filterNames;
-    for(i = 0;filters[i][0];i++)
+    for(i = 0;filters[i] != AL_FILTER_NULL;i++)
     {
         char *next = strchr(current, ',');
-        ALenum val;
+        assert(next != NULL);
 
-        val = alGetEnumValue(filters[i]);
-        if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
+        palFilteri(object, AL_FILTER_TYPE, filters[i]);
+        if(alGetError() != AL_NO_ERROR)
             memmove(current, next+1, strlen(next));
         else
             current = next+1;
@@ -337,27 +330,31 @@ static void printEFXInfo(ALCdevice *device)
     printf("Supported filters:");
     printList(filterNames, ',');
 
+    palDeleteFilters(1, &object);
+    palGenEffects(1, &object);
+    checkALErrors();
+
     current = effectNames;
-    for(i = 0;effects[i][0];i++)
+    for(i = 0;effects[i] != AL_EFFECT_NULL;i++)
     {
         char *next = strchr(current, ',');
-        ALenum val;
+        assert(next != NULL);
 
-        val = alGetEnumValue(effects[i]);
-        if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
+        palEffecti(object, AL_EFFECT_TYPE, effects[i]);
+        if(alGetError() != AL_NO_ERROR)
             memmove(current, next+1, strlen(next));
         else
             current = next+1;
     }
     if(alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
     {
-        for(i = 0;dedeffects[i][0];i++)
+        for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
         {
             char *next = strchr(current, ',');
-            ALenum val;
+            assert(next != NULL);
 
-            val = alGetEnumValue(dedeffects[i]);
-            if(alGetError() != AL_NO_ERROR || val == 0 || val == -1)
+            palEffecti(object, AL_EFFECT_TYPE, dedeffects[i]);
+            if(alGetError() != AL_NO_ERROR)
                 memmove(current, next+1, strlen(next));
             else
                 current = next+1;
@@ -365,14 +362,18 @@ static void printEFXInfo(ALCdevice *device)
     }
     else
     {
-        for(i = 0;dedeffects[i][0];i++)
+        for(i = 0;dedeffects[i] != AL_EFFECT_NULL;i++)
         {
             char *next = strchr(current, ',');
+            assert(next != NULL);
             memmove(current, next+1, strlen(next));
         }
     }
     printf("Supported effects:");
     printList(effectNames, ',');
+
+    palDeleteEffects(1, &object);
+    checkALErrors();
 }
 
 int main(int argc, char *argv[])
@@ -380,6 +381,11 @@ int main(int argc, char *argv[])
     ALCdevice *device;
     ALCcontext *context;
 
+#ifdef _WIN32
+    /* OpenAL Soft gives UTF-8 strings, so set the console to expect that. */
+    SetConsoleOutputCP(CP_UTF8);
+#endif
+
     if(argc > 1 && (strcmp(argv[1], "--help") == 0 ||
                     strcmp(argv[1], "-h") == 0))
     {
@@ -425,6 +431,7 @@ int main(int argc, char *argv[])
         return 1;
     }
 
+    printModeInfo(device);
     printALInfo();
     printResamplerInfo();
     printEFXInfo(device);
diff --git a/utils/sofa-info.cpp b/utils/sofa-info.cpp
index bc5b709a..6dffef44 100644
--- a/utils/sofa-info.cpp
+++ b/utils/sofa-info.cpp
@@ -23,45 +23,16 @@
 
 #include <stdio.h>
 
-#include <array>
-#include <cmath>
 #include <memory>
 #include <vector>
 
-#include <mysofa.h>
+#include "sofa-support.h"
 
-#include "win_main_utf8.h"
+#include "mysofa.h"
 
+#include "win_main_utf8.h"
 
 using uint = unsigned int;
-using double3 = std::array<double,3>;
-
-struct MySofaDeleter {
-    void operator()(MYSOFA_HRTF *sofa) { mysofa_free(sofa); }
-};
-using MySofaHrtfPtr = std::unique_ptr<MYSOFA_HRTF,MySofaDeleter>;
-
-// Per-field measurement info.
-struct HrirFdT {
-    double mDistance{0.0};
-    uint mEvCount{0u};
-    uint mEvStart{0u};
-    std::vector<uint> mAzCounts;
-};
-
-static const char *SofaErrorStr(int err)
-{
-    switch(err)
-    {
-    case MYSOFA_OK: return "OK";
-    case MYSOFA_INVALID_FORMAT: return "Invalid format";
-    case MYSOFA_UNSUPPORTED_FORMAT: return "Unsupported format";
-    case MYSOFA_INTERNAL_ERROR: return "Internal error";
-    case MYSOFA_NO_MEMORY: return "Out of memory";
-    case MYSOFA_READ_ERROR: return "Read error";
-    }
-    return "Unknown";
-}
 
 static void PrintSofaAttributes(const char *prefix, struct MYSOFA_ATTRIBUTE *attribute)
 {
@@ -75,121 +46,10 @@ static void PrintSofaAttributes(const char *prefix, struct MYSOFA_ATTRIBUTE *att
 static void PrintSofaArray(const char *prefix, struct MYSOFA_ARRAY *array)
 {
     PrintSofaAttributes(prefix, array->attributes);
-
     for(uint i{0u};i < array->elements;i++)
         fprintf(stdout, "%s[%u]: %.6f\n", prefix, i, array->values[i]);
 }
 
-/* Produces a sorted array of unique elements from a particular axis of the
- * triplets array.  The filters are used to focus on particular coordinates
- * of other axes as necessary.  The epsilons are used to constrain the
- * equality of unique elements.
- */
-static uint GetUniquelySortedElems(const uint m, const double3 *aers, const uint axis,
-    const double *const (&filters)[3], const double (&epsilons)[3], double *elems)
-{
-    uint count{0u};
-    for(uint i{0u};i < m;++i)
-    {
-        const double elem{aers[i][axis]};
-
-        uint j;
-        for(j = 0;j < 3;j++)
-        {
-            if(filters[j] && std::fabs(aers[i][j] - *filters[j]) > epsilons[j])
-                break;
-        }
-        if(j < 3)
-            continue;
-
-        for(j = 0;j < count;j++)
-        {
-            const double delta{elem - elems[j]};
-
-            if(delta > epsilons[axis])
-                continue;
-
-            if(delta >= -epsilons[axis])
-                break;
-
-            for(uint k{count};k > j;k--)
-                elems[k] = elems[k - 1];
-
-            elems[j] = elem;
-            count++;
-            break;
-        }
-
-        if(j >= count)
-            elems[count++] = elem;
-    }
-
-    return count;
-}
-
-/* Given a list of elements, this will produce the smallest step size that
- * can uniformly cover a fair portion of the list.  Ideally this will be over
- * half, but in degenerate cases this can fall to a minimum of 5 (the lower
- * limit on elevations necessary to build a layout).
- */
-static double GetUniformStepSize(const double epsilon, const uint m, const double *elems)
-{
-    auto steps = std::vector<double>(m, 0.0);
-    auto counts = std::vector<uint>(m, 0u);
-    uint count{0u};
-
-    for(uint stride{1u};stride < m/2;stride++)
-    {
-        for(uint i{0u};i < m-stride;i++)
-        {
-            const double step{elems[i + stride] - elems[i]};
-
-            uint j;
-            for(j = 0;j < count;j++)
-            {
-                if(std::fabs(step - steps[j]) < epsilon)
-                {
-                    counts[j]++;
-                    break;
-                }
-            }
-
-            if(j >= count)
-            {
-                steps[j] = step;
-                counts[j] = 1;
-                count++;
-            }
-        }
-
-        for(uint i{1u};i < count;i++)
-        {
-            if(counts[i] > counts[0])
-            {
-                steps[0] = steps[i];
-                counts[0] = counts[i];
-            }
-        }
-
-        count = 1;
-
-        if(counts[0] > m/2)
-            break;
-    }
-
-    if(counts[0] > 255)
-    {
-        uint i{2u};
-        while(counts[0]/i > 255 && (counts[0]%i) != 0)
-            ++i;
-        counts[0] /= i;
-        steps[0] *= i;
-    }
-    if(counts[0] > 5)
-        return steps[0];
-    return 0.0;
-}
-
 /* Attempts to produce a compatible layout.  Most data sets tend to be
  * uniform and have the same major axis as used by OpenAL Soft's HRTF model.
  * This will remove outliers and produce a maximally dense layout when
@@ -198,127 +58,36 @@ static double GetUniformStepSize(const double epsilon, const uint m, const doubl
  */
 static void PrintCompatibleLayout(const uint m, const float *xyzs)
 {
-    auto aers = std::vector<double3>(m, double3{});
-    auto elems = std::vector<double>(m, {});
+    fputc('\n', stdout);
 
-    fprintf(stdout, "\n");
-
-    for(uint i{0u};i < m;++i)
+    auto fds = GetCompatibleLayout(m, xyzs);
+    if(fds.empty())
     {
-        float aer[3]{xyzs[i*3], xyzs[i*3 + 1], xyzs[i*3 + 2]};
-        mysofa_c2s(&aer[0]);
-        aers[i][0] = aer[0];
-        aers[i][1] = aer[1];
-        aers[i][2] = aer[2];
-    }
-
-    uint fdCount{GetUniquelySortedElems(m, aers.data(), 2, { nullptr, nullptr, nullptr },
-        { 0.1, 0.1, 0.001 }, elems.data())};
-    if(fdCount > (m / 3))
-    {
-        fprintf(stdout, "Incompatible layout (inumerable radii).\n");
+        fprintf(stdout, "No compatible field layouts in SOFA file.\n");
         return;
     }
 
-    std::vector<HrirFdT> fds(fdCount);
-    for(uint fi{0u};fi < fdCount;fi++)
-        fds[fi].mDistance = elems[fi];
-
-    for(uint fi{0u};fi < fdCount;fi++)
+    uint used_elems{0};
+    for(size_t fi{0u};fi < fds.size();++fi)
     {
-        const double dist{fds[fi].mDistance};
-        uint evCount{GetUniquelySortedElems(m, aers.data(), 1, { nullptr, nullptr, &dist },
-            { 0.1, 0.1, 0.001 }, elems.data())};
-
-        if(evCount > (m / 3))
-        {
-            fprintf(stdout, "Incompatible layout (innumerable elevations).\n");
-            return;
-        }
-
-        double step{GetUniformStepSize(0.1, evCount, elems.data())};
-        if(step <= 0.0)
-        {
-            fprintf(stdout, "Incompatible layout (non-uniform elevations).\n");
-            return;
-        }
-
-        uint evStart{0u};
-        for(uint ei{0u};ei < evCount;ei++)
-        {
-            double ev{90.0 + elems[ei]};
-            double eif{std::round(ev / step)};
-            const uint ev_start{static_cast<uint>(eif)};
-
-            if(std::fabs(eif - static_cast<double>(ev_start)) < (0.1/step))
-            {
-                evStart = ev_start;
-                break;
-            }
-        }
-
-        evCount = static_cast<uint>(std::round(180.0 / step)) + 1;
-        if(evCount < 5)
-        {
-            fprintf(stdout, "Incompatible layout (too few uniform elevations).\n");
-            return;
-        }
-
-        fds[fi].mEvCount = evCount;
-        fds[fi].mEvStart = evStart;
-        fds[fi].mAzCounts.resize(evCount);
-        auto &azCounts = fds[fi].mAzCounts;
-
-        for(uint ei{evStart};ei < evCount;ei++)
-        {
-            double ev{-90.0 + static_cast<double>(ei)*180.0/static_cast<double>(evCount - 1)};
-            uint azCount{GetUniquelySortedElems(m, aers.data(), 0, { nullptr, &ev, &dist },
-                { 0.1, 0.1, 0.001 }, elems.data())};
-
-            if(azCount > (m / 3))
-            {
-                fprintf(stdout, "Incompatible layout (innumerable azimuths).\n");
-                return;
-            }
-
-            if(ei > 0 && ei < (evCount - 1))
-            {
-                step = GetUniformStepSize(0.1, azCount, elems.data());
-                if(step <= 0.0)
-                {
-                    fprintf(stdout, "Incompatible layout (non-uniform azimuths).\n");
-                    return;
-                }
-
-                azCounts[ei] = static_cast<uint>(std::round(360.0f / step));
-            }
-            else if(azCount != 1)
-            {
-                fprintf(stdout, "Incompatible layout (non-singular poles).\n");
-                return;
-            }
-            else
-            {
-                azCounts[ei] = 1;
-            }
-        }
-
-        for(uint ei{0u};ei < evStart;ei++)
-            azCounts[ei] = azCounts[evCount - ei - 1];
+        for(uint ei{fds[fi].mEvStart};ei < fds[fi].mEvCount;++ei)
+            used_elems += fds[fi].mAzCounts[ei];
     }
 
-    fprintf(stdout, "Compatible Layout:\n\ndistance = %.3f", fds[0].mDistance);
-
-    for(uint fi{1u};fi < fdCount;fi++)
+    fprintf(stdout, "Compatible Layout (%u of %u measurements):\n\ndistance = %.3f", used_elems, m,
+        fds[0].mDistance);
+    for(size_t fi{1u};fi < fds.size();fi++)
         fprintf(stdout, ", %.3f", fds[fi].mDistance);
 
     fprintf(stdout, "\nazimuths = ");
-    for(uint fi{0u};fi < fdCount;fi++)
+    for(size_t fi{0u};fi < fds.size();++fi)
     {
-        for(uint ei{0u};ei < fds[fi].mEvCount;ei++)
+        for(uint ei{0u};ei < fds[fi].mEvStart;++ei)
+            fprintf(stdout, "%d%s", fds[fi].mAzCounts[fds[fi].mEvCount - 1 - ei], ", ");
+        for(uint ei{fds[fi].mEvStart};ei < fds[fi].mEvCount;++ei)
             fprintf(stdout, "%d%s", fds[fi].mAzCounts[ei],
                 (ei < (fds[fi].mEvCount - 1)) ? ", " :
-                (fi < (fdCount - 1)) ? ";\n           " : "\n");
+                (fi < (fds.size() - 1)) ? ";\n           " : "\n");
     }
 }
 
@@ -329,7 +98,8 @@ static void SofaInfo(const char *filename)
     MySofaHrtfPtr sofa{mysofa_load(filename, &err)};
     if(!sofa)
     {
-        fprintf(stdout, "Error: Could not load source file '%s'.\n", filename);
+        fprintf(stdout, "Error: Could not load source file '%s' (%s).\n", filename,
+            SofaErrorStr(err));
         return;
     }
 
@@ -356,8 +126,6 @@ static void SofaInfo(const char *filename)
 
 int main(int argc, char *argv[])
 {
-    GET_UNICODE_ARGS(&argc, &argv);
-
     if(argc != 2)
     {
         fprintf(stdout, "Usage: %s <sofa-file>\n", argv[0]);
diff --git a/utils/sofa-support.cpp b/utils/sofa-support.cpp
new file mode 100644
index 00000000..e37789d5
--- /dev/null
+++ b/utils/sofa-support.cpp
@@ -0,0 +1,292 @@
+/*
+ * SOFA utility methods for inspecting SOFA file metrics and determining HRTF
+ * utility compatible layouts.
+ *
+ * Copyright (C) 2018-2019  Christopher Fitzgerald
+ * Copyright (C) 2019  Christopher Robinson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Or visit:  http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ */
+
+#include "sofa-support.h"
+
+#include <stdio.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <utility>
+#include <vector>
+
+#include "mysofa.h"
+
+
+namespace {
+
+using uint = unsigned int;
+using double3 = std::array<double,3>;
+
+
+/* Produces a sorted array of unique elements from a particular axis of the
+ * triplets array.  The filters are used to focus on particular coordinates
+ * of other axes as necessary.  The epsilons are used to constrain the
+ * equality of unique elements.
+ */
+std::vector<double> GetUniquelySortedElems(const std::vector<double3> &aers, const uint axis,
+    const double *const (&filters)[3], const double (&epsilons)[3])
+{
+    std::vector<double> elems;
+    for(const double3 &aer : aers)
+    {
+        const double elem{aer[axis]};
+
+        uint j;
+        for(j = 0;j < 3;j++)
+        {
+            if(filters[j] && std::abs(aer[j] - *filters[j]) > epsilons[j])
+                break;
+        }
+        if(j < 3)
+            continue;
+
+        auto iter = elems.begin();
+        for(;iter != elems.end();++iter)
+        {
+            const double delta{elem - *iter};
+            if(delta > epsilons[axis]) continue;
+            if(delta >= -epsilons[axis]) break;
+
+            iter = elems.emplace(iter, elem);
+            break;
+        }
+        if(iter == elems.end())
+            elems.emplace_back(elem);
+    }
+    return elems;
+}
+
+/* Given a list of azimuths, this will produce the smallest step size that can
+ * uniformly cover the list. Ideally this will be over half, but in degenerate
+ * cases this can fall to a minimum of 5 (the lower limit).
+ */
+double GetUniformAzimStep(const double epsilon, const std::vector<double> &elems)
+{
+    if(elems.size() < 5) return 0.0;
+
+    /* Get the maximum count possible, given the first two elements. It would
+     * be impossible to have more than this since the first element must be
+     * included.
+     */
+    uint count{static_cast<uint>(std::ceil(360.0 / (elems[1]-elems[0])))};
+    count = std::min(count, 255u);
+
+    for(;count >= 5;--count)
+    {
+        /* Given the stepping value for this number of elements, check each
+         * multiple to ensure there's a matching element.
+         */
+        const double step{360.0 / count};
+        bool good{true};
+        size_t idx{1u};
+        for(uint mult{1u};mult < count && good;++mult)
+        {
+            const double target{step*mult + elems[0]};
+            while(idx < elems.size() && target-elems[idx] > epsilon)
+                ++idx;
+            good &= (idx < elems.size()) && !(std::abs(target-elems[idx++]) > epsilon);
+        }
+        if(good)
+            return step;
+    }
+    return 0.0;
+}
+
+/* Given a list of elevations, this will produce the smallest step size that
+ * can uniformly cover the list. Ideally this will be over half, but in
+ * degenerate cases this can fall to a minimum of 5 (the lower limit).
+ */
+double GetUniformElevStep(const double epsilon, std::vector<double> &elems)
+{
+    if(elems.size() < 5) return 0.0;
+
+    /* Reverse the elevations so it increments starting with -90 (flipped from
+     * +90). This makes it easier to work out a proper stepping value.
+     */
+    std::reverse(elems.begin(), elems.end());
+    for(auto &v : elems) v *= -1.0;
+
+    uint count{static_cast<uint>(std::ceil(180.0 / (elems[1]-elems[0])))};
+    count = std::min(count, 255u);
+
+    double ret{0.0};
+    for(;count >= 5;--count)
+    {
+        const double step{180.0 / count};
+        bool good{true};
+        size_t idx{1u};
+        /* Elevations don't need to match all multiples if there's not enough
+         * elements to check. Missing elevations can be synthesized.
+         */
+        for(uint mult{1u};mult <= count && idx < elems.size() && good;++mult)
+        {
+            const double target{step*mult + elems[0]};
+            while(idx < elems.size() && target-elems[idx] > epsilon)
+                ++idx;
+            good &= !(idx < elems.size()) || !(std::abs(target-elems[idx++]) > epsilon);
+        }
+        if(good)
+        {
+            ret = step;
+            break;
+        }
+    }
+    /* Re-reverse the elevations to restore the correct order. */
+    for(auto &v : elems) v *= -1.0;
+    std::reverse(elems.begin(), elems.end());
+
+    return ret;
+}
+
+} // namespace
+
+
+const char *SofaErrorStr(int err)
+{
+    switch(err)
+    {
+    case MYSOFA_OK: return "OK";
+    case MYSOFA_INVALID_FORMAT: return "Invalid format";
+    case MYSOFA_UNSUPPORTED_FORMAT: return "Unsupported format";
+    case MYSOFA_INTERNAL_ERROR: return "Internal error";
+    case MYSOFA_NO_MEMORY: return "Out of memory";
+    case MYSOFA_READ_ERROR: return "Read error";
+    }
+    return "Unknown";
+}
+
+std::vector<SofaField> GetCompatibleLayout(const size_t m, const float *xyzs)
+{
+    auto aers = std::vector<double3>(m, double3{});
+    for(size_t i{0u};i < m;++i)
+    {
+        float vals[3]{xyzs[i*3], xyzs[i*3 + 1], xyzs[i*3 + 2]};
+        mysofa_c2s(&vals[0]);
+        aers[i] = {vals[0], vals[1], vals[2]};
+    }
+
+    auto radii = GetUniquelySortedElems(aers, 2, {}, {0.1, 0.1, 0.001});
+    std::vector<SofaField> fds;
+    fds.reserve(radii.size());
+
+    for(const double dist : radii)
+    {
+        auto elevs = GetUniquelySortedElems(aers, 1, {nullptr, nullptr, &dist}, {0.1, 0.1, 0.001});
+
+        /* Remove elevations that don't have a valid set of azimuths. */
+        auto invalid_elev = [&dist,&aers](const double ev) -> bool
+        {
+            auto azims = GetUniquelySortedElems(aers, 0, {nullptr, &ev, &dist}, {0.1, 0.1, 0.001});
+
+            if(std::abs(ev) > 89.999)
+                return azims.size() != 1;
+            if(azims.empty() || !(std::abs(azims[0]) < 0.1))
+                return true;
+            return GetUniformAzimStep(0.1, azims) <= 0.0;
+        };
+        elevs.erase(std::remove_if(elevs.begin(), elevs.end(), invalid_elev), elevs.end());
+
+        double step{GetUniformElevStep(0.1, elevs)};
+        if(step <= 0.0)
+        {
+            if(elevs.empty())
+                fprintf(stdout, "No usable elevations on field distance %f.\n", dist);
+            else
+            {
+                fprintf(stdout, "Non-uniform elevations on field distance %.3f.\nGot: %+.2f", dist,
+                    elevs[0]);
+                for(size_t ei{1u};ei < elevs.size();++ei)
+                    fprintf(stdout, ", %+.2f", elevs[ei]);
+                fputc('\n', stdout);
+            }
+            continue;
+        }
+
+        uint evStart{0u};
+        for(uint ei{0u};ei < elevs.size();ei++)
+        {
+            if(!(elevs[ei] < 0.0))
+            {
+                fprintf(stdout, "Too many missing elevations on field distance %f.\n", dist);
+                return fds;
+            }
+
+            double eif{(90.0+elevs[ei]) / step};
+            const double ev_start{std::round(eif)};
+
+            if(std::abs(eif - ev_start) < (0.1/step))
+            {
+                evStart = static_cast<uint>(ev_start);
+                break;
+            }
+        }
+
+        const auto evCount = static_cast<uint>(std::round(180.0 / step)) + 1;
+        if(evCount < 5)
+        {
+            fprintf(stdout, "Too few uniform elevations on field distance %f.\n", dist);
+            continue;
+        }
+
+        SofaField field{};
+        field.mDistance = dist;
+        field.mEvCount = evCount;
+        field.mEvStart = evStart;
+        field.mAzCounts.resize(evCount, 0u);
+        auto &azCounts = field.mAzCounts;
+
+        for(uint ei{evStart};ei < evCount;ei++)
+        {
+            double ev{-90.0 + ei*180.0/(evCount - 1)};
+            auto azims = GetUniquelySortedElems(aers, 0, {nullptr, &ev, &dist}, {0.1, 0.1, 0.001});
+
+            if(ei == 0 || ei == (evCount-1))
+            {
+                if(azims.size() != 1)
+                {
+                    fprintf(stdout, "Non-singular poles on field distance %f.\n", dist);
+                    return fds;
+                }
+                azCounts[ei] = 1;
+            }
+            else
+            {
+                step = GetUniformAzimStep(0.1, azims);
+                if(step <= 0.0)
+                {
+                    fprintf(stdout, "Non-uniform azimuths on elevation %f, field distance %f.\n",
+                        ev, dist);
+                    return fds;
+                }
+                azCounts[ei] = static_cast<uint>(std::round(360.0f / step));
+            }
+        }
+
+        fds.emplace_back(std::move(field));
+    }
+
+    return fds;
+}
diff --git a/utils/sofa-support.h b/utils/sofa-support.h
new file mode 100644
index 00000000..1229f49d
--- /dev/null
+++ b/utils/sofa-support.h
@@ -0,0 +1,30 @@
+#ifndef UTILS_SOFA_SUPPORT_H
+#define UTILS_SOFA_SUPPORT_H
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+#include "mysofa.h"
+
+
+struct MySofaDeleter {
+    void operator()(MYSOFA_HRTF *sofa) { mysofa_free(sofa); }
+};
+using MySofaHrtfPtr = std::unique_ptr<MYSOFA_HRTF,MySofaDeleter>;
+
+// Per-field measurement info.
+struct SofaField {
+    using uint = unsigned int;
+
+    double mDistance{0.0};
+    uint mEvCount{0u};
+    uint mEvStart{0u};
+    std::vector<uint> mAzCounts;
+};
+
+const char *SofaErrorStr(int err);
+
+std::vector<SofaField> GetCompatibleLayout(const size_t m, const float *xyzs);
+
+#endif /* UTILS_SOFA_SUPPORT_H */
diff --git a/utils/uhjdecoder.cpp b/utils/uhjdecoder.cpp
new file mode 100644
index 00000000..6d992e30
--- /dev/null
+++ b/utils/uhjdecoder.cpp
@@ -0,0 +1,538 @@
+/*
+ * 2-channel UHJ Decoder
+ *
+ * Copyright (c) Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <array>
+#include <complex>
+#include <cstring>
+#include <memory>
+#include <stddef.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "albit.h"
+#include "albyte.h"
+#include "alcomplex.h"
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alspan.h"
+#include "vector.h"
+#include "opthelpers.h"
+#include "phase_shifter.h"
+
+#include "sndfile.h"
+
+#include "win_main_utf8.h"
+
+
+struct FileDeleter {
+    void operator()(FILE *file) { fclose(file); }
+};
+using FilePtr = std::unique_ptr<FILE,FileDeleter>;
+
+struct SndFileDeleter {
+    void operator()(SNDFILE *sndfile) { sf_close(sndfile); }
+};
+using SndFilePtr = std::unique_ptr<SNDFILE,SndFileDeleter>;
+
+
+using ubyte = unsigned char;
+using ushort = unsigned short;
+using uint = unsigned int;
+using complex_d = std::complex<double>;
+
+using byte4 = std::array<al::byte,4>;
+
+
+constexpr ubyte SUBTYPE_BFORMAT_FLOAT[]{
+    0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
+    0xca, 0x00, 0x00, 0x00
+};
+
+void fwrite16le(ushort val, FILE *f)
+{
+    ubyte data[2]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff) };
+    fwrite(data, 1, 2, f);
+}
+
+void fwrite32le(uint val, FILE *f)
+{
+    ubyte data[4]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff),
+        static_cast<ubyte>((val>>16)&0xff), static_cast<ubyte>((val>>24)&0xff) };
+    fwrite(data, 1, 4, f);
+}
+
+template<al::endian = al::endian::native>
+byte4 f32AsLEBytes(const float &value) = delete;
+
+template<>
+byte4 f32AsLEBytes<al::endian::little>(const float &value)
+{
+    byte4 ret{};
+    std::memcpy(ret.data(), &value, 4);
+    return ret;
+}
+template<>
+byte4 f32AsLEBytes<al::endian::big>(const float &value)
+{
+    byte4 ret{};
+    std::memcpy(ret.data(), &value, 4);
+    std::swap(ret[0], ret[3]);
+    std::swap(ret[1], ret[2]);
+    return ret;
+}
+
+
+constexpr uint BufferLineSize{1024};
+
+using FloatBufferLine = std::array<float,BufferLineSize>;
+using FloatBufferSpan = al::span<float,BufferLineSize>;
+
+
+struct UhjDecoder {
+    constexpr static size_t sFilterDelay{1024};
+
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mS{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mD{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mT{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mQ{};
+
+    /* History for the FIR filter. */
+    alignas(16) std::array<float,sFilterDelay-1> mDTHistory{};
+    alignas(16) std::array<float,sFilterDelay-1> mSHistory{};
+
+    alignas(16) std::array<float,BufferLineSize + sFilterDelay*2> mTemp{};
+
+    void decode(const float *RESTRICT InSamples, const size_t InChannels,
+        const al::span<FloatBufferLine> OutSamples, const size_t SamplesToDo);
+    void decode2(const float *RESTRICT InSamples, const al::span<FloatBufferLine> OutSamples,
+        const size_t SamplesToDo);
+
+    DEF_NEWDEL(UhjDecoder)
+};
+
+const PhaseShifterT<UhjDecoder::sFilterDelay*2> PShift{};
+
+
+/* Decoding UHJ is done as:
+ *
+ * S = Left + Right
+ * D = Left - Right
+ *
+ * W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T)
+ * X = 0.418496*S - j(0.828331*D + 0.767820*T)
+ * Y = 0.795968*D - 0.676392*T + j(0.186633*S)
+ * Z = 1.023332*Q
+ *
+ * where j is a +90 degree phase shift. 3-channel UHJ excludes Q, while 2-
+ * channel excludes Q and T. The B-Format signal reconstructed from 2-channel
+ * UHJ should not be run through a normal B-Format decoder, as it needs
+ * different shelf filters.
+ *
+ * NOTE: Some sources specify
+ *
+ * S = (Left + Right)/2
+ * D = (Left - Right)/2
+ *
+ * However, this is incorrect. It's halving Left and Right even though they
+ * were already halved during encoding, causing S and D to be half what they
+ * initially were at the encoding stage. This division is not present in
+ * Gerzon's original paper for deriving Sigma (S) or Delta (D) from the L and R
+ * signals. As proof, taking Y for example:
+ *
+ * Y = 0.795968*D - 0.676392*T + j(0.186633*S)
+ *
+ * * Plug in the encoding parameters, using ? as a placeholder for whether S
+ *   and D should receive an extra 0.5 factor
+ * Y = 0.795968*(j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y)*? -
+ *     0.676392*(j(-0.1432*W + 0.6512*X) - 0.7071068*Y) +
+ *     0.186633*j(0.9396926*W + 0.1855740*X)*?
+ *
+ * * Move common factors in
+ * Y = (j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X) + 0.6554516*0.795968*?*Y) -
+ *     (j(-0.1432*0.676392*W + 0.6512*0.676392*X) - 0.7071068*0.676392*Y) +
+ *     j(0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X)
+ *
+ * * Clean up extraneous groupings
+ * Y = j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X) + 0.6554516*0.795968*?*Y -
+ *     j(-0.1432*0.676392*W + 0.6512*0.676392*X) + 0.7071068*0.676392*Y +
+ *     j*(0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X)
+ *
+ * * Move phase shifts together and combine them
+ * Y = j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X - -0.1432*0.676392*W -
+ *        0.6512*0.676392*X + 0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X) +
+ *     0.6554516*0.795968*?*Y + 0.7071068*0.676392*Y
+ *
+ * * Reorder terms
+ * Y = j(-0.3420201*0.795968*?*W +  0.1432*0.676392*W + 0.9396926*0.186633*?*W +
+ *        0.5098604*0.795968*?*X + -0.6512*0.676392*X + 0.1855740*0.186633*?*X) +
+ *     0.7071068*0.676392*Y + 0.6554516*0.795968*?*Y
+ *
+ * * Move common factors out
+ * Y = j((-0.3420201*0.795968*? +  0.1432*0.676392 + 0.9396926*0.186633*?)*W +
+ *       ( 0.5098604*0.795968*? + -0.6512*0.676392 + 0.1855740*0.186633*?)*X) +
+ *     (0.7071068*0.676392 + 0.6554516*0.795968*?)*Y
+ *
+ * * Result w/ 0.5 factor:
+ * -0.3420201*0.795968*0.5 +  0.1432*0.676392 + 0.9396926*0.186633*0.5 =  0.04843*W
+ *  0.5098604*0.795968*0.5 + -0.6512*0.676392 + 0.1855740*0.186633*0.5 = -0.22023*X
+ *  0.7071068*0.676392                        + 0.6554516*0.795968*0.5 =  0.73914*Y
+ * -> Y = j(0.04843*W + -0.22023*X) + 0.73914*Y
+ *
+ * * Result w/o 0.5 factor:
+ * -0.3420201*0.795968 +  0.1432*0.676392 + 0.9396926*0.186633 = 0.00000*W
+ *  0.5098604*0.795968 + -0.6512*0.676392 + 0.1855740*0.186633 = 0.00000*X
+ *  0.7071068*0.676392                    + 0.6554516*0.795968 = 1.00000*Y
+ * -> Y = j(0.00000*W + 0.00000*X) + 1.00000*Y
+ *
+ * Not halving produces a result matching the original input.
+ */
+void UhjDecoder::decode(const float *RESTRICT InSamples, const size_t InChannels,
+    const al::span<FloatBufferLine> OutSamples, const size_t SamplesToDo)
+{
+    ASSUME(SamplesToDo > 0);
+
+    float *woutput{OutSamples[0].data()};
+    float *xoutput{OutSamples[1].data()};
+    float *youtput{OutSamples[2].data()};
+
+    /* Add a delay to the input channels, to align it with the all-passed
+     * signal.
+     */
+
+    /* S = Left + Right */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mS[sFilterDelay+i] = InSamples[i*InChannels + 0] + InSamples[i*InChannels + 1];
+
+    /* D = Left - Right */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mD[sFilterDelay+i] = InSamples[i*InChannels + 0] - InSamples[i*InChannels + 1];
+
+    if(InChannels > 2)
+    {
+        /* T */
+        for(size_t i{0};i < SamplesToDo;++i)
+            mT[sFilterDelay+i] = InSamples[i*InChannels + 2];
+    }
+    if(InChannels > 3)
+    {
+        /* Q */
+        for(size_t i{0};i < SamplesToDo;++i)
+            mQ[sFilterDelay+i] = InSamples[i*InChannels + 3];
+    }
+
+    /* Precompute j(0.828331*D + 0.767820*T) and store in xoutput. */
+    auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
+    std::transform(mD.cbegin(), mD.cbegin()+SamplesToDo+sFilterDelay, mT.cbegin(), tmpiter,
+        [](const float d, const float t) noexcept { return 0.828331f*d + 0.767820f*t; });
+    std::copy_n(mTemp.cbegin()+SamplesToDo, mDTHistory.size(), mDTHistory.begin());
+    PShift.process({xoutput, SamplesToDo}, mTemp.data());
+
+    for(size_t i{0};i < SamplesToDo;++i)
+    {
+        /* W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T) */
+        woutput[i] = 0.981532f*mS[i] + 0.197484f*xoutput[i];
+        /* X = 0.418496*S - j(0.828331*D + 0.767820*T) */
+        xoutput[i] = 0.418496f*mS[i] - xoutput[i];
+    }
+
+    /* Precompute j*S and store in youtput. */
+    tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
+    std::copy_n(mS.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
+    std::copy_n(mTemp.cbegin()+SamplesToDo, mSHistory.size(), mSHistory.begin());
+    PShift.process({youtput, SamplesToDo}, mTemp.data());
+
+    for(size_t i{0};i < SamplesToDo;++i)
+    {
+        /* Y = 0.795968*D - 0.676392*T + j(0.186633*S) */
+        youtput[i] = 0.795968f*mD[i] - 0.676392f*mT[i] + 0.186633f*youtput[i];
+    }
+
+    if(OutSamples.size() > 3)
+    {
+        float *zoutput{OutSamples[3].data()};
+        /* Z = 1.023332*Q */
+        for(size_t i{0};i < SamplesToDo;++i)
+            zoutput[i] = 1.023332f*mQ[i];
+    }
+
+    std::copy(mS.begin()+SamplesToDo, mS.begin()+SamplesToDo+sFilterDelay, mS.begin());
+    std::copy(mD.begin()+SamplesToDo, mD.begin()+SamplesToDo+sFilterDelay, mD.begin());
+    std::copy(mT.begin()+SamplesToDo, mT.begin()+SamplesToDo+sFilterDelay, mT.begin());
+    std::copy(mQ.begin()+SamplesToDo, mQ.begin()+SamplesToDo+sFilterDelay, mQ.begin());
+}
+
+/* This is an alternative equation for decoding 2-channel UHJ. Not sure what
+ * the intended benefit is over the above equation as this slightly reduces the
+ * amount of the original left response and has more of the phase-shifted
+ * forward response on the left response.
+ *
+ * This decoding is done as:
+ *
+ * S = Left + Right
+ * D = Left - Right
+ *
+ * W = 0.981530*S + j*0.163585*D
+ * X = 0.418504*S - j*0.828347*D
+ * Y = 0.762956*D + j*0.384230*S
+ *
+ * where j is a +90 degree phase shift.
+ *
+ * NOTE: As above, S and D should not be halved. The only consequence of
+ * halving here is merely a -6dB reduction in output, but it's still incorrect.
+ */
+void UhjDecoder::decode2(const float *RESTRICT InSamples,
+    const al::span<FloatBufferLine> OutSamples, const size_t SamplesToDo)
+{
+    ASSUME(SamplesToDo > 0);
+
+    float *woutput{OutSamples[0].data()};
+    float *xoutput{OutSamples[1].data()};
+    float *youtput{OutSamples[2].data()};
+
+    /* S = Left + Right */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mS[sFilterDelay+i] = InSamples[i*2 + 0] + InSamples[i*2 + 1];
+
+    /* D = Left - Right */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mD[sFilterDelay+i] = InSamples[i*2 + 0] - InSamples[i*2 + 1];
+
+    /* Precompute j*D and store in xoutput. */
+    auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
+    std::copy_n(mD.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
+    std::copy_n(mTemp.cbegin()+SamplesToDo, mDTHistory.size(), mDTHistory.begin());
+    PShift.process({xoutput, SamplesToDo}, mTemp.data());
+
+    for(size_t i{0};i < SamplesToDo;++i)
+    {
+        /* W = 0.981530*S + j*0.163585*D */
+        woutput[i] = 0.981530f*mS[i] + 0.163585f*xoutput[i];
+        /* X = 0.418504*S - j*0.828347*D */
+        xoutput[i] = 0.418504f*mS[i] - 0.828347f*xoutput[i];
+    }
+
+    /* Precompute j*S and store in youtput. */
+    tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
+    std::copy_n(mS.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
+    std::copy_n(mTemp.cbegin()+SamplesToDo, mSHistory.size(), mSHistory.begin());
+    PShift.process({youtput, SamplesToDo}, mTemp.data());
+
+    for(size_t i{0};i < SamplesToDo;++i)
+    {
+        /* Y = 0.762956*D + j*0.384230*S */
+        youtput[i] = 0.762956f*mD[i] + 0.384230f*youtput[i];
+    }
+
+    std::copy(mS.begin()+SamplesToDo, mS.begin()+SamplesToDo+sFilterDelay, mS.begin());
+    std::copy(mD.begin()+SamplesToDo, mD.begin()+SamplesToDo+sFilterDelay, mD.begin());
+}
+
+
+int main(int argc, char **argv)
+{
+    if(argc < 2 || std::strcmp(argv[1], "-h") == 0 || std::strcmp(argv[1], "--help") == 0)
+    {
+        printf("Usage: %s <[options] filename.wav...>\n\n"
+            "  Options:\n"
+            "    --general      Use the general equations for 2-channel UHJ (default).\n"
+            "    --alternative  Use the alternative equations for 2-channel UHJ.\n"
+            "\n"
+            "Note: When decoding 2-channel UHJ to an .amb file, the result should not use\n"
+            "the normal B-Format shelf filters! Only 3- and 4-channel UHJ can accurately\n"
+            "reconstruct the original B-Format signal.",
+            argv[0]);
+        return 1;
+    }
+
+    size_t num_files{0}, num_decoded{0};
+    bool use_general{true};
+    for(int fidx{1};fidx < argc;++fidx)
+    {
+        if(std::strcmp(argv[fidx], "--general") == 0)
+        {
+            use_general = true;
+            continue;
+        }
+        if(std::strcmp(argv[fidx], "--alternative") == 0)
+        {
+            use_general = false;
+            continue;
+        }
+        ++num_files;
+        SF_INFO ininfo{};
+        SndFilePtr infile{sf_open(argv[fidx], SFM_READ, &ininfo)};
+        if(!infile)
+        {
+            fprintf(stderr, "Failed to open %s\n", argv[fidx]);
+            continue;
+        }
+        if(sf_command(infile.get(), SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+        {
+            fprintf(stderr, "%s is already B-Format\n", argv[fidx]);
+            continue;
+        }
+        uint outchans{};
+        if(ininfo.channels == 2)
+            outchans = 3;
+        else if(ininfo.channels == 3 || ininfo.channels == 4)
+            outchans = static_cast<uint>(ininfo.channels);
+        else
+        {
+            fprintf(stderr, "%s is not a 2-, 3-, or 4-channel file\n", argv[fidx]);
+            continue;
+        }
+        printf("Converting %s from %d-channel UHJ%s...\n", argv[fidx], ininfo.channels,
+            (ininfo.channels == 2) ? use_general ? " (general)" : " (alternative)" : "");
+
+        std::string outname{argv[fidx]};
+        auto lastslash = outname.find_last_of('/');
+        if(lastslash != std::string::npos)
+            outname.erase(0, lastslash+1);
+        auto lastdot = outname.find_last_of('.');
+        if(lastdot != std::string::npos)
+            outname.resize(lastdot+1);
+        outname += "amb";
+
+        FilePtr outfile{fopen(outname.c_str(), "wb")};
+        if(!outfile)
+        {
+            fprintf(stderr, "Failed to create %s\n", outname.c_str());
+            continue;
+        }
+
+        fputs("RIFF", outfile.get());
+        fwrite32le(0xFFFFFFFF, outfile.get()); // 'RIFF' header len; filled in at close
+
+        fputs("WAVE", outfile.get());
+
+        fputs("fmt ", outfile.get());
+        fwrite32le(40, outfile.get()); // 'fmt ' header len; 40 bytes for EXTENSIBLE
+
+        // 16-bit val, format type id (extensible: 0xFFFE)
+        fwrite16le(0xFFFE, outfile.get());
+        // 16-bit val, channel count
+        fwrite16le(static_cast<ushort>(outchans), outfile.get());
+        // 32-bit val, frequency
+        fwrite32le(static_cast<uint>(ininfo.samplerate), outfile.get());
+        // 32-bit val, bytes per second
+        fwrite32le(static_cast<uint>(ininfo.samplerate)*sizeof(float)*outchans, outfile.get());
+        // 16-bit val, frame size
+        fwrite16le(static_cast<ushort>(sizeof(float)*outchans), outfile.get());
+        // 16-bit val, bits per sample
+        fwrite16le(static_cast<ushort>(sizeof(float)*8), outfile.get());
+        // 16-bit val, extra byte count
+        fwrite16le(22, outfile.get());
+        // 16-bit val, valid bits per sample
+        fwrite16le(static_cast<ushort>(sizeof(float)*8), outfile.get());
+        // 32-bit val, channel mask
+        fwrite32le(0, outfile.get());
+        // 16 byte GUID, sub-type format
+        fwrite(SUBTYPE_BFORMAT_FLOAT, 1, 16, outfile.get());
+
+        fputs("data", outfile.get());
+        fwrite32le(0xFFFFFFFF, outfile.get()); // 'data' header len; filled in at close
+        if(ferror(outfile.get()))
+        {
+            fprintf(stderr, "Error writing wave file header: %s (%d)\n", strerror(errno), errno);
+            continue;
+        }
+
+        auto DataStart = ftell(outfile.get());
+
+        auto decoder = std::make_unique<UhjDecoder>();
+        auto inmem = std::make_unique<float[]>(BufferLineSize*static_cast<uint>(ininfo.channels));
+        auto decmem = al::vector<std::array<float,BufferLineSize>, 16>(outchans);
+        auto outmem = std::make_unique<byte4[]>(BufferLineSize*outchans);
+
+        /* A number of initial samples need to be skipped to cut the lead-in
+         * from the all-pass filter delay. The same number of samples need to
+         * be fed through the decoder after reaching the end of the input file
+         * to ensure none of the original input is lost.
+         */
+        size_t LeadIn{UhjDecoder::sFilterDelay};
+        sf_count_t LeadOut{UhjDecoder::sFilterDelay};
+        while(LeadOut > 0)
+        {
+            sf_count_t sgot{sf_readf_float(infile.get(), inmem.get(), BufferLineSize)};
+            sgot = std::max<sf_count_t>(sgot, 0);
+            if(sgot < BufferLineSize)
+            {
+                const sf_count_t remaining{std::min(BufferLineSize - sgot, LeadOut)};
+                std::fill_n(inmem.get() + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
+                sgot += remaining;
+                LeadOut -= remaining;
+            }
+
+            auto got = static_cast<size_t>(sgot);
+            if(ininfo.channels > 2 || use_general)
+                decoder->decode(inmem.get(), static_cast<uint>(ininfo.channels), decmem, got);
+            else
+                decoder->decode2(inmem.get(), decmem, got);
+            if(LeadIn >= got)
+            {
+                LeadIn -= got;
+                continue;
+            }
+
+            got -= LeadIn;
+            for(size_t i{0};i < got;++i)
+            {
+                /* Attenuate by -3dB for FuMa output levels. */
+                constexpr auto inv_sqrt2 = static_cast<float>(1.0/al::numbers::sqrt2);
+                for(size_t j{0};j < outchans;++j)
+                    outmem[i*outchans + j] = f32AsLEBytes(decmem[j][LeadIn+i] * inv_sqrt2);
+            }
+            LeadIn = 0;
+
+            size_t wrote{fwrite(outmem.get(), sizeof(byte4)*outchans, got, outfile.get())};
+            if(wrote < got)
+            {
+                fprintf(stderr, "Error writing wave data: %s (%d)\n", strerror(errno), errno);
+                break;
+            }
+        }
+
+        auto DataEnd = ftell(outfile.get());
+        if(DataEnd > DataStart)
+        {
+            long dataLen{DataEnd - DataStart};
+            if(fseek(outfile.get(), 4, SEEK_SET) == 0)
+                fwrite32le(static_cast<uint>(DataEnd-8), outfile.get()); // 'WAVE' header len
+            if(fseek(outfile.get(), DataStart-4, SEEK_SET) == 0)
+                fwrite32le(static_cast<uint>(dataLen), outfile.get()); // 'data' header len
+        }
+        fflush(outfile.get());
+        ++num_decoded;
+    }
+    if(num_decoded == 0)
+        fprintf(stderr, "Failed to decode any input files\n");
+    else if(num_decoded < num_files)
+        fprintf(stderr, "Decoded %zu of %zu files\n", num_decoded, num_files);
+    else
+        printf("Decoded %zu file%s\n", num_decoded, (num_decoded==1)?"":"s");
+    return 0;
+}
diff --git a/utils/uhjencoder.cpp b/utils/uhjencoder.cpp
new file mode 100644
index 00000000..34698993
--- /dev/null
+++ b/utils/uhjencoder.cpp
@@ -0,0 +1,531 @@
+/*
+ * 2-channel UHJ Encoder
+ *
+ * Copyright (c) Chris Robinson <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <array>
+#include <cstring>
+#include <inttypes.h>
+#include <memory>
+#include <stddef.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "almalloc.h"
+#include "alnumbers.h"
+#include "alspan.h"
+#include "opthelpers.h"
+#include "phase_shifter.h"
+#include "vector.h"
+
+#include "sndfile.h"
+
+#include "win_main_utf8.h"
+
+
+namespace {
+
+struct SndFileDeleter {
+    void operator()(SNDFILE *sndfile) { sf_close(sndfile); }
+};
+using SndFilePtr = std::unique_ptr<SNDFILE,SndFileDeleter>;
+
+
+using uint = unsigned int;
+
+constexpr uint BufferLineSize{1024};
+
+using FloatBufferLine = std::array<float,BufferLineSize>;
+using FloatBufferSpan = al::span<float,BufferLineSize>;
+
+
+struct UhjEncoder {
+    constexpr static size_t sFilterDelay{1024};
+
+    /* Delays and processing storage for the unfiltered signal. */
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mW{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mX{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mY{};
+    alignas(16) std::array<float,BufferLineSize+sFilterDelay> mZ{};
+
+    alignas(16) std::array<float,BufferLineSize> mS{};
+    alignas(16) std::array<float,BufferLineSize> mD{};
+    alignas(16) std::array<float,BufferLineSize> mT{};
+
+    /* History for the FIR filter. */
+    alignas(16) std::array<float,sFilterDelay*2 - 1> mWXHistory1{};
+    alignas(16) std::array<float,sFilterDelay*2 - 1> mWXHistory2{};
+
+    alignas(16) std::array<float,BufferLineSize + sFilterDelay*2> mTemp{};
+
+    void encode(const al::span<FloatBufferLine> OutSamples,
+        const al::span<FloatBufferLine,4> InSamples, const size_t SamplesToDo);
+
+    DEF_NEWDEL(UhjEncoder)
+};
+
+const PhaseShifterT<UhjEncoder::sFilterDelay*2> PShift{};
+
+
+/* Encoding UHJ from B-Format is done as:
+ *
+ * S = 0.9396926*W + 0.1855740*X
+ * D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y
+ *
+ * Left = (S + D)/2.0
+ * Right = (S - D)/2.0
+ * T = j(-0.1432*W + 0.6512*X) - 0.7071068*Y
+ * Q = 0.9772*Z
+ *
+ * where j is a wide-band +90 degree phase shift. T is excluded from 2-channel
+ * output, and Q is excluded from 2- and 3-channel output.
+ */
+void UhjEncoder::encode(const al::span<FloatBufferLine> OutSamples,
+    const al::span<FloatBufferLine,4> InSamples, const size_t SamplesToDo)
+{
+    const float *RESTRICT winput{al::assume_aligned<16>(InSamples[0].data())};
+    const float *RESTRICT xinput{al::assume_aligned<16>(InSamples[1].data())};
+    const float *RESTRICT yinput{al::assume_aligned<16>(InSamples[2].data())};
+    const float *RESTRICT zinput{al::assume_aligned<16>(InSamples[3].data())};
+
+    /* Combine the previously delayed input signal with the new input. */
+    std::copy_n(winput, SamplesToDo, mW.begin()+sFilterDelay);
+    std::copy_n(xinput, SamplesToDo, mX.begin()+sFilterDelay);
+    std::copy_n(yinput, SamplesToDo, mY.begin()+sFilterDelay);
+    std::copy_n(zinput, SamplesToDo, mZ.begin()+sFilterDelay);
+
+    /* S = 0.9396926*W + 0.1855740*X */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mS[i] = 0.9396926f*mW[i] + 0.1855740f*mX[i];
+
+    /* Precompute j(-0.3420201*W + 0.5098604*X) and store in mD. */
+    auto tmpiter = std::copy(mWXHistory1.cbegin(), mWXHistory1.cend(), mTemp.begin());
+    std::transform(winput, winput+SamplesToDo, xinput, tmpiter,
+        [](const float w, const float x) noexcept -> float
+        { return -0.3420201f*w + 0.5098604f*x; });
+    std::copy_n(mTemp.cbegin()+SamplesToDo, mWXHistory1.size(), mWXHistory1.begin());
+    PShift.process({mD.data(), SamplesToDo}, mTemp.data());
+
+    /* D = j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y */
+    for(size_t i{0};i < SamplesToDo;++i)
+        mD[i] = mD[i] + 0.6554516f*mY[i];
+
+    /* Left = (S + D)/2.0 */
+    float *RESTRICT left{al::assume_aligned<16>(OutSamples[0].data())};
+    for(size_t i{0};i < SamplesToDo;i++)
+        left[i] = (mS[i] + mD[i]) * 0.5f;
+    /* Right = (S - D)/2.0 */
+    float *RESTRICT right{al::assume_aligned<16>(OutSamples[1].data())};
+    for(size_t i{0};i < SamplesToDo;i++)
+        right[i] = (mS[i] - mD[i]) * 0.5f;
+
+    if(OutSamples.size() > 2)
+    {
+        /* Precompute j(-0.1432*W + 0.6512*X) and store in mT. */
+        tmpiter = std::copy(mWXHistory2.cbegin(), mWXHistory2.cend(), mTemp.begin());
+        std::transform(winput, winput+SamplesToDo, xinput, tmpiter,
+            [](const float w, const float x) noexcept -> float
+            { return -0.1432f*w + 0.6512f*x; });
+        std::copy_n(mTemp.cbegin()+SamplesToDo, mWXHistory2.size(), mWXHistory2.begin());
+        PShift.process({mT.data(), SamplesToDo}, mTemp.data());
+
+        /* T = j(-0.1432*W + 0.6512*X) - 0.7071068*Y */
+        float *RESTRICT t{al::assume_aligned<16>(OutSamples[2].data())};
+        for(size_t i{0};i < SamplesToDo;i++)
+            t[i] = mT[i] - 0.7071068f*mY[i];
+    }
+    if(OutSamples.size() > 3)
+    {
+        /* Q = 0.9772*Z */
+        float *RESTRICT q{al::assume_aligned<16>(OutSamples[3].data())};
+        for(size_t i{0};i < SamplesToDo;i++)
+            q[i] = 0.9772f*mZ[i];
+    }
+
+    /* Copy the future samples to the front for next time. */
+    std::copy(mW.cbegin()+SamplesToDo, mW.cbegin()+SamplesToDo+sFilterDelay, mW.begin());
+    std::copy(mX.cbegin()+SamplesToDo, mX.cbegin()+SamplesToDo+sFilterDelay, mX.begin());
+    std::copy(mY.cbegin()+SamplesToDo, mY.cbegin()+SamplesToDo+sFilterDelay, mY.begin());
+    std::copy(mZ.cbegin()+SamplesToDo, mZ.cbegin()+SamplesToDo+sFilterDelay, mZ.begin());
+}
+
+
+struct SpeakerPos {
+    int mChannelID;
+    float mAzimuth;
+    float mElevation;
+};
+
+/* Azimuth is counter-clockwise. */
+constexpr SpeakerPos StereoMap[2]{
+    { SF_CHANNEL_MAP_LEFT,   30.0f, 0.0f },
+    { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
+}, QuadMap[4]{
+    { SF_CHANNEL_MAP_LEFT,         45.0f, 0.0f },
+    { SF_CHANNEL_MAP_RIGHT,       -45.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_LEFT,   135.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_RIGHT, -135.0f, 0.0f },
+}, X51Map[6]{
+    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
+    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
+    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
+    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
+    { SF_CHANNEL_MAP_SIDE_LEFT,   110.0f, 0.0f },
+    { SF_CHANNEL_MAP_SIDE_RIGHT, -110.0f, 0.0f },
+}, X51RearMap[6]{
+    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
+    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
+    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
+    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_LEFT,   110.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_RIGHT, -110.0f, 0.0f },
+}, X71Map[8]{
+    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
+    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
+    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
+    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_LEFT,   150.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f, 0.0f },
+    { SF_CHANNEL_MAP_SIDE_LEFT,    90.0f, 0.0f },
+    { SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f, 0.0f },
+}, X714Map[12]{
+    { SF_CHANNEL_MAP_LEFT,         30.0f,  0.0f },
+    { SF_CHANNEL_MAP_RIGHT,       -30.0f,  0.0f },
+    { SF_CHANNEL_MAP_CENTER,        0.0f,  0.0f },
+    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
+    { SF_CHANNEL_MAP_REAR_LEFT,   150.0f,  0.0f },
+    { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f,  0.0f },
+    { SF_CHANNEL_MAP_SIDE_LEFT,    90.0f,  0.0f },
+    { SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f,  0.0f },
+    { SF_CHANNEL_MAP_TOP_FRONT_LEFT,    45.0f, 35.0f },
+    { SF_CHANNEL_MAP_TOP_FRONT_RIGHT,  -45.0f, 35.0f },
+    { SF_CHANNEL_MAP_TOP_REAR_LEFT,    135.0f, 35.0f },
+    { SF_CHANNEL_MAP_TOP_REAR_RIGHT,  -135.0f, 35.0f },
+};
+
+constexpr auto GenCoeffs(double x /*+front*/, double y /*+left*/, double z /*+up*/) noexcept
+{
+    /* Coefficients are +3dB of FuMa. */
+    return std::array<float,4>{{
+        1.0f,
+        static_cast<float>(al::numbers::sqrt2 * x),
+        static_cast<float>(al::numbers::sqrt2 * y),
+        static_cast<float>(al::numbers::sqrt2 * z)
+    }};
+}
+
+} // namespace
+
+
+int main(int argc, char **argv)
+{
+    if(argc < 2 || std::strcmp(argv[1], "-h") == 0 || std::strcmp(argv[1], "--help") == 0)
+    {
+        printf("Usage: %s <infile...>\n\n", argv[0]);
+        return 1;
+    }
+
+    uint uhjchans{2};
+    size_t num_files{0}, num_encoded{0};
+    for(int fidx{1};fidx < argc;++fidx)
+    {
+        if(strcmp(argv[fidx], "-bhj") == 0)
+        {
+            uhjchans = 2;
+            continue;
+        }
+        if(strcmp(argv[fidx], "-thj") == 0)
+        {
+            uhjchans = 3;
+            continue;
+        }
+        if(strcmp(argv[fidx], "-phj") == 0)
+        {
+            uhjchans = 4;
+            continue;
+        }
+        ++num_files;
+
+        std::string outname{argv[fidx]};
+        size_t lastslash{outname.find_last_of('/')};
+        if(lastslash != std::string::npos)
+            outname.erase(0, lastslash+1);
+        size_t extpos{outname.find_last_of('.')};
+        if(extpos != std::string::npos)
+            outname.resize(extpos);
+        outname += ".uhj.flac";
+
+        SF_INFO ininfo{};
+        SndFilePtr infile{sf_open(argv[fidx], SFM_READ, &ininfo)};
+        if(!infile)
+        {
+            fprintf(stderr, "Failed to open %s\n", argv[fidx]);
+            continue;
+        }
+        printf("Converting %s to %s...\n", argv[fidx], outname.c_str());
+
+        /* Work out the channel map, preferably using the actual channel map
+         * from the file/format, but falling back to assuming WFX order.
+         */
+        al::span<const SpeakerPos> spkrs;
+        auto chanmap = std::vector<int>(static_cast<uint>(ininfo.channels), SF_CHANNEL_MAP_INVALID);
+        if(sf_command(infile.get(), SFC_GET_CHANNEL_MAP_INFO, chanmap.data(),
+            ininfo.channels*int{sizeof(int)}) == SF_TRUE)
+        {
+            static const std::array<int,2> stereomap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT}};
+            static const std::array<int,4> quadmap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
+                SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT}};
+            static const std::array<int,6> x51map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
+                SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
+                SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT}};
+            static const std::array<int,6> x51rearmap{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
+                SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
+                SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT}};
+            static const std::array<int,8> x71map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
+                SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
+                SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT,
+                SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT}};
+            static const std::array<int,12> x714map{{SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT,
+                SF_CHANNEL_MAP_CENTER, SF_CHANNEL_MAP_LFE,
+                SF_CHANNEL_MAP_REAR_LEFT, SF_CHANNEL_MAP_REAR_RIGHT,
+                SF_CHANNEL_MAP_SIDE_LEFT, SF_CHANNEL_MAP_SIDE_RIGHT,
+                SF_CHANNEL_MAP_TOP_FRONT_LEFT, SF_CHANNEL_MAP_TOP_FRONT_RIGHT,
+                SF_CHANNEL_MAP_TOP_REAR_LEFT, SF_CHANNEL_MAP_TOP_REAR_RIGHT}};
+            static const std::array<int,3> ambi2dmap{{SF_CHANNEL_MAP_AMBISONIC_B_W,
+                SF_CHANNEL_MAP_AMBISONIC_B_X, SF_CHANNEL_MAP_AMBISONIC_B_Y}};
+            static const std::array<int,4> ambi3dmap{{SF_CHANNEL_MAP_AMBISONIC_B_W,
+                SF_CHANNEL_MAP_AMBISONIC_B_X, SF_CHANNEL_MAP_AMBISONIC_B_Y,
+                SF_CHANNEL_MAP_AMBISONIC_B_Z}};
+
+            auto match_chanmap = [](const al::span<int> a, const al::span<const int> b) -> bool
+            {
+                if(a.size() != b.size())
+                    return false;
+                for(const int id : a)
+                {
+                    if(std::find(b.begin(), b.end(), id) != b.end())
+                        return false;
+                }
+                return true;
+            };
+            if(match_chanmap(chanmap, stereomap))
+                spkrs = StereoMap;
+            else if(match_chanmap(chanmap, quadmap))
+                spkrs = QuadMap;
+            else if(match_chanmap(chanmap, x51map))
+                spkrs = X51Map;
+            else if(match_chanmap(chanmap, x51rearmap))
+                spkrs = X51RearMap;
+            else if(match_chanmap(chanmap, x71map))
+                spkrs = X71Map;
+            else if(match_chanmap(chanmap, x714map))
+                spkrs = X714Map;
+            else if(match_chanmap(chanmap, ambi2dmap) || match_chanmap(chanmap, ambi3dmap))
+            {
+                /* Do nothing. */
+            }
+            else
+            {
+                std::string mapstr;
+                if(!chanmap.empty())
+                {
+                    mapstr = std::to_string(chanmap[0]);
+                    for(int idx : al::span<int>{chanmap}.subspan<1>())
+                    {
+                        mapstr += ',';
+                        mapstr += std::to_string(idx);
+                    }
+                }
+                fprintf(stderr, " ... %zu channels not supported (map: %s)\n", chanmap.size(),
+                    mapstr.c_str());
+                continue;
+            }
+        }
+        else if(ininfo.channels == 2)
+        {
+            fprintf(stderr, " ... assuming WFX order stereo\n");
+            spkrs = StereoMap;
+            chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
+            chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
+        }
+        else if(ininfo.channels == 6)
+        {
+            fprintf(stderr, " ... assuming WFX order 5.1\n");
+            spkrs = X51Map;
+            chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
+            chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
+            chanmap[2] = SF_CHANNEL_MAP_FRONT_CENTER;
+            chanmap[3] = SF_CHANNEL_MAP_LFE;
+            chanmap[4] = SF_CHANNEL_MAP_SIDE_LEFT;
+            chanmap[5] = SF_CHANNEL_MAP_SIDE_RIGHT;
+        }
+        else if(ininfo.channels == 8)
+        {
+            fprintf(stderr, " ... assuming WFX order 7.1\n");
+            spkrs = X71Map;
+            chanmap[0] = SF_CHANNEL_MAP_FRONT_LEFT;
+            chanmap[1] = SF_CHANNEL_MAP_FRONT_RIGHT;
+            chanmap[2] = SF_CHANNEL_MAP_FRONT_CENTER;
+            chanmap[3] = SF_CHANNEL_MAP_LFE;
+            chanmap[4] = SF_CHANNEL_MAP_REAR_LEFT;
+            chanmap[5] = SF_CHANNEL_MAP_REAR_RIGHT;
+            chanmap[6] = SF_CHANNEL_MAP_SIDE_LEFT;
+            chanmap[7] = SF_CHANNEL_MAP_SIDE_RIGHT;
+        }
+        else
+        {
+            fprintf(stderr, " ... unmapped %d-channel audio not supported\n", ininfo.channels);
+            continue;
+        }
+
+        SF_INFO outinfo{};
+        outinfo.frames = ininfo.frames;
+        outinfo.samplerate = ininfo.samplerate;
+        outinfo.channels = static_cast<int>(uhjchans);
+        outinfo.format = SF_FORMAT_PCM_24 | SF_FORMAT_FLAC;
+        SndFilePtr outfile{sf_open(outname.c_str(), SFM_WRITE, &outinfo)};
+        if(!outfile)
+        {
+            fprintf(stderr, " ... failed to create %s\n", outname.c_str());
+            continue;
+        }
+
+        auto encoder = std::make_unique<UhjEncoder>();
+        auto splbuf = al::vector<FloatBufferLine, 16>(static_cast<uint>(9+ininfo.channels)+uhjchans);
+        auto ambmem = al::span<FloatBufferLine,4>{splbuf.data(), 4};
+        auto encmem = al::span<FloatBufferLine,4>{&splbuf[4], 4};
+        auto srcmem = al::span<float,BufferLineSize>{splbuf[8].data(), BufferLineSize};
+        auto outmem = al::span<float>{splbuf[9].data(), BufferLineSize*uhjchans};
+
+        /* A number of initial samples need to be skipped to cut the lead-in
+         * from the all-pass filter delay. The same number of samples need to
+         * be fed through the encoder after reaching the end of the input file
+         * to ensure none of the original input is lost.
+         */
+        size_t total_wrote{0};
+        size_t LeadIn{UhjEncoder::sFilterDelay};
+        sf_count_t LeadOut{UhjEncoder::sFilterDelay};
+        while(LeadIn > 0 || LeadOut > 0)
+        {
+            auto inmem = outmem.data() + outmem.size();
+            auto sgot = sf_readf_float(infile.get(), inmem, BufferLineSize);
+
+            sgot = std::max<sf_count_t>(sgot, 0);
+            if(sgot < BufferLineSize)
+            {
+                const sf_count_t remaining{std::min(BufferLineSize - sgot, LeadOut)};
+                std::fill_n(inmem + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
+                sgot += remaining;
+                LeadOut -= remaining;
+            }
+
+            for(auto&& buf : ambmem)
+                buf.fill(0.0f);
+
+            auto got = static_cast<size_t>(sgot);
+            if(spkrs.empty())
+            {
+                /* B-Format is already in the correct order. It just needs a
+                 * +3dB boost.
+                 */
+                static constexpr float scale{al::numbers::sqrt2_v<float>};
+                const size_t chans{std::min<size_t>(static_cast<uint>(ininfo.channels), 4u)};
+                for(size_t c{0};c < chans;++c)
+                {
+                    for(size_t i{0};i < got;++i)
+                        ambmem[c][i] = inmem[i*static_cast<uint>(ininfo.channels)] * scale;
+                    ++inmem;
+                }
+            }
+            else for(const int chanid : chanmap)
+            {
+                /* Skip LFE. Or mix directly into W? Or W+X? */
+                if(chanid == SF_CHANNEL_MAP_LFE)
+                {
+                    ++inmem;
+                    continue;
+                }
+
+                const auto spkr = std::find_if(spkrs.cbegin(), spkrs.cend(),
+                    [chanid](const SpeakerPos &pos){return pos.mChannelID == chanid;});
+                if(spkr == spkrs.cend())
+                {
+                    fprintf(stderr, " ... failed to find channel ID %d\n", chanid);
+                    continue;
+                }
+
+                for(size_t i{0};i < got;++i)
+                    srcmem[i] = inmem[i * static_cast<uint>(ininfo.channels)];
+                ++inmem;
+
+                static constexpr auto Deg2Rad = al::numbers::pi / 180.0;
+                const auto coeffs = GenCoeffs(
+                    std::cos(spkr->mAzimuth*Deg2Rad) * std::cos(spkr->mElevation*Deg2Rad),
+                    std::sin(spkr->mAzimuth*Deg2Rad) * std::cos(spkr->mElevation*Deg2Rad),
+                    std::sin(spkr->mElevation*Deg2Rad));
+                for(size_t c{0};c < 4;++c)
+                {
+                    for(size_t i{0};i < got;++i)
+                        ambmem[c][i] += srcmem[i] * coeffs[c];
+                }
+            }
+
+            encoder->encode(encmem.subspan(0, uhjchans), ambmem, got);
+            if(LeadIn >= got)
+            {
+                LeadIn -= got;
+                continue;
+            }
+
+            got -= LeadIn;
+            for(size_t c{0};c < uhjchans;++c)
+            {
+                constexpr float max_val{8388607.0f / 8388608.0f};
+                auto clamp = [](float v, float mn, float mx) noexcept
+                { return std::min(std::max(v, mn), mx); };
+                for(size_t i{0};i < got;++i)
+                    outmem[i*uhjchans + c] = clamp(encmem[c][LeadIn+i], -1.0f, max_val);
+            }
+            LeadIn = 0;
+
+            sf_count_t wrote{sf_writef_float(outfile.get(), outmem.data(),
+                static_cast<sf_count_t>(got))};
+            if(wrote < 0)
+                fprintf(stderr, " ... failed to write samples: %d\n", sf_error(outfile.get()));
+            else
+                total_wrote += static_cast<size_t>(wrote);
+        }
+        printf(" ... wrote %zu samples (%" PRId64 ").\n", total_wrote, int64_t{ininfo.frames});
+        ++num_encoded;
+    }
+    if(num_encoded == 0)
+        fprintf(stderr, "Failed to encode any input files\n");
+    else if(num_encoded < num_files)
+        fprintf(stderr, "Encoded %zu of %zu files\n", num_encoded, num_files);
+    else
+        printf("Encoded %s%zu file%s\n", (num_encoded > 1) ? "all " : "", num_encoded,
+            (num_encoded == 1) ? "" : "s");
+    return 0;
+}