Use std::array for most mixing buffer arrays

2019-05-28 16:22:36 -07:00
parent 7ce2b632f5
commit c80ee5b701
14 changed files with 89 additions and 80 deletions
@@ -1937,7 +1937,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
        num_chans*sizeof(device->MixBuffer[0]));
    device->MixBuffer.resize(num_chans);

-    device->Dry.Buffer = &reinterpret_cast<ALfloat(&)[BUFFERSIZE]>(device->MixBuffer[0]);
+    device->Dry.Buffer = device->MixBuffer.data();
    if(device->RealOut.NumChannels != 0)
        device->RealOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels;
    else
@@ -133,8 +133,9 @@ void ProcessHrtf(ALCdevice *device, const ALsizei SamplesToDo)
    ASSUME(lidx >= 0 && ridx >= 0);

    DirectHrtfState *state{device->mHrtfState.get()};
-    MixDirectHrtf(device->RealOut.Buffer[lidx], device->RealOut.Buffer[ridx], device->Dry.Buffer,
-        device->HrtfAccumData, state, device->Dry.NumChannels, SamplesToDo);
+    MixDirectHrtf(device->RealOut.Buffer[lidx].data(), device->RealOut.Buffer[ridx].data(),
+        &reinterpret_cast<float(&)[BUFFERSIZE]>(device->Dry.Buffer[0]), device->HrtfAccumData,
+        state, device->Dry.NumChannels, SamplesToDo);
 }

 void ProcessAmbiDec(ALCdevice *device, const ALsizei SamplesToDo)
@@ -165,8 +166,8 @@ void ProcessBs2b(ALCdevice *device, const ALsizei SamplesToDo)
    ASSUME(lidx >= 0 && ridx >= 0);

    /* Apply binaural/crossfeed filter */
-    bs2b_cross_feed(device->Bs2b.get(), device->RealOut.Buffer[lidx],
-                    device->RealOut.Buffer[ridx], SamplesToDo);
+    bs2b_cross_feed(device->Bs2b.get(), device->RealOut.Buffer[lidx].data(),
+        device->RealOut.Buffer[ridx].data(), SamplesToDo);
 }

 } // namespace
@@ -1465,14 +1466,17 @@ void ProcessContext(ALCcontext *ctx, const ALsizei SamplesToDo)
        [SamplesToDo](const ALeffectslot *slot) -> void
        {
            EffectState *state{slot->Params.mEffectState};
-            state->process(SamplesToDo, slot->Wet.Buffer, slot->Wet.NumChannels,
-                state->mOutBuffer, state->mOutChannels);
+            state->process(SamplesToDo,
+                &reinterpret_cast<float(&)[BUFFERSIZE]>(slot->Wet.Buffer[0]),
+                slot->Wet.NumChannels,
+                &reinterpret_cast<float(&)[BUFFERSIZE]>(state->mOutBuffer[0]),
+                state->mOutChannels);
        }
    );
 }


-void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*Buffer)[BUFFERSIZE], const int lidx,
+void ApplyStablizer(FrontStablizer *Stablizer, FloatBufferLine *Buffer, const int lidx,
    const int ridx, const int cidx, const ALsizei SamplesToDo, const ALsizei NumChannels)
 {
    ASSUME(SamplesToDo > 0);
@@ -1487,16 +1491,17 @@ void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*Buffer)[BUFFERSIZE], co
            continue;

        auto &DelayBuf = Stablizer->DelayBuf[i];
