Rename alMain.h to alcmain.h

And move it and alu.h to Alc/.

52 files changed, 1053 insertions, 53 deletions

diff --git a/Alc/alc.cpp b/Alc/alc.cpp
index 0bc099b4..00f90d91 100644
--- a/Alc/alc.cpp
+++ b/Alc/alc.cpp
@@ -52,11 +52,11 @@
 #include "AL/efx.h"
 
 #include "alAuxEffectSlot.h"
+#include "alcmain.h"
 #include "alEffect.h"
 #include "alError.h"
 #include "alFilter.h"
 #include "alListener.h"
-#include "alMain.h"
 #include "alSource.h"
 #include "albyte.h"
 #include "alconfig.h"
diff --git a/Alc/alcmain.h b/Alc/alcmain.h
new file mode 100644
index 00000000..a22e0e81
--- /dev/null
+++ b/Alc/alcmain.h
@@ -0,0 +1,534 @@
+#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 "hrtf.h"
+#include "inprogext.h"
+#include "vector.h"
+
+class BFormatDec;
+struct ALbuffer;
+struct ALeffect;
+struct ALfilter;
+struct BackendBase;
+struct Compressor;
+struct EffectState;
+struct FrontStablizer;
+struct Uhj2Encoder;
+struct bs2b;
+
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
+#define IS_LITTLE_ENDIAN (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#else
+static const union {
+    ALuint u;
+    ALubyte b[sizeof(ALuint)];
+} EndianTest = { 1 };
+#define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
+#endif
+
+
+#define MIN_OUTPUT_RATE      8000
+#define DEFAULT_OUTPUT_RATE  44100
+#define DEFAULT_UPDATE_SIZE  882 /* 20ms */
+#define DEFAULT_NUM_UPDATES  3
+
+
+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 = ALbyte; };
+template<>
+struct DevFmtTypeTraits<DevFmtUByte> { using Type = ALubyte; };
+template<>
+struct DevFmtTypeTraits<DevFmtShort> { using Type = ALshort; };
+template<>
+struct DevFmtTypeTraits<DevFmtUShort> { using Type = ALushort; };
+template<>
+struct DevFmtTypeTraits<DevFmtInt> { using Type = ALint; };
+template<>
+struct DevFmtTypeTraits<DevFmtUInt> { using Type = ALuint; };
+template<>
+struct DevFmtTypeTraits<DevFmtFloat> { using Type = ALfloat; };
+
+
+ALsizei BytesFromDevFmt(DevFmtType type) noexcept;
+ALsizei ChannelsFromDevFmt(DevFmtChannels chans, ALsizei ambiorder) noexcept;
+inline ALsizei FrameSizeFromDevFmt(DevFmtChannels chans, DevFmtType type, ALsizei 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
+};
+
+
+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};
+        ALsizei Length{0}; /* 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;
+    ALsizei 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 either end of a buffer for resampling.
+ * Note that both the beginning and end need padding!
+ */
+#define MAX_RESAMPLE_PADDING 24
+
+
+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<ALint,MaxChannels> ChannelIndex{};
+
+    al::span<FloatBufferLine> Buffer;
+};
+
+using POSTPROCESS = void(*)(ALCdevice *device, const ALsizei SamplesToDo);
+
+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 {
+    RefCount ref{1u};
+
+    std::atomic<bool> Connected{true};
+    const DeviceType Type{};
+
+    ALuint Frequency{};
+    ALuint UpdateSize{};
+    ALuint BufferSize{};
+
+    DevFmtChannels FmtChans{};
+    DevFmtType     FmtType{};
+    ALboolean IsHeadphones{AL_FALSE};
+    ALsizei 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{};
+    ALsizei 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_RESAMPLE_PADDING*2];
+    alignas(16) ALfloat ResampledData[BUFFERSIZE];
+    alignas(16) ALfloat FilteredData[BUFFERSIZE];
+    union {
+        alignas(16) ALfloat HrtfSourceData[BUFFERSIZE + HRTF_HISTORY_LENGTH];
+        alignas(16) ALfloat NfcSampleData[BUFFERSIZE];
+    };
+    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;
+
+    POSTPROCESS PostProcess{};
+
+    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();
+
+    ALsizei bytesFromFmt() const noexcept { return BytesFromDevFmt(FmtType); }
+    ALsizei channelsFromFmt() const noexcept { return ChannelsFromDevFmt(FmtChans, mAmbiOrder); }
+    ALsizei frameSizeFromFmt() const noexcept { return bytesFromFmt() * channelsFromFmt(); }
+
+    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"
+
+
+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;
+            ALsizei count;
+        } bufcomp;
+        struct {
+            ALenum type;
+            ALuint id;
+            ALuint param;
+            ALchar msg[1008];
+        } user;
+        EffectState *mEffectState;
+    } u{};
+
+    AsyncEvent() noexcept = default;
+    constexpr AsyncEvent(unsigned int type) noexcept : EnumType{type} { }
+};
+
+
+void AllocateVoices(ALCcontext *context, size_t num_voices);
+
+
+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 -1 if it
+ * doesn't exist.
+ */
+inline ALint GetChannelIdxByName(const RealMixParams &real, Channel chan) noexcept
+{ return real.ChannelIndex[chan]; }
+
+
+void StartEventThrd(ALCcontext *ctx);
+void StopEventThrd(ALCcontext *ctx);
+
+
+al::vector<std::string> SearchDataFiles(const char *match, const char *subdir);
+
+#endif
diff --git a/Alc/alconfig.cpp b/Alc/alconfig.cpp
index 5f5f9149..b246a91d 100644
--- a/Alc/alconfig.cpp
+++ b/Alc/alconfig.cpp
@@ -28,6 +28,8 @@
 
 #include "config.h"
 
+#include "alconfig.h"
+
 #include <cstdlib>
 #include <cctype>
 #include <cstring>
@@ -43,8 +45,7 @@
 #include <string>
 #include <algorithm>
 
-#include "alMain.h"
-#include "alconfig.h"
+#include "alcmain.h"
 #include "logging.h"
 #include "compat.h"
 
diff --git a/Alc/alu.cpp b/Alc/alu.cpp
index 666cbb27..cc1a5a98 100644
--- a/Alc/alu.cpp
+++ b/Alc/alu.cpp
@@ -47,9 +47,9 @@
 
 #include "alAuxEffectSlot.h"
 #include "alBuffer.h"
+#include "alcmain.h"
 #include "alEffect.h"
 #include "alListener.h"
-#include "alMain.h"
 #include "alcontext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/alu.h b/Alc/alu.h
new file mode 100644
index 00000000..9acf904a
--- /dev/null
+++ b/Alc/alu.h
@@ -0,0 +1,466 @@
+#ifndef _ALU_H_
+#define _ALU_H_
+
+#include <array>
+#include <atomic>
+#include <cmath>
+#include <cstddef>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
+
+#include "alBuffer.h"
+#include "alcmain.h"
+#include "almalloc.h"
+#include "alspan.h"
+#include "ambidefs.h"
+#include "filters/biquad.h"
+#include "filters/nfc.h"
+#include "filters/splitter.h"
+#include "hrtf.h"
+#include "logging.h"
+
+struct ALbufferlistitem;
+struct ALeffectslot;
+struct BSincTable;
+
+
+enum class DistanceModel;
+
+#define MAX_PITCH  255
+#define MAX_SENDS  16
+
+
+#define DITHER_RNG_SEED 22222
+
+
+enum SpatializeMode {
+    SpatializeOff = AL_FALSE,
+    SpatializeOn = AL_TRUE,
+    SpatializeAuto = AL_AUTO_SOFT
+};
+
+enum Resampler {
+    PointResampler,
+    LinearResampler,
+    FIR4Resampler,
+    BSinc12Resampler,
+    BSinc24Resampler,
+
+    ResamplerMax = BSinc24Resampler
+};
+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  4
+#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 {
+    ALfloat sf; /* Scale interpolation factor. */
+    ALsizei m;  /* Coefficient count. */
+    ALsizei l;  /* Left coefficient offset. */
+    /* Filter coefficients, followed by the scale, phase, and scale-phase
+     * delta coefficients. Starting at phase index 0, each subsequent phase
+     * index follows contiguously.
+     */
+    const ALfloat *filter;
+};
+
+union InterpState {
+    BsincState bsinc;
+};
+
+using ResamplerFunc = const ALfloat*(*)(const InterpState *state,
+    const ALfloat *RESTRICT src, ALsizei frac, ALint increment,
+    ALfloat *RESTRICT dst, ALsizei dstlen);
+
+void BsincPrepare(const ALuint increment, BsincState *state, const BSincTable *table);
+
+extern const BSincTable bsinc12;
+extern const BSincTable bsinc24;
+
+
+enum {
+    AF_None = 0,
+    AF_LowPass = 1,
+    AF_HighPass = 2,
+    AF_BandPass = AF_LowPass | AF_HighPass
+};
+
+
+struct MixHrtfFilter {
+    const HrirArray<ALfloat> *Coeffs;
+    ALsizei Delay[2];
+    ALfloat Gain;
+    ALfloat GainStep;
+};
+
+
+struct DirectParams {
+    BiquadFilter LowPass;
+    BiquadFilter HighPass;
+
+    NfcFilter NFCtrlFilter;
+
+    struct {
+        HrtfFilter Old;
+        HrtfFilter Target;
+        HrtfState State;
+    } Hrtf;
+
+    struct {
+        ALfloat Current[MAX_OUTPUT_CHANNELS];
+        ALfloat Target[MAX_OUTPUT_CHANNELS];
+    } Gains;
+};
+
+struct SendParams {
+    BiquadFilter LowPass;
+    BiquadFilter HighPass;
+
+    struct {
+        ALfloat Current[MAX_OUTPUT_CHANNELS];
+        ALfloat Target[MAX_OUTPUT_CHANNELS];
+    } Gains;
+};
+
+
+struct ALvoicePropsBase {
+    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;
+    ALboolean HeadRelative;
+    DistanceModel mDistanceModel;
+    Resampler mResampler;
+    ALboolean DirectChannels;
+    SpatializeMode mSpatializeMode;
+
+    ALboolean DryGainHFAuto;
+    ALboolean WetGainAuto;
+    ALboolean WetGainHFAuto;
+    ALfloat   OuterGainHF;
+
+    ALfloat AirAbsorptionFactor;
+    ALfloat RoomRolloffFactor;
+    ALfloat DopplerFactor;
+
+    std::array<ALfloat,2> StereoPan;
+
+    ALfloat Radius;
+
+    /** Direct filter and auxiliary send info. */
+    struct {
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat HFReference;
+        ALfloat GainLF;
+        ALfloat LFReference;
+    } Direct;
+    struct SendData {
+        ALeffectslot *Slot;
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat HFReference;
+        ALfloat GainLF;
+        ALfloat 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<ALsizei> 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;
+    ALsizei mNumChannels;
+    ALsizei mSampleSize;
+
+    /** Current target parameters used for mixing. */
+    ALint mStep;
+
+    ResamplerFunc mResampler;
+
+    InterpState mResampleState;
+
+    ALuint mFlags;
+
+    struct DirectData {
+        int FilterType;
+        al::span<FloatBufferLine> Buffer;
+    };
+    DirectData mDirect;
+
+    struct SendData {
+        int FilterType;
+        al::span<FloatBufferLine> Buffer;
+    };
+    std::array<SendData,MAX_SENDS> mSend;
+
+    struct ChannelData {
+        alignas(16) std::array<ALfloat,MAX_RESAMPLE_PADDING*2> mPrevSamples;
+
+        ALfloat 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() { 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;
+    }
+};
+
+
+using MixerFunc = void(*)(const ALfloat *data, const al::span<FloatBufferLine> OutBuffer,
+    ALfloat *CurrentGains, const ALfloat *TargetGains, const ALsizei Counter, const ALsizei OutPos,
+    const ALsizei BufferSize);
+using RowMixerFunc = void(*)(FloatBufferLine &OutBuffer, const ALfloat *gains,
+    const al::span<const FloatBufferLine> InSamples, const ALsizei InPos,
+    const ALsizei BufferSize);
+using HrtfMixerFunc = void(*)(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
+    const ALfloat *InSamples, float2 *AccumSamples, const ALsizei OutPos, const ALsizei IrSize,
+    MixHrtfFilter *hrtfparams, const ALsizei BufferSize);
+using HrtfMixerBlendFunc = void(*)(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
+    const ALfloat *InSamples, float2 *AccumSamples, const ALsizei OutPos, const ALsizei IrSize,
+    const HrtfFilter *oldparams, MixHrtfFilter *newparams, const ALsizei BufferSize);
+using HrtfDirectMixerFunc = void(*)(FloatBufferLine &LeftOut, FloatBufferLine &RightOut,
+    const al::span<const FloatBufferLine> InSamples, float2 *AccumSamples, DirectHrtfState *State,
+    const ALsizei BufferSize);
+
+
+#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,
+};
+
+void aluInit(void);
+
+void aluInitMixer(void);
+
+ResamplerFunc SelectResampler(Resampler resampler);
+
+/* 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);
+
+void ProcessHrtf(ALCdevice *device, const ALsizei SamplesToDo);
+void ProcessAmbiDec(ALCdevice *device, const ALsizei SamplesToDo);
+void ProcessUhj(ALCdevice *device, const ALsizei SamplesToDo);
+void ProcessBs2b(ALCdevice *device, const ALsizei SamplesToDo);
+
+/**
+ * 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 ALfloat y, const ALfloat z, const ALfloat x, const ALfloat spread,
+                    ALfloat (&coeffs)[MAX_AMBI_CHANNELS]);
+
+/**
+ * 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 ALfloat (&dir)[3], ALfloat spread, ALfloat (&coeffs)[MAX_AMBI_CHANNELS])
+{
+    /* 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(ALfloat azimuth, ALfloat elevation, ALfloat spread, ALfloat (&coeffs)[MAX_AMBI_CHANNELS])
+{
+    ALfloat x = -std::sin(azimuth) * std::cos(elevation);
+    ALfloat y = std::sin(elevation);
+    ALfloat 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 ALfloat*RESTRICT coeffs, ALfloat ingain, ALfloat (&gains)[MAX_OUTPUT_CHANNELS]);
+
+
+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 MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCcontext *Context, const ALsizei SamplesToDo);
+
+void aluMixData(ALCdevice *device, ALvoid *OutBuffer, ALsizei 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);
+
+extern MixerFunc MixSamples;
+extern RowMixerFunc MixRowSamples;
+
+extern const ALfloat ConeScale;
+extern const ALfloat ZScale;
+extern const ALboolean OverrideReverbSpeedOfSound;
+
+#endif
diff --git a/Alc/backends/alsa.cpp b/Alc/backends/alsa.cpp
index 698a4088..c133df68 100644
--- a/Alc/backends/alsa.cpp
+++ b/Alc/backends/alsa.cpp
@@ -37,8 +37,8 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
 #include "albyte.h"
+#include "alcmain.h"
 #include "alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/backends/base.cpp b/Alc/backends/base.cpp
index 5748975e..a7d47c6d 100644
--- a/Alc/backends/base.cpp
+++ b/Alc/backends/base.cpp
@@ -5,7 +5,7 @@
 
 #include <thread>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 
 #include "backends/base.h"
diff --git a/Alc/backends/base.h b/Alc/backends/base.h
index 7a9232a6..437e31d9 100644
--- a/Alc/backends/base.h
+++ b/Alc/backends/base.h
@@ -6,7 +6,7 @@
 #include <string>
 #include <mutex>
 
-#include "alMain.h"
+#include "alcmain.h"
 
 
 struct ClockLatency {
diff --git a/Alc/backends/coreaudio.cpp b/Alc/backends/coreaudio.cpp
index c6978505..b4b46382 100644
--- a/Alc/backends/coreaudio.cpp
+++ b/Alc/backends/coreaudio.cpp
@@ -26,7 +26,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "ringbuffer.h"
 #include "converter.h"
diff --git a/Alc/backends/dsound.cpp b/Alc/backends/dsound.cpp
index d4c1033c..5a156d54 100644
--- a/Alc/backends/dsound.cpp
+++ b/Alc/backends/dsound.cpp
@@ -44,7 +44,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "ringbuffer.h"
 #include "compat.h"
diff --git a/Alc/backends/jack.cpp b/Alc/backends/jack.cpp
index 99e9019b..3f81d08c 100644
--- a/Alc/backends/jack.cpp
+++ b/Alc/backends/jack.cpp
@@ -29,7 +29,7 @@
 #include <thread>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "alconfig.h"
 #include "ringbuffer.h"
diff --git a/Alc/backends/loopback.cpp b/Alc/backends/loopback.cpp
index 77606b89..4a1c641a 100644
--- a/Alc/backends/loopback.cpp
+++ b/Alc/backends/loopback.cpp
@@ -22,7 +22,7 @@
 
 #include "backends/loopback.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 
 
diff --git a/Alc/backends/null.cpp b/Alc/backends/null.cpp
index 00a37fda..ae58cb8b 100644
--- a/Alc/backends/null.cpp
+++ b/Alc/backends/null.cpp
@@ -30,7 +30,7 @@
 #include <functional>
 #include <thread>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "almalloc.h"
 #include "alu.h"
 #include "logging.h"
diff --git a/Alc/backends/opensl.cpp b/Alc/backends/opensl.cpp
index 452028ea..b34dc0cb 100644
--- a/Alc/backends/opensl.cpp
+++ b/Alc/backends/opensl.cpp
@@ -31,7 +31,7 @@
 #include <thread>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "ringbuffer.h"
 #include "threads.h"
diff --git a/Alc/backends/oss.cpp b/Alc/backends/oss.cpp
index 33075890..8cfe9e96 100644
--- a/Alc/backends/oss.cpp
+++ b/Alc/backends/oss.cpp
@@ -43,7 +43,7 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/backends/portaudio.cpp b/Alc/backends/portaudio.cpp
index 10c8261b..73e972c5 100644
--- a/Alc/backends/portaudio.cpp
+++ b/Alc/backends/portaudio.cpp
@@ -26,7 +26,7 @@
 #include <cstdlib>
 #include <cstring>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "alconfig.h"
 #include "ringbuffer.h"
diff --git a/Alc/backends/pulseaudio.cpp b/Alc/backends/pulseaudio.cpp
index 97736253..da209c8d 100644
--- a/Alc/backends/pulseaudio.cpp
+++ b/Alc/backends/pulseaudio.cpp
@@ -34,7 +34,7 @@
 #include <algorithm>
 #include <condition_variable>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "alconfig.h"
 #include "compat.h"
diff --git a/Alc/backends/qsa.cpp b/Alc/backends/qsa.cpp
index 074430ca..64ed53aa 100644
--- a/Alc/backends/qsa.cpp
+++ b/Alc/backends/qsa.cpp
@@ -33,7 +33,7 @@
 #include <memory>
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "threads.h"
 
diff --git a/Alc/backends/sdl2.cpp b/Alc/backends/sdl2.cpp
index a7a1752e..97547959 100644
--- a/Alc/backends/sdl2.cpp
+++ b/Alc/backends/sdl2.cpp
@@ -27,7 +27,7 @@
 
 #include <string>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "threads.h"
 #include "compat.h"
diff --git a/Alc/backends/sndio.cpp b/Alc/backends/sndio.cpp
index e696cf55..587f67bb 100644
--- a/Alc/backends/sndio.cpp
+++ b/Alc/backends/sndio.cpp
@@ -29,7 +29,7 @@
 #include <thread>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "threads.h"
 #include "vector.h"
diff --git a/Alc/backends/solaris.cpp b/Alc/backends/solaris.cpp
index 5c12ad72..584f6e66 100644
--- a/Alc/backends/solaris.cpp
+++ b/Alc/backends/solaris.cpp
@@ -38,7 +38,7 @@
 #include <thread>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "alconfig.h"
 #include "threads.h"
diff --git a/Alc/backends/wasapi.cpp b/Alc/backends/wasapi.cpp
index 384aaba8..bd009463 100644
--- a/Alc/backends/wasapi.cpp
+++ b/Alc/backends/wasapi.cpp
@@ -54,7 +54,7 @@
 #include <functional>
 #include <condition_variable>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "ringbuffer.h"
 #include "compat.h"
diff --git a/Alc/backends/wave.cpp b/Alc/backends/wave.cpp
index 77692686..67ed7e79 100644
--- a/Alc/backends/wave.cpp
+++ b/Alc/backends/wave.cpp
@@ -35,7 +35,7 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/backends/winmm.cpp b/Alc/backends/winmm.cpp
index 57abee06..cd32e95b 100644
--- a/Alc/backends/winmm.cpp
+++ b/Alc/backends/winmm.cpp
@@ -37,7 +37,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "ringbuffer.h"
 #include "threads.h"
diff --git a/Alc/bformatdec.h b/Alc/bformatdec.h
index 31abc4fe..06974651 100644
--- a/Alc/bformatdec.h
+++ b/Alc/bformatdec.h
@@ -6,7 +6,7 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "almalloc.h"
 #include "alspan.h"
 #include "ambidefs.h"
diff --git a/Alc/converter.h b/Alc/converter.h
index 04d94833..033e4d3f 100644
--- a/Alc/converter.h
+++ b/Alc/converter.h
@@ -3,7 +3,7 @@
 
 #include <memory>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "almalloc.h"
 
diff --git a/Alc/effects/autowah.cpp b/Alc/effects/autowah.cpp
index 8545de1f..96292636 100644
--- a/Alc/effects/autowah.cpp
+++ b/Alc/effects/autowah.cpp
@@ -25,7 +25,7 @@
 
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/base.h b/Alc/effects/base.h
index 2b067f11..4f48de22 100644
--- a/Alc/effects/base.h
+++ b/Alc/effects/base.h
@@ -1,8 +1,7 @@
 #ifndef EFFECTS_BASE_H
 #define EFFECTS_BASE_H
 
-#include "alMain.h"
-
+#include "alcmain.h"
 #include "almalloc.h"
 #include "alspan.h"
 #include "atomic.h"
diff --git a/Alc/effects/chorus.cpp b/Alc/effects/chorus.cpp
index b9bf3f4c..d475b57a 100644
--- a/Alc/effects/chorus.cpp
+++ b/Alc/effects/chorus.cpp
@@ -31,8 +31,8 @@
 #include "AL/efx.h"
 
 #include "alAuxEffectSlot.h"
+#include "alcmain.h"
 #include "alError.h"
-#include "alMain.h"
 #include "alcontext.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/effects/compressor.cpp b/Alc/effects/compressor.cpp
index 82f70317..4a487097 100644
--- a/Alc/effects/compressor.cpp
+++ b/Alc/effects/compressor.cpp
@@ -22,7 +22,7 @@
 
 #include <cstdlib>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alu.h"
 #include "alAuxEffectSlot.h"
diff --git a/Alc/effects/dedicated.cpp b/Alc/effects/dedicated.cpp
index f31cc903..b31b3750 100644
--- a/Alc/effects/dedicated.cpp
+++ b/Alc/effects/dedicated.cpp
@@ -24,7 +24,7 @@
 #include <cmath>
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/distortion.cpp b/Alc/effects/distortion.cpp
index 94af9e11..59557395 100644
--- a/Alc/effects/distortion.cpp
+++ b/Alc/effects/distortion.cpp
@@ -25,7 +25,7 @@
 
 #include <cmath>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/echo.cpp b/Alc/effects/echo.cpp
index 0211520b..c10f2eb2 100644
--- a/Alc/effects/echo.cpp
+++ b/Alc/effects/echo.cpp
@@ -25,7 +25,7 @@
 
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alFilter.h"
 #include "alAuxEffectSlot.h"
diff --git a/Alc/effects/equalizer.cpp b/Alc/effects/equalizer.cpp
index 961ae8fc..69ab5021 100644
--- a/Alc/effects/equalizer.cpp
+++ b/Alc/effects/equalizer.cpp
@@ -26,7 +26,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/fshifter.cpp b/Alc/effects/fshifter.cpp
index 68e10cba..b47aa00e 100644
--- a/Alc/effects/fshifter.cpp
+++ b/Alc/effects/fshifter.cpp
@@ -26,7 +26,7 @@
 #include <complex>
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/modulator.cpp b/Alc/effects/modulator.cpp
index 8377aefe..086482d7 100644
--- a/Alc/effects/modulator.cpp
+++ b/Alc/effects/modulator.cpp
@@ -26,7 +26,7 @@
 #include <cmath>
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/null.cpp b/Alc/effects/null.cpp
index 3c27bae0..e55c8699 100644
--- a/Alc/effects/null.cpp
+++ b/Alc/effects/null.cpp
@@ -5,7 +5,7 @@
 #include "AL/al.h"
 #include "AL/alc.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/pshifter.cpp b/Alc/effects/pshifter.cpp
index bade81e6..39d3cf1a 100644
--- a/Alc/effects/pshifter.cpp
+++ b/Alc/effects/pshifter.cpp
@@ -30,7 +30,7 @@
 #include <complex>
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/effects/reverb.cpp b/Alc/effects/reverb.cpp
index 01f5c476..ac996b3f 100644
--- a/Alc/effects/reverb.cpp
+++ b/Alc/effects/reverb.cpp
@@ -29,7 +29,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alu.h"
 #include "alAuxEffectSlot.h"
diff --git a/Alc/effects/vmorpher.cpp b/Alc/effects/vmorpher.cpp
index 6f7e22ae..eebba3f1 100644
--- a/Alc/effects/vmorpher.cpp
+++ b/Alc/effects/vmorpher.cpp
@@ -25,7 +25,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alcontext.h"
 #include "alAuxEffectSlot.h"
 #include "alError.h"
diff --git a/Alc/filters/nfc.cpp b/Alc/filters/nfc.cpp
index e607dd56..1a567f2c 100644
--- a/Alc/filters/nfc.cpp
+++ b/Alc/filters/nfc.cpp
@@ -5,7 +5,7 @@
 
 #include <algorithm>
 
-#include "alMain.h"
+#include "alcmain.h"
 
 
 /* Near-field control filters are the basis for handling the near-field effect.
diff --git a/Alc/filters/splitter.h b/Alc/filters/splitter.h
index 70fddd9e..927c4d17 100644
--- a/Alc/filters/splitter.h
+++ b/Alc/filters/splitter.h
@@ -1,7 +1,7 @@
 #ifndef FILTER_SPLITTER_H
 #define FILTER_SPLITTER_H
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "almalloc.h"
 
 
diff --git a/Alc/helpers.cpp b/Alc/helpers.cpp
index 9f6283a3..e86af6ce 100644
--- a/Alc/helpers.cpp
+++ b/Alc/helpers.cpp
@@ -103,7 +103,7 @@ DEFINE_PROPERTYKEY(PKEY_AudioEndpoint_GUID, 0x1da5d803, 0xd492, 0x4edd, 0x8c, 0x
 #include <shlobj.h>
 #endif
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "almalloc.h"
 #include "compat.h"
 #include "cpu_caps.h"
diff --git a/Alc/hrtf.cpp b/Alc/hrtf.cpp
index 73cdc24e..786c4c5d 100644
--- a/Alc/hrtf.cpp
+++ b/Alc/hrtf.cpp
@@ -40,7 +40,7 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alconfig.h"
 #include "almalloc.h"
 #include "alnumeric.h"
diff --git a/Alc/mastering.h b/Alc/mastering.h
index 1003fa6c..34dc8dcb 100644
--- a/Alc/mastering.h
+++ b/Alc/mastering.h
@@ -7,7 +7,7 @@
 
 #include "almalloc.h"
 /* For FloatBufferLine/BUFFERSIZE. */
-#include "alMain.h"
+#include "alcmain.h"
 
 
 struct SlidingHold;
diff --git a/Alc/mixer/defs.h b/Alc/mixer/defs.h
index 0e91e30e..3e5d1125 100644
--- a/Alc/mixer/defs.h
+++ b/Alc/mixer/defs.h
@@ -3,9 +3,9 @@
 
 #include "AL/alc.h"
 #include "AL/al.h"
-#include "alMain.h"
-#include "alu.h"
 
+#include "alcmain.h"
+#include "alu.h"
 #include "alspan.h"
 
 
diff --git a/Alc/mixer/mixer_c.cpp b/Alc/mixer/mixer_c.cpp
index b9d51c9c..47c4a6f4 100644
--- a/Alc/mixer/mixer_c.cpp
+++ b/Alc/mixer/mixer_c.cpp
@@ -4,7 +4,7 @@
 
 #include <limits>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "alSource.h"
 #include "alAuxEffectSlot.h"
diff --git a/Alc/mixer/mixer_neon.cpp b/Alc/mixer/mixer_neon.cpp
index 81d0ff67..fa487d97 100644
--- a/Alc/mixer/mixer_neon.cpp
+++ b/Alc/mixer/mixer_neon.cpp
@@ -6,7 +6,7 @@
 
 #include "AL/al.h"
 #include "AL/alc.h"
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 #include "hrtf.h"
 #include "defs.h"
diff --git a/Alc/mixer/mixer_sse.cpp b/Alc/mixer/mixer_sse.cpp
index f407ac14..b763fdbd 100644
--- a/Alc/mixer/mixer_sse.cpp
+++ b/Alc/mixer/mixer_sse.cpp
@@ -6,7 +6,7 @@
 
 #include "AL/al.h"
 #include "AL/alc.h"
-#include "alMain.h"
+#include "alcmain.h"
 #include "alu.h"
 
 #include "alSource.h"
diff --git a/Alc/mixvoice.cpp b/Alc/mixvoice.cpp
index 1020cc74..be872f6d 100644
--- a/Alc/mixvoice.cpp
+++ b/Alc/mixvoice.cpp
@@ -40,7 +40,7 @@
 #include "AL/alc.h"
 
 #include "alBuffer.h"
-#include "alMain.h"
+#include "alcmain.h"
 #include "alSource.h"
 #include "albyte.h"
 #include "alconfig.h"
diff --git a/Alc/panning.cpp b/Alc/panning.cpp
index e8f80069..3a67e33a 100644
--- a/Alc/panning.cpp
+++ b/Alc/panning.cpp
@@ -32,7 +32,7 @@
 #include <algorithm>
 #include <functional>
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "alAuxEffectSlot.h"
 #include "alu.h"
 #include "alconfig.h"
diff --git a/Alc/uhjfilter.h b/Alc/uhjfilter.h
index 181e036a..53e4f89e 100644
--- a/Alc/uhjfilter.h
+++ b/Alc/uhjfilter.h
@@ -3,7 +3,7 @@
 
 #include "AL/al.h"
 
-#include "alMain.h"
+#include "alcmain.h"
 #include "almalloc.h"