Simplify MixParams and AmbiUpsampler

Since the dry buffer is always an ambisonic target now

1 files changed, 29 insertions, 109 deletions

diff --git a/Alc/bformatdec.cpp b/Alc/bformatdec.cpp
index 84f18833..79d42ec5 100644
--- a/Alc/bformatdec.cpp
+++ b/Alc/bformatdec.cpp
@@ -24,41 +24,17 @@ namespace {
 static_assert(BFormatDec::sNumBands == 2, "Unexpected BFormatDec::sNumBands");
 static_assert(AmbiUpsampler::sNumBands == 2, "Unexpected AmbiUpsampler::sNumBands");
 
-/* These points are in AL coordinates! */
-constexpr ALfloat Ambi3DPoints[8][3] = {
-    { -0.577350269f,  0.577350269f, -0.577350269f },
-    {  0.577350269f,  0.577350269f, -0.577350269f },
-    { -0.577350269f,  0.577350269f,  0.577350269f },
-    {  0.577350269f,  0.577350269f,  0.577350269f },
-    { -0.577350269f, -0.577350269f, -0.577350269f },
-    {  0.577350269f, -0.577350269f, -0.577350269f },
-    { -0.577350269f, -0.577350269f,  0.577350269f },
-    {  0.577350269f, -0.577350269f,  0.577350269f },
+constexpr ALfloat Ambi3DDecoderHFScale[MAX_AMBI_ORDER+1] = {
+    2.00000000f, 1.15470054f
 };
-constexpr ALfloat Ambi3DDecoder[8][MAX_AMBI_COEFFS] = {
-    { 0.125f,  0.125f,  0.125f,  0.125f },
-    { 0.125f, -0.125f,  0.125f,  0.125f },
-    { 0.125f,  0.125f,  0.125f, -0.125f },
-    { 0.125f, -0.125f,  0.125f, -0.125f },
-    { 0.125f,  0.125f, -0.125f,  0.125f },
-    { 0.125f, -0.125f, -0.125f,  0.125f },
-    { 0.125f,  0.125f, -0.125f, -0.125f },
-    { 0.125f, -0.125f, -0.125f, -0.125f },
+constexpr ALfloat Ambi3DDecoderHFScale2O[MAX_AMBI_ORDER+1] = {
+    1.49071198f, 1.15470054f
 };
-constexpr ALfloat Ambi3DDecoderHFScale[MAX_AMBI_COEFFS] = {
-    2.0f,
-    1.15470054f, 1.15470054f, 1.15470054f
-};
-constexpr ALfloat Ambi3DDecoderHFScale2O[MAX_AMBI_COEFFS] = {
-    1.49071198f,
-    1.15470054f, 1.15470054f, 1.15470054f
-};
-constexpr ALfloat Ambi3DDecoderHFScale3O[MAX_AMBI_COEFFS] = {
-    1.17958441f,
-    1.01578297f, 1.01578297f, 1.01578297f
+constexpr ALfloat Ambi3DDecoderHFScale3O[MAX_AMBI_ORDER+1] = {
+    1.17958441f, 1.01578297f
 };
 
-inline auto GetDecoderHFScales(ALsizei order) noexcept -> const ALfloat(&)[MAX_AMBI_COEFFS]
+inline auto GetDecoderHFScales(ALsizei order) noexcept -> const ALfloat(&)[MAX_AMBI_ORDER+1]
 {
     if(order >= 3) return Ambi3DDecoderHFScale3O;
     if(order == 2) return Ambi3DDecoderHFScale2O;
@@ -105,7 +81,7 @@ void BFormatDec::reset(const AmbDecConf *conf, bool allow_2band, ALsizei inchans
         (conf->ChanMask > AMBI_2ORDER_MASK) ? 3 :
         (conf->ChanMask > AMBI_1ORDER_MASK) ? 2 : 1};
     {
-        const ALfloat (&hfscales)[MAX_AMBI_COEFFS] = GetDecoderHFScales(out_order);
+        const ALfloat (&hfscales)[MAX_AMBI_ORDER+1] = GetDecoderHFScales(out_order);
         /* The specified filter gain is for the mid-point/reference gain. The
          * gain at the shelf itself will be the square of that, so specify the
          * square-root of the desired shelf gain.
@@ -192,7 +168,7 @@ void BFormatDec::reset(ALsizei inchans, ALuint srate, ALsizei chancount, const C
         (inchans > 5) ? 3 :
         (inchans > 3) ? 2 : 1};
     {
-        const ALfloat (&hfscales)[MAX_AMBI_COEFFS] = GetDecoderHFScales(out_order);
+        const ALfloat (&hfscales)[MAX_AMBI_ORDER+1] = GetDecoderHFScales(out_order);
         /* The specified filter gain is for the mid-point/reference gain. The
          * gain at the shelf itself will be the square of that, so specify the
          * square-root of the desired shelf gain.
@@ -208,7 +184,7 @@ void BFormatDec::reset(ALsizei inchans, ALuint srate, ALsizei chancount, const C
             mUpSampler[i].Shelf.copyParamsFrom(mUpSampler[1].Shelf);
     }
 
-    for(size_t i{0u};i < chancount;i++)
+    for(ALsizei i{0};i < chancount;i++)
     {
         const ALfloat (&coeffs)[MAX_AMBI_COEFFS] = chancoeffs[chanmap[i]];
         ALfloat (&mtx)[MAX_AMBI_COEFFS] = mMatrix.Single[chanmap[i]];
@@ -281,88 +257,32 @@ void BFormatDec::upSample(ALfloat (*OutBuffer)[BUFFERSIZE], const ALfloat (*InSa
 }
 
 
-void AmbiUpsampler::reset(const ALCdevice *device)
+void AmbiUpsampler::reset(const ALsizei out_order, const ALfloat xover_norm)
 {
-    const ALfloat xover_norm{400.0f / (float)device->Frequency};
-
-    mSimpleUp = (device->Dry.CoeffCount == 0);
-    if(mSimpleUp)
-    {
-        const ALfloat (&hfscales)[MAX_AMBI_COEFFS] = GetDecoderHFScales(
-            (device->Dry.NumChannels > 16) ? 4 :
-            (device->Dry.NumChannels >  9) ? 3 :
-            (device->Dry.NumChannels >  4) ? 2 : 1);
-        const ALfloat gain0{std::sqrt(Ambi3DDecoderHFScale[0] / hfscales[0])};
-        const ALfloat gain1{std::sqrt(Ambi3DDecoderHFScale[1] / hfscales[1])};
-
-        mShelf[0].setParams(BiquadType::HighShelf, gain0, xover_norm,
-            calc_rcpQ_from_slope(gain0, 1.0f));
-        mShelf[1].setParams(BiquadType::HighShelf, gain1, xover_norm,
-            calc_rcpQ_from_slope(gain1, 1.0f));
-        for(ALsizei i{2};i < 4;i++)
-            mShelf[i].copyParamsFrom(mShelf[1]);
-    }
-    else
-    {
-        mInput[0].XOver.init(xover_norm);
-        for(auto input = std::begin(mInput)+1;input != std::end(mInput);++input)
-            input->XOver = mInput[0].XOver;
-
-        ALfloat encgains[8][MAX_OUTPUT_CHANNELS];
-        for(size_t k{0u};k < COUNTOF(Ambi3DPoints);k++)
-        {
-            ALfloat coeffs[MAX_AMBI_COEFFS];
-            CalcDirectionCoeffs(Ambi3DPoints[k], 0.0f, coeffs);
-            ComputePanGains(&device->Dry, coeffs, 1.0f, encgains[k]);
-        }
-
-        /* Combine the matrices that do the in->virt and virt->out conversions
-         * so we get a single in->out conversion. NOTE: the Encoder matrix
-         * (encgains) and output are transposed, so the input channels line up
-         * with the rows and the output channels line up with the columns.
-         */
-        const ALfloat (&hfscales)[MAX_AMBI_COEFFS] = GetDecoderHFScales(
-            (device->Dry.CoeffCount > 16) ? 4 :
-            (device->Dry.CoeffCount >  9) ? 3 :
-            (device->Dry.CoeffCount >  4) ? 2 : 1);
-        for(ALsizei i{0};i < 4;i++)
-        {
-            mInput[i].Gains.fill({});
-            const ALdouble hfscale = static_cast<ALdouble>(Ambi3DDecoderHFScale[i]) / hfscales[i];
-            for(ALsizei j{0};j < device->Dry.NumChannels;j++)
-            {
-                ALdouble gain{0.0};
-                for(size_t k{0u};k < COUNTOF(Ambi3DDecoder);k++)
-                    gain += (ALdouble)Ambi3DDecoder[k][i] * encgains[k][j];
-                mInput[i].Gains[HF_BAND][j] = (ALfloat)(gain * hfscale);
-                mInput[i].Gains[LF_BAND][j] = (ALfloat)gain;
-            }
-        }
-    }
+    const ALfloat (&hfscales)[MAX_AMBI_ORDER+1] = GetDecoderHFScales(out_order);
+    const ALfloat gain0{std::sqrt(Ambi3DDecoderHFScale[0] / hfscales[0])};
+    const ALfloat gain1{std::sqrt(Ambi3DDecoderHFScale[1] / hfscales[1])};
+
+    mShelf[0].setParams(BiquadType::HighShelf, gain0, xover_norm,
+        calc_rcpQ_from_slope(gain0, 1.0f));
+    mShelf[1].setParams(BiquadType::HighShelf, gain1, xover_norm,
+        calc_rcpQ_from_slope(gain1, 1.0f));
+    for(ALsizei i{2};i < 4;i++)
+        mShelf[i].copyParamsFrom(mShelf[1]);
 }
 
-void AmbiUpsampler::process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALsizei OutChannels, const ALfloat (*InSamples)[BUFFERSIZE], const ALsizei SamplesToDo)
+void AmbiUpsampler::process(ALfloat (*OutBuffer)[BUFFERSIZE], const ALfloat (*InSamples)[BUFFERSIZE], const ALsizei InChannels, const ALsizei SamplesToDo)
 {
     ASSUME(SamplesToDo > 0);
+    ASSUME(InChannels > 0);
+    ASSUME(InChannels <= 4);
 
-    if(mSimpleUp)
-    {
-        for(ALsizei i{0};i < 4;i++)
-        {
-            mShelf[i].process(mSamples[0], InSamples[i], SamplesToDo);
-
-            const ALfloat *RESTRICT src{al::assume_aligned<16>(mSamples[0])};
-            ALfloat *dst{al::assume_aligned<16>(OutBuffer[i])};
-            std::transform(src, src+SamplesToDo, dst, dst, std::plus<float>{});
-        }
-    }
-    else for(auto input = std::begin(mInput);input != std::end(mInput);++input)
+    for(ALsizei i{0};i < InChannels;i++)
     {
-        input->XOver.process(mSamples[HF_BAND], mSamples[LF_BAND], *(InSamples++), SamplesToDo);
+        mShelf[i].process(mSamples[0], InSamples[i], SamplesToDo);
 
-        MixSamples(mSamples[HF_BAND], OutChannels, OutBuffer, input->Gains[HF_BAND].data(),
-            input->Gains[HF_BAND].data(), 0, 0, SamplesToDo);
-        MixSamples(mSamples[LF_BAND], OutChannels, OutBuffer, input->Gains[LF_BAND].data(),
-            input->Gains[LF_BAND].data(), 0, 0, SamplesToDo);
+        const ALfloat *RESTRICT src{al::assume_aligned<16>(mSamples[0])};
+        ALfloat *dst{al::assume_aligned<16>(OutBuffer[i])};
+        std::transform(src, src+SamplesToDo, dst, dst, std::plus<float>{});
     }
 }