-        auto buffer_end = Buffer[i] + SamplesToDo;
+        auto buffer_end = Buffer[i].begin() + SamplesToDo;
        if(LIKELY(SamplesToDo >= ALsizei{FrontStablizer::DelayLength}))
        {
-            auto delay_end = std::rotate(Buffer[i], buffer_end - FrontStablizer::DelayLength,
-                buffer_end);
-            std::swap_ranges(Buffer[i], delay_end, std::begin(DelayBuf));
+            auto delay_end = std::rotate(Buffer[i].begin(),
+                buffer_end - FrontStablizer::DelayLength, buffer_end);
+            std::swap_ranges(Buffer[i].begin(), delay_end, std::begin(DelayBuf));
        }
        else
        {
-            auto delay_start = std::swap_ranges(Buffer[i], buffer_end, std::begin(DelayBuf));
+            auto delay_start = std::swap_ranges(Buffer[i].begin(), buffer_end,
+                std::begin(DelayBuf));
            std::rotate(std::begin(DelayBuf), delay_start, std::end(DelayBuf));
        }
    }
@@ -1509,7 +1514,7 @@ void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*Buffer)[BUFFERSIZE], co
    /* This applies the band-splitter, preserving phase at the cost of some
     * delay. The shorter the delay, the more error seeps into the result.
     */
