Use span's iterators for FlexArray

Use a span for the distance compensation buffer

Avoid some more raw pointers

Remove const from a return type

Use spans instead of raw pointers for the filters' output

Use spans more for voice processing

Fix buffer load size for negative buffer offsets

Rename some 'pan's to 'gain's for clarity

Use an iterator to iterate over the channel orders

Iterate over the async events directly

Give names to unnamed structs

Add an in-progress extension for panning sources

Add the _SOFT suffix to the I32 UHJ formats

The existing UHJ formats are provided by AL_SOFT_UHJ[_ex] which already have
the _SOFT suffix, so this just makes it consistent.

Fix up some includes

Move storage format definitions to a separate file

Fix PFFFT compilation for PowerPC (#955)

Fixes taken from 2 upstream commits:
- https://bitbucket.org/jpommier/pffft/commits/ccd5628652f86d193cad887447e2546ffb7c1b28
- https://bitbucket.org/jpommier/pffft/commits/233c26659185ff55958e96e4c25f3fcafe249a65

Use spans for PPhaseResampler::process

Fix some clang-tidy complaints

Use spans for preparing samples from buffers

Use the correct return type for subspan

Reduce the depth of some branches

Make mSampleData an array of floats instead of an array of arrays

This helps reduce the amount of unused memory in between the mixing channels'
storage, for better cache utilization.

Add voice properties to do left-right panning

Use a proper type for the resampler padding length

Check when resampling to do a simple copy

Collapse some nested ifs

Fix cubic_tables.h includes

Explicitly use load and store for atomics

Check if a file exists instead of relying on an exception

Pass a span to ApplyDistanceComp

Calculate the ending mix counter value earlier

Check that writeAdvance and readAdvance don't over/underflow

Rename some variables for clarity

Fix a bug that playback via portaudio does not work at all (#975)

Properly use std::hardware_destructive_interference_size

Allow using the total capacity of the RingBuffer

Make better use of cache lines for the ringbuffer indices

Store the filter table directly in the cubic filter object

Replace an array with a switch

Make AL[C]_EXT_direct_context public

Give better names to the wrapper function parameters

Initialize a variable when declaring it

Add a couple missing includes

Promote a variable to size_t for the multiply, not after

Replace a few more for/while loops with std::generator

Don't assume a span is static sized

Add a slightly more efficient cubic resampler

Not as beneficial as I'd have hoped, but there does seem to be a slight
improvement.

Avoid calculating an extra bsinc phase index

It's just the first index offset by 1, which is easy enough to calculate the
deltas from.

Use a variant to control the modulator effect generator

Clean up some includes

Use the cubic filter bit-depth for the chorus depth/delay scale

Use std::generate instead of for loops for resampling

Use the gaussian filter table for the chorus effect

Move the reverb's cubic filter to a shared header

Use a 4-point Gaussian filter for cubic resampling

Avoid a few uses of &array[idx]

Update some includes

Call the correct delete function

Fix macOS support for tss

Make the context error state thread-local

This is very much not specified by the standard, but it is necessary to allow
thread-safe usage and error checking. Otherwise, if two threads are making AL
calls (say, one thread handling a streaming buffer queue and another to play
and update sound sources) and checking for errors, it's possible for one thread
to generate an error that the other thread reads, causing the one thread to not
see the error and think its calls were okay despite the failure, and the other
thread to think its calls caused an error when it was actually successful. This
is a possible, if not likely, scenario in existing apps.

This probably violates the current standard, however I can't think of a useful
scenario where this would be a significant problem. It would essentially rely
on the app knowingly reading errors from a separate thread than the one that
generated them, which would be a problem for actually reacting to the failed
call or having useful information to log the error with. That's if the app is
even generating errors to begin with.

If this does prove to be a problem, a compat option can be added to restore the
original behavior. Or in the worst case, revert to the original behavior by
default and have an opt-in flag for apps that want thread-local error state.
But for now, let's assume existing apps will be fine, if not fix potention race
conditions.

Clear the sorted array for the default reverb auxslot

Don't do geometric reflections for the late reverb

At this point, the vector all-pass is already applying a diffusion-based
scattering matrix, which the geometric reflections would compound with.

Clean up some includes

Make some parameter names consistent

Invert the phase of reflected signals in reverb

Pass a span to the data stream databuf

Constify a span's type that's only read

Silence unused parameter warnings

Remove al::ifstream wrapper

Unnecessary since std::filesystem can handle UTF-8 path names

Fix up some includes

Remove a couple unnecessary macros

Clean up some variable initialization

Replace an assertion macro with an inline function

Use a unique_ptr to manager PFFFT_Setup objects

Make al::span a bit more conformant

And check the size for fixed-size span initialization

Use wstrings for retriving the exe path on Windows

Clarify ambiguity between size_t and DWORD

Avoid hardcoding some sublist counts

Remove custom minz/maxz functions

Separate integer division from floating point conversion

Avoid extraneous angular conversions

Remove some custom mix/max/clamp functions

Use the correct length for the reveb mixing matrix multiply

Use a single buffer for the reverb delay input

The room gain/lf/hf is applied when tapping for the early reflections, which
makes the initial input delay buffer the same for both pipelines, allowing it
to be shared. Each pipeline fades its early reflection input taps to create a
smoother transition.

Check the sample rate limit for loading HRTF

Properly sort the loaded HRTFs

Use string_view a bit more

Better handle exceptions when loading mhr files

Recognize the IEC61937 enum in newer Oboe versions

Separate a lambda definition from calling it

Replace another loop with any_of

Silence some clang-tidy warnings

Reset the offset for each line in Allpass4::process

Check the string_view length before reading it

One more fix for Apple

Add a missing include for macOS

Make sure the winrt::hstring gets used as a wstring

Use std::filesystem to construct config file paths

Use string_view instead of temporary strings

Remove some unneeded elses