Fix it

Author: kunitoki

modules/yup_dsp/filters/yup_LinkwitzRileyFilter.h

@@ -185,11 +185,11 @@ class LinkwitzRileyFilter
         for (int i = 0; i < numSamples; ++i)
         {
             processSample (inputLeft[i],
-                          inputRight[i],
-                          outputLowLeft[i],
-                          outputLowRight[i],
-                          outputHighLeft[i],
-                          outputHighRight[i]);
+                           inputRight[i],
+                           outputLowLeft[i],
+                           outputLowRight[i],
+                           outputHighLeft[i],
+                           outputHighRight[i]);
         }
     }
 
@@ -277,20 +277,23 @@ class LinkwitzRileyFilter
         // Apply coefficients to biquad stages
         for (int stage = 0; stage < numStages; ++stage)
         {
-            // Each stage gets two identical coefficients (cascade)
-            const auto& lowCoeff = lowCoeffs[stage * 2];     // Both cascades use same coeffs
-            const auto& highCoeff = highCoeffs[stage * 2];   // Both cascades use same coeffs
-
-            // Set coefficients for both cascades (identical for Linkwitz-Riley)
-            lowPassStage1.leftChannelStages[stage].setCoefficients (lowCoeff);
-            lowPassStage1.rightChannelStages[stage].setCoefficients (lowCoeff);
-            lowPassStage2.leftChannelStages[stage].setCoefficients (lowCoeff);
-            lowPassStage2.rightChannelStages[stage].setCoefficients (lowCoeff);
-
-            highPassStage1.leftChannelStages[stage].setCoefficients (highCoeff);
-            highPassStage1.rightChannelStages[stage].setCoefficients (highCoeff);
-            highPassStage2.leftChannelStages[stage].setCoefficients (highCoeff);
-            highPassStage2.rightChannelStages[stage].setCoefficients (highCoeff);
+            // Each cascade needs its own coefficients
+            const auto& lowCoeff1 = lowCoeffs[stage * 2];       // First cascade
+            const auto& lowCoeff2 = lowCoeffs[stage * 2 + 1];   // Second cascade
+            const auto& highCoeff1 = highCoeffs[stage * 2];     // First cascade
+            const auto& highCoeff2 = highCoeffs[stage * 2 + 1]; // Second cascade
+
+            // Set coefficients for first cascade
+            lowPassStage1.leftChannelStages[stage].setCoefficients (lowCoeff1);
+            lowPassStage1.rightChannelStages[stage].setCoefficients (lowCoeff1);
+            highPassStage1.leftChannelStages[stage].setCoefficients (highCoeff1);
+            highPassStage1.rightChannelStages[stage].setCoefficients (highCoeff1);
+
+            // Set coefficients for second cascade (different coefficients)
+            lowPassStage2.leftChannelStages[stage].setCoefficients (lowCoeff2);
+            lowPassStage2.rightChannelStages[stage].setCoefficients (lowCoeff2);
+            highPassStage2.leftChannelStages[stage].setCoefficients (highCoeff2);
+            highPassStage2.rightChannelStages[stage].setCoefficients (highCoeff2);
         }
     }
 
@@ -311,7 +314,7 @@ class LinkwitzRileyFilter
 
     //==============================================================================
     CoeffType frequency = static_cast<CoeffType> (1000.0);
-    double sampleRate = 44100.0;
+    double sampleRate = 0.0;
 
     FilterStage lowPassStage1, lowPassStage2;
     FilterStage highPassStage1, highPassStage2;

tests/yup_dsp/yup_LinkwitzRileyFilter.cpp

@@ -175,35 +175,48 @@ TEST_F (LinkwitzRileyFilterTests, LR8ProcessSampleDoesNotCrash)
 TEST_F (LinkwitzRileyFilterTests, ComplementaryResponse)
 {
     LinkwitzRiley2Filter<float> filter (1000.0);
+    filter.setSampleRate (sampleRate);
+    filter.reset();
 
-    // Test that low + high outputs sum to approximately unity at crossover frequency
+    // Now do the actual test
     float lowLeft, lowRight, highLeft, highRight;
-    float sumLeft = 0.0f, sumRight = 0.0f;
 
-    // Process sine wave at crossover frequency
+    // Let the filter settle by processing some samples first
+    for (int i = 0; i < blockSize; ++i)
+        filter.processSample (sineTestLeft[i], sineTestRight[i], lowLeft, lowRight, highLeft, highRight);
+
+    // Test that low + high outputs sum to approximately unity at crossover frequency
+    std::vector<float> summedLeft (blockSize);
+    std::vector<float> summedRight (blockSize);
+
+    // Process sine wave at crossover frequency (second pass for steady state)
     for (int i = 0; i < blockSize; ++i)
     {
         filter.processSample (sineTestLeft[i], sineTestRight[i], lowLeft, lowRight, highLeft, highRight);
-        sumLeft += (lowLeft + highLeft) * (lowLeft + highLeft);
-        sumRight += (lowRight + highRight) * (lowRight + highRight);
+        summedLeft[i] = lowLeft + highLeft;
+        summedRight[i] = lowRight + highRight;
     }
 
-    // RMS of sum should be close to RMS of input
+    // Calculate RMS of summed outputs
+    float sumRmsLeft = 0.0f, sumRmsRight = 0.0f;
     float inputRmsLeft = 0.0f, inputRmsRight = 0.0f;
+
     for (int i = 0; i < blockSize; ++i)
     {
+        sumRmsLeft += summedLeft[i] * summedLeft[i];
+        sumRmsRight += summedRight[i] * summedRight[i];
         inputRmsLeft += sineTestLeft[i] * sineTestLeft[i];
         inputRmsRight += sineTestRight[i] * sineTestRight[i];
     }
 
-    sumLeft = std::sqrt (sumLeft / blockSize);
-    sumRight = std::sqrt (sumRight / blockSize);
+    sumRmsLeft = std::sqrt (sumRmsLeft / blockSize);
+    sumRmsRight = std::sqrt (sumRmsRight / blockSize);
     inputRmsLeft = std::sqrt (inputRmsLeft / blockSize);
     inputRmsRight = std::sqrt (inputRmsRight / blockSize);
 
     // Allow for some tolerance due to filter transient and numerical precision
-    EXPECT_NEAR (sumLeft, inputRmsLeft, 0.1f);
-    EXPECT_NEAR (sumRight, inputRmsRight, 0.1f);
+    EXPECT_NEAR (sumRmsLeft, inputRmsLeft, 0.1f);
+    EXPECT_NEAR (sumRmsRight, inputRmsRight, 0.1f);
 }
 
 TEST_F (LinkwitzRileyFilterTests, ResetClearsState)