-    auto apply_splitter = [&APFilter,&tmpbuf,SamplesToDo](const ALfloat *Buffer,
+    auto apply_splitter = [&APFilter,&tmpbuf,SamplesToDo](const FloatBufferLine &Buffer,
        ALfloat (&DelayBuf)[FrontStablizer::DelayLength], BandSplitter &Filter,
        ALfloat (&splitbuf)[2][BUFFERSIZE]) -> void
    {
@@ -1520,7 +1525,7 @@ void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*Buffer)[BUFFERSIZE], co
         */
        auto tmpbuf_end = std::begin(tmpbuf) + SamplesToDo;
        std::copy_n(std::begin(DelayBuf), FrontStablizer::DelayLength, tmpbuf_end);
-        std::reverse_copy(Buffer, Buffer+SamplesToDo, std::begin(tmpbuf));
+        std::reverse_copy(Buffer.begin(), Buffer.begin()+SamplesToDo, std::begin(tmpbuf));
        std::copy_n(std::begin(tmpbuf), FrontStablizer::DelayLength, std::begin(DelayBuf));

        /* Apply an all-pass on the reversed signal, then reverse the samples
@@ -1568,8 +1573,8 @@ void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*Buffer)[BUFFERSIZE], co
    }
 }

-void ApplyDistanceComp(ALfloat (*Samples)[BUFFERSIZE], const DistanceComp &distcomp,
-                       const ALsizei SamplesToDo, const ALsizei numchans)
+void ApplyDistanceComp(FloatBufferLine *Samples, const DistanceComp &distcomp,
+    const ALsizei SamplesToDo, const ALsizei numchans)
 {
    ASSUME(SamplesToDo > 0);
    ASSUME(numchans > 0);
@@ -1583,7 +1588,7 @@ void ApplyDistanceComp(ALfloat (*Samples)[BUFFERSIZE], const DistanceComp &distc
        if(base < 1)
            continue;

-        ALfloat *inout{al::assume_aligned<16>(Samples[c])};
+        ALfloat *inout{al::assume_aligned<16>(Samples[c].data())};
        auto inout_end = inout + SamplesToDo;
        if(LIKELY(SamplesToDo >= base))
        {
@@ -1599,8 +1604,8 @@ void ApplyDistanceComp(ALfloat (*Samples)[BUFFERSIZE], const DistanceComp &distc
    }
 }

-void ApplyDither(ALfloat (*Samples)[BUFFERSIZE], ALuint *dither_seed, const ALfloat quant_scale,
-                 const ALsizei SamplesToDo, const ALsizei numchans)
+void ApplyDither(FloatBufferLine *Samples, ALuint *dither_seed, const ALfloat quant_scale,
+    const ALsizei SamplesToDo, const ALsizei numchans)
 {
    ASSUME(numchans > 0);

@@ -1610,11 +1615,10 @@ void ApplyDither(ALfloat (*Samples)[BUFFERSIZE], ALuint *dither_seed, const ALfl
     */
    const ALfloat invscale{1.0f / quant_scale};
    ALuint seed{*dither_seed};
-    auto dither_channel = [&seed,invscale,quant_scale,SamplesToDo](ALfloat *input) -> void
+    auto dither_channel = [&seed,invscale,quant_scale,SamplesToDo](FloatBufferLine &input) -> void
    {
        ASSUME(SamplesToDo > 0);
-        ALfloat *buffer{al::assume_aligned<16>(input)};
-        auto dither_sample = [&seed,invscale,quant_scale](ALfloat sample) noexcept -> ALfloat
+        auto dither_sample = [&seed,invscale,quant_scale](const ALfloat sample) noexcept -> ALfloat
        {
            ALfloat val{sample * quant_scale};
            ALuint rng0{dither_rng(&seed)};
@@ -1622,7 +1626,7 @@ void ApplyDither(ALfloat (*Samples)[BUFFERSIZE], ALuint *dither_seed, const ALfl
            val += static_cast<ALfloat>(rng0*(1.0/UINT_MAX) - rng1*(1.0/UINT_MAX));
            return fast_roundf(val) * invscale;
        };
-        std::transform(buffer, buffer+SamplesToDo, buffer, dither_sample);
+        std::transform(input.begin(), input.begin()+SamplesToDo, input.begin(), dither_sample);
    };
    std::for_each(Samples, Samples+numchans, dither_channel);
    *dither_seed = seed;
@@ -1660,7 +1664,7 @@ template<> inline ALubyte SampleConv(ALfloat val) noexcept
 { return SampleConv<ALbyte>(val) + 128; }

 template<DevFmtType T>
-void Write(const ALfloat (*InBuffer)[BUFFERSIZE], ALvoid *OutBuffer, const ALsizei Offset,
+void Write(const FloatBufferLine *InBuffer, ALvoid *OutBuffer, const ALsizei Offset,
    const ALsizei SamplesToDo, const ALsizei numchans)
 {
    using SampleType = typename DevFmtTypeTraits<T>::Type;
@@ -1668,7 +1672,7 @@ void Write(const ALfloat (*InBuffer)[BUFFERSIZE], ALvoid *OutBuffer, const ALsiz
    ASSUME(Offset >= 0);
    ASSUME(numchans > 0);
    SampleType *outbase = static_cast<SampleType*>(OutBuffer) + Offset*numchans;
-    auto conv_channel = [&outbase,SamplesToDo,numchans](const ALfloat *inbuf) -> void
+    auto conv_channel = [&outbase,SamplesToDo,numchans](const FloatBufferLine &inbuf) -> void
    {
        ASSUME(SamplesToDo > 0);
        SampleType *out{outbase++};
@@ -1677,7 +1681,7 @@ void Write(const ALfloat (*InBuffer)[BUFFERSIZE], ALvoid *OutBuffer, const ALsiz
            *out = SampleConv<SampleType>(s);
            out += numchans;
        };
-        std::for_each(inbuf, inbuf+SamplesToDo, conv_sample);
+        std::for_each(inbuf.begin(), inbuf.begin()+SamplesToDo, conv_sample);
    };
    std::for_each(InBuffer, InBuffer+numchans, conv_channel);
 }
@@ -1758,7 +1762,7 @@ void aluMixData(ALCdevice *device, ALvoid *OutBuffer, ALsizei NumSamples)

        if(LIKELY(OutBuffer))
        {
-            ALfloat (*Buffer)[BUFFERSIZE]{device->RealOut.Buffer};
+            FloatBufferLine *Buffer{device->RealOut.Buffer};
            ALsizei Channels{device->RealOut.NumChannels};

            /* Finally, interleave and convert samples, writing to the device's
@@ -146,7 +146,7 @@ BFormatDec::BFormatDec(const ALsizei inchans, const ALsizei chancount,
 }


-void BFormatDec::process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALsizei OutChannels, const ALfloat (*InSamples)[BUFFERSIZE], const ALsizei SamplesToDo)
+void BFormatDec::process(FloatBufferLine *OutBuffer, const ALsizei OutChannels, const FloatBufferLine *InSamples, const ALsizei SamplesToDo)
 {
    ASSUME(OutChannels > 0);
    ASSUME(mNumChannels > 0);
@@ -154,19 +154,19 @@ void BFormatDec::process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALsizei OutChan
    if(mDualBand)
    {
        for(ALsizei i{0};i < mNumChannels;i++)
-            mXOver[i].process(mSamplesHF[i].data(), mSamplesLF[i].data(), InSamples[i],
-                              SamplesToDo);
+            mXOver[i].process(mSamplesHF[i].data(), mSamplesLF[i].data(), InSamples[i].data(),
+                SamplesToDo);

        for(ALsizei chan{0};chan < OutChannels;chan++)
        {
            if(UNLIKELY(!(mEnabled&(1<<chan))))
                continue;

-            MixRowSamples(OutBuffer[chan], mMatrix.Dual[chan][sHFBand],
-                &reinterpret_cast<ALfloat(&)[BUFFERSIZE]>(mSamplesHF[0]),
+            MixRowSamples(OutBuffer[chan].data(), mMatrix.Dual[chan][sHFBand],
+                &reinterpret_cast<const ALfloat(&)[BUFFERSIZE]>(mSamplesHF[0]),
                mNumChannels, 0, SamplesToDo);
-            MixRowSamples(OutBuffer[chan], mMatrix.Dual[chan][sLFBand],
-                &reinterpret_cast<ALfloat(&)[BUFFERSIZE]>(mSamplesLF[0]),
+            MixRowSamples(OutBuffer[chan].data(), mMatrix.Dual[chan][sLFBand],
+                &reinterpret_cast<const ALfloat(&)[BUFFERSIZE]>(mSamplesLF[0]),
                mNumChannels, 0, SamplesToDo);
        }
    }
@@ -177,8 +177,9 @@ void BFormatDec::process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALsizei OutChan
            if(UNLIKELY(!(mEnabled&(1<<chan))))
                continue;

-            MixRowSamples(OutBuffer[chan], mMatrix.Single[chan], InSamples,
-                          mNumChannels, 0, SamplesToDo);
+            MixRowSamples(OutBuffer[chan].data(), mMatrix.Single[chan],
+                &reinterpret_cast<const ALfloat(&)[BUFFERSIZE]>(InSamples[0]), mNumChannels, 0,
+                SamplesToDo);
        }
    }
 }
@@ -43,8 +43,8 @@ public:
        const ALsizei (&chanmap)[MAX_OUTPUT_CHANNELS]);

    /* Decodes the ambisonic input to the given output channels. */
-    void process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALsizei OutChannels,
-        const ALfloat (*InSamples)[BUFFERSIZE], const ALsizei SamplesToDo);
+    void process(FloatBufferLine *OutBuffer, const ALsizei OutChannels,
+        const FloatBufferLine *InSamples, const ALsizei SamplesToDo);

    /* Retrieves per-order HF scaling factors for "upsampling" ambisonic data. */
    static std::array<ALfloat,MAX_AMBI_ORDER+1> GetHFOrderScales(const ALsizei in_order,
@@ -143,7 +143,7 @@ struct EffectTarget {
 struct EffectState {
    RefCount mRef{1u};

-    ALfloat (*mOutBuffer)[BUFFERSIZE]{nullptr};
+    FloatBufferLine *mOutBuffer{nullptr};
    ALsizei mOutChannels{0};


@@ -97,7 +97,7 @@ void ShiftSlidingHold(SlidingHold *Hold, const ALsizei n)
 /* Multichannel compression is linked via the absolute maximum of all
 * channels.
 */
-void LinkChannels(Compressor *Comp, const ALsizei SamplesToDo, const ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE])
+void LinkChannels(Compressor *Comp, const ALsizei SamplesToDo, const FloatBufferLine *OutBuffer)
 {
    const ALsizei index{Comp->mLookAhead};
    const ALsizei numChans{Comp->mNumChans};
@@ -109,9 +109,9 @@ void LinkChannels(Compressor *Comp, const ALsizei SamplesToDo, const ALfloat (*R
    auto side_begin = std::begin(Comp->mSideChain) + index;
    std::fill(side_begin, side_begin+SamplesToDo, 0.0f);

-    auto fill_max = [SamplesToDo,side_begin](const ALfloat *input) -> void
+    auto fill_max = [SamplesToDo,side_begin](const FloatBufferLine &input) -> void
    {
-        const ALfloat *RESTRICT buffer{al::assume_aligned<16>(input)};
+        const ALfloat *RESTRICT buffer{al::assume_aligned<16>(input.data())};
        auto max_abs = std::bind(maxf, _1, std::bind(static_cast<float(&)(float)>(std::fabs), _2));
        std::transform(side_begin, side_begin+SamplesToDo, buffer, side_begin, max_abs);
    };
@@ -293,7 +293,7 @@ void GainCompressor(Compressor *Comp, const ALsizei SamplesToDo)
 * reaching the offending impulse.  This is best used when operating as a
 * limiter.
 */
-void SignalDelay(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE])
+void SignalDelay(Compressor *Comp, const ALsizei SamplesToDo, FloatBufferLine *OutBuffer)
 {
    static constexpr ALsizei mask{BUFFERSIZE - 1};
    const ALsizei numChans{Comp->mNumChans};
@@ -305,7 +305,7 @@ void SignalDelay(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*RESTRICT

    for(ALsizei c{0};c < numChans;c++)
    {
-        ALfloat *RESTRICT inout{al::assume_aligned<16>(OutBuffer[c])};
+        ALfloat *RESTRICT inout{al::assume_aligned<16>(OutBuffer[c].data())};
        ALfloat *RESTRICT delay{al::assume_aligned<16>(Comp->mDelay[c])};
        for(ALsizei i{0};i < SamplesToDo;i++)
        {
@@ -425,7 +425,7 @@ Compressor::~Compressor()
 }


-void Compressor::process(const ALsizei SamplesToDo, ALfloat (*OutBuffer)[BUFFERSIZE])
+void Compressor::process(const ALsizei SamplesToDo, FloatBufferLine *OutBuffer)
 {
    const ALsizei numChans{mNumChans};

@@ -435,9 +435,9 @@ void Compressor::process(const ALsizei SamplesToDo, ALfloat (*OutBuffer)[BUFFERS
    const ALfloat preGain{mPreGain};
    if(preGain != 1.0f)
    {
-        auto apply_gain = [SamplesToDo,preGain](ALfloat *input) noexcept -> void
+        auto apply_gain = [SamplesToDo,preGain](FloatBufferLine &input) noexcept -> void
        {
-            ALfloat *buffer{al::assume_aligned<16>(input)};
+            ALfloat *buffer{al::assume_aligned<16>(input.data())};
            std::transform(buffer, buffer+SamplesToDo, buffer,
                std::bind(std::multiplies<float>{}, _1, preGain));
        };
@@ -460,9 +460,9 @@ void Compressor::process(const ALsizei SamplesToDo, ALfloat (*OutBuffer)[BUFFERS
        SignalDelay(this, SamplesToDo, OutBuffer);

    const ALfloat (&sideChain)[BUFFERSIZE*2] = mSideChain;
-    auto apply_comp = [SamplesToDo,&sideChain](ALfloat *input) noexcept -> void
+    auto apply_comp = [SamplesToDo,&sideChain](FloatBufferLine &input) noexcept -> void
    {
-        ALfloat *buffer{al::assume_aligned<16>(input)};
+        ALfloat *buffer{al::assume_aligned<16>(input.data())};
        const ALfloat *gains{al::assume_aligned<16>(&sideChain[0])};
        std::transform(gains, gains+SamplesToDo, buffer, buffer,
            std::bind(std::multiplies<float>{}, _1, _2));
@@ -6,7 +6,7 @@
 #include "AL/al.h"

 #include "almalloc.h"
-/* For BUFFERSIZE. */
+/* For FloatBufferLine/BUFFERSIZE. */
 #include "alMain.h"


@@ -65,7 +65,7 @@ struct Compressor {


    ~Compressor();
-    void process(const ALsizei SamplesToDo, ALfloat (*OutBuffer)[BUFFERSIZE]);
+    void process(const ALsizei SamplesToDo, FloatBufferLine *OutBuffer);
    ALsizei getLookAhead() const noexcept { return mLookAhead; }

    DEF_PLACE_NEWDEL()
@@ -744,10 +744,9 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc
                        hrtfparams.Gain = 0.0f;
                        hrtfparams.GainStep = gain / static_cast<ALfloat>(fademix);

-                        MixHrtfBlendSamples(
-                            voice->mDirect.Buffer[OutLIdx], voice->mDirect.Buffer[OutRIdx],
-                            HrtfSamples, AccumSamples, OutPos, IrSize, &parms.Hrtf.Old,
-                            &hrtfparams, fademix);
+                        MixHrtfBlendSamples(voice->mDirect.Buffer[OutLIdx].data(),
+                            voice->mDirect.Buffer[OutRIdx].data(), HrtfSamples, AccumSamples,
+                            OutPos, IrSize, &parms.Hrtf.Old, &hrtfparams, fademix);
                        /* Update the old parameters with the result. */
                        parms.Hrtf.Old = parms.Hrtf.Target;
                        if(fademix < Counter)
@@ -778,10 +777,9 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc
                        hrtfparams.Gain = parms.Hrtf.Old.Gain;
                        hrtfparams.GainStep = (gain - parms.Hrtf.Old.Gain) /
                            static_cast<ALfloat>(todo);
-                        MixHrtfSamples(
-                            voice->mDirect.Buffer[OutLIdx], voice->mDirect.Buffer[OutRIdx],
-                            HrtfSamples+fademix, AccumSamples+fademix, OutPos+fademix, IrSize,
-                            &hrtfparams, todo);
+                        MixHrtfSamples(voice->mDirect.Buffer[OutLIdx].data(),
+                            voice->mDirect.Buffer[OutRIdx].data(), HrtfSamples+fademix,
+                            AccumSamples+fademix, OutPos+fademix, IrSize, &hrtfparams, todo);
                        /* Store the interpolated gain or the final target gain
                         * depending if the fade is done.
                         */
@@ -803,8 +801,8 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc
                        SilentTarget : parms.Gains.Target};

                    MixSamples(samples, voice->mDirect.ChannelsPerOrder[0],
-                        voice->mDirect.Buffer, parms.Gains.Current, TargetGains, Counter,
-                        OutPos, DstBufferSize);
+                        &reinterpret_cast<float(&)[BUFFERSIZE]>(voice->mDirect.Buffer[0]),
+                        parms.Gains.Current, TargetGains, Counter, OutPos, DstBufferSize);

                    ALfloat (&nfcsamples)[BUFFERSIZE] = Device->NfcSampleData;
                    ALsizei chanoffset{voice->mDirect.ChannelsPerOrder[0]};
@@ -815,8 +813,9 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc
                            return;
                        (parms.NFCtrlFilter.*process)(nfcsamples, samples, DstBufferSize);
                        MixSamples(nfcsamples, voice->mDirect.ChannelsPerOrder[order],
-                            voice->mDirect.Buffer+chanoffset, parms.Gains.Current+chanoffset,
-                            TargetGains+chanoffset, Counter, OutPos, DstBufferSize);
+                            &reinterpret_cast<float(&)[BUFFERSIZE]>(voice->mDirect.Buffer[chanoffset]),
+                            parms.Gains.Current+chanoffset, TargetGains+chanoffset, Counter,
+                            OutPos, DstBufferSize);
                        chanoffset += voice->mDirect.ChannelsPerOrder[order];
                    };
                    apply_nfc(&NfcFilter::process1, 1);
@@ -827,7 +826,8 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc
                {
                    const ALfloat *TargetGains{UNLIKELY(vstate == ALvoice::Stopping) ?
                        SilentTarget : parms.Gains.Target};
-                    MixSamples(samples, voice->mDirect.Channels, voice->mDirect.Buffer,
+                    MixSamples(samples, voice->mDirect.Channels,
+                        &reinterpret_cast<float(&)[BUFFERSIZE]>(voice->mDirect.Buffer[0]),
                        parms.Gains.Current, TargetGains, Counter, OutPos, DstBufferSize);
                }
            }
@@ -844,7 +844,8 @@ void MixVoice(ALvoice *voice, ALvoice::State vstate, const ALuint SourceID, ALCc

                const ALfloat *TargetGains{UNLIKELY(vstate==ALvoice::Stopping) ? SilentTarget :
                    parms.Gains.Target};
-                MixSamples(samples, send.Channels, send.Buffer, parms.Gains.Current,
+                MixSamples(samples, send.Channels,
+                    &reinterpret_cast<float(&)[BUFFERSIZE]>(send.Buffer[0]), parms.Gains.Current,
                    TargetGains, Counter, OutPos, DstBufferSize);
            };
            std::for_each(voice->mSend.begin(), voice->mSend.end(), mix_send);
@@ -976,6 +976,6 @@ void aluInitEffectPanning(ALeffectslot *slot, ALCdevice *device)
        { return BFChannelConfig{1.0f, acn}; }
    );
    std::fill(iter, slot->Wet.AmbiMap.end(), BFChannelConfig{});
-    slot->Wet.Buffer = &reinterpret_cast<ALfloat(&)[BUFFERSIZE]>(slot->MixBuffer[0]);
+    slot->Wet.Buffer = slot->MixBuffer.data();
    slot->Wet.NumChannels = static_cast<ALsizei>(count);
 }
@@ -59,7 +59,7 @@ void allpass_process(AllPassState *state, ALfloat *dst, const ALfloat *src, cons
 * know which is the intended result.
 */

-void Uhj2Encoder::encode(ALfloat *LeftOut, ALfloat *RightOut, ALfloat (*InSamples)[BUFFERSIZE], const ALsizei SamplesToDo)
+void Uhj2Encoder::encode(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, FloatBufferLine *InSamples, const ALsizei SamplesToDo)
 {
    alignas(16) ALfloat D[MAX_UPDATE_SAMPLES], S[MAX_UPDATE_SAMPLES];
    alignas(16) ALfloat temp[MAX_UPDATE_SAMPLES];
@@ -72,7 +72,7 @@ void Uhj2Encoder::encode(ALfloat *LeftOut, ALfloat *RightOut, ALfloat (*InSample
        ASSUME(todo > 0);

        /* D = 0.6554516*Y */
-        const ALfloat *RESTRICT input{al::assume_aligned<16>(InSamples[2]+base)};
+        const ALfloat *RESTRICT input{al::assume_aligned<16>(InSamples[2].data()+base)};
        for(ALsizei i{0};i < todo;i++)
            temp[i] = 0.6554516f*input[i];
        allpass_process(&mFilter1_Y[0], temp, temp, Filter1CoeffSqr[0], todo);
@@ -89,8 +89,8 @@ void Uhj2Encoder::encode(ALfloat *LeftOut, ALfloat *RightOut, ALfloat (*InSample
        mLastY = temp[todo-1];

        /* D += j(-0.3420201*W + 0.5098604*X) */
-        const ALfloat *RESTRICT input0{al::assume_aligned<16>(InSamples[0]+base)};
-        const ALfloat *RESTRICT input1{al::assume_aligned<16>(InSamples[1]+base)};
+        const ALfloat *RESTRICT input0{al::assume_aligned<16>(InSamples[0].data()+base)};
+        const ALfloat *RESTRICT input1{al::assume_aligned<16>(InSamples[1].data()+base)};
        for(ALsizei i{0};i < todo;i++)
            temp[i] = -0.3420201f*input0[i] + 0.5098604f*input1[i];
        allpass_process(&mFilter2_WX[0], temp, temp, Filter2CoeffSqr[0], todo);
@@ -113,11 +113,11 @@ void Uhj2Encoder::encode(ALfloat *LeftOut, ALfloat *RightOut, ALfloat (*InSample
        mLastWX = temp[todo-1];

        /* Left = (S + D)/2.0 */
-        ALfloat *RESTRICT left = al::assume_aligned<16>(LeftOut+base);
+        ALfloat *RESTRICT left = al::assume_aligned<16>(LeftOut.data()+base);
        for(ALsizei i{0};i < todo;i++)
            left[i] += (S[i] + D[i]) * 0.5f;
        /* Right = (S - D)/2.0 */
-        ALfloat *RESTRICT right = al::assume_aligned<16>(RightOut+base);
+        ALfloat *RESTRICT right = al::assume_aligned<16>(RightOut.data()+base);
        for(ALsizei i{0};i < todo;i++)
            right[i] += (S[i] - D[i]) * 0.5f;

@@ -45,7 +45,8 @@ struct Uhj2Encoder {
    /* Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
     * signal. The input must use FuMa channel ordering and scaling.
     */
-    void encode(ALfloat *LeftOut, ALfloat *RightOut, ALfloat (*InSamples)[BUFFERSIZE], const ALsizei SamplesToDo);
+    void encode(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, FloatBufferLine *InSamples,
+        const ALsizei SamplesToDo);

    DEF_NEWDEL(Uhj2Encoder)
 };
@@ -71,7 +71,7 @@ struct ALeffectslot {
    ALuint id{};

    /* Mixing buffer used by the Wet mix. */
-    al::vector<std::array<ALfloat,BUFFERSIZE>,16> MixBuffer;
+    al::vector<FloatBufferLine, 16> MixBuffer;

    /* Wet buffer configuration is ACN channel order with N3D scaling.
     * Consequently, effects that only want to work with mono input can use
@@ -305,6 +305,8 @@ struct BFChannelConfig {
 */
 #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!
 */
@@ -315,14 +317,14 @@ struct MixParams {
    /* Coefficient channel mapping for mixing to the buffer. */
    std::array<BFChannelConfig,MAX_OUTPUT_CHANNELS> AmbiMap;

-    ALfloat (*Buffer)[BUFFERSIZE]{nullptr};
+    FloatBufferLine *Buffer{nullptr};
    ALsizei NumChannels{0};
 };

 struct RealMixParams {
    std::array<ALint,MaxChannels> ChannelIndex{};

-    ALfloat (*Buffer)[BUFFERSIZE]{nullptr};
+    FloatBufferLine *Buffer{nullptr};
    ALsizei NumChannels{0};
 };

@@ -405,7 +407,7 @@ struct ALCdevice {
    alignas(16) float2 HrtfAccumData[BUFFERSIZE + HRIR_LENGTH];

    /* Mixing buffer used by the Dry mix and Real output. */
-    al::vector<std::array<ALfloat,BUFFERSIZE>, 16> MixBuffer;
+    al::vector<FloatBufferLine, 16> MixBuffer;

    /* The "dry" path corresponds to the main output. */
    MixParams Dry;
@@ -263,7 +263,7 @@ struct ALvoice {
        int FilterType;
        DirectParams Params[MAX_INPUT_CHANNELS];

-        ALfloat (*Buffer)[BUFFERSIZE];
+        FloatBufferLine *Buffer;
        ALsizei Channels;
        ALsizei ChannelsPerOrder[MAX_AMBI_ORDER+1];
    } mDirect;
@@ -272,7 +272,7 @@ struct ALvoice {
        int FilterType;
        SendParams Params[MAX_INPUT_CHANNELS];

-        ALfloat (*Buffer)[BUFFERSIZE];
+        FloatBufferLine *Buffer;
        ALsizei Channels;
    };
    al::FlexArray<SendData> mSend;