diff options
Diffstat (limited 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" |