react-native-audio-api 0.10.0-nightly-2d11b56-20251021 → 0.10.0-nightly-75aa9d0-20251022

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -67,7 +67,7 @@ JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
                                   .getArrayBuffer(runtime);
   auto frequencyArray =
       reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
-  auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
+  auto length = static_cast<size_t>(arrayBufferFrequency.size(runtime));
 
   auto arrayBufferMag = args[1]
                             .getObject(runtime)

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -1,3 +1,31 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
 #include <audioapi/utils/AudioArray.h>
@@ -13,14 +41,14 @@ BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
   frequencyParam_ = std::make_shared<AudioParam>(
       350.0, 0.0f, context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
-      0.0,
+      0.0f,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
       1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
       context);
   QParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+      1.0f, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   gainParam_ = std::make_shared<AudioParam>(
-      0.0,
+      0.0f,
       MOST_NEGATIVE_SINGLE_FLOAT,
       40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT,
       context);
@@ -76,27 +104,35 @@ void BiquadFilterNode::getFrequencyResponse(
     const float *frequencyArray,
     float *magResponseOutput,
     float *phaseResponseOutput,
-    const int length) {
+    const size_t length) {
+#ifndef AUDIO_API_TEST_SUITE
   applyFilter();
+#endif
 
-  // Local copies for micro-optimization
-  float b0 = b0_;
-  float b1 = b1_;
-  float b2 = b2_;
-  float a1 = a1_;
-  float a2 = a2_;
+  // Use double precision for later calculations
+  double b0 = static_cast<double>(b0_);
+  double b1 = static_cast<double>(b1_);
+  double b2 = static_cast<double>(b2_);
+  double a1 = static_cast<double>(a1_);
+  double a2 = static_cast<double>(a2_);
+
+  float nyquist = context_->getNyquistFrequency();
 
   for (size_t i = 0; i < length; i++) {
-    if (frequencyArray[i] < 0.0 || frequencyArray[i] > 1.0) {
+    // Convert from frequency in Hz to normalized frequency [0, 1]
+    float normalizedFreq = frequencyArray[i] / nyquist;
+
+    if (normalizedFreq < 0.0f || normalizedFreq > 1.0f) {
+      // Out-of-bounds frequencies should return NaN.
       magResponseOutput[i] = std::nanf("");
       phaseResponseOutput[i] = std::nanf("");
       continue;
     }
 
-    auto omega = -PI * frequencyArray[i] / context_->getNyquistFrequency();
-    auto z = std::complex<float>(cos(omega), sin(omega));
+    double omega = -PI * normalizedFreq;
+    auto z = std::complex<double>(std::cos(omega), std::sin(omega));
     auto response = (b0 + (b1 + b2 * z) * z) /
-        (std::complex<float>(1, 0) + (a1 + a2 * z) * z);
+        (std::complex<double>(1, 0) + (a1 + a2 * z) * z);
     magResponseOutput[i] = static_cast<float>(std::abs(response));
     phaseResponseOutput[i] =
         static_cast<float>(atan2(imag(response), real(response)));
@@ -120,17 +156,16 @@ void BiquadFilterNode::setNormalizedCoefficients(
 
 void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
   // Limit frequency to [0, 1] range
-  if (frequency >= 1.0) {
+  if (frequency >= 1.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (frequency <= 0.0) {
+  if (frequency <= 0.0f) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
 
   float theta = PI * frequency;
@@ -143,16 +178,15 @@ void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
-  if (frequency >= 1.0) {
+  if (frequency >= 1.0f) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
-  if (frequency <= 0.0) {
+  if (frequency <= 0.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
 
   float theta = PI * frequency;
@@ -166,13 +200,13 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
 
 void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
   // Limit frequency to [0, 1] range
-  if (frequency <= 0.0 || frequency >= 1.0) {
+  if (frequency <= 0.0f || frequency >= 1.0f) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
   // Limit Q to positive values
-  if (Q <= 0.0) {
+  if (Q <= 0.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -188,12 +222,12 @@ void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
 void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
   float A = std::pow(10.0f, gain / 40.0f);
 
-  if (frequency >= 1.0) {
+  if (frequency >= 1.0f) {
     setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (frequency <= 0.0) {
+  if (frequency <= 0.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -215,12 +249,12 @@ void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
 void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
   float A = std::pow(10.0f, gain / 40.0f);
 
-  if (frequency >= 1.0) {
+  if (frequency >= 1.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (frequency <= 0.0) {
+  if (frequency <= 0.0f) {
     setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -247,12 +281,12 @@ void BiquadFilterNode::setPeakingCoefficients(
     float gain) {
   float A = std::pow(10.0f, gain / 40.0f);
 
-  if (frequency <= 0.0 || frequency >= 1.0) {
+  if (frequency <= 0.0f || frequency >= 1.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (Q <= 0.0) {
+  if (Q <= 0.0f) {
     setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -271,12 +305,12 @@ void BiquadFilterNode::setPeakingCoefficients(
 }
 
 void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
-  if (frequency <= 0.0 || frequency >= 1.0) {
+  if (frequency <= 0.0f || frequency >= 1.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (Q <= 0.0) {
+  if (Q <= 0.0f) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -290,12 +324,12 @@ void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
-  if (frequency <= 0.0 || frequency >= 1.0) {
+  if (frequency <= 0.0f || frequency >= 1.0f) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
-  if (Q <= 0.0) {
+  if (Q <= 0.0f) {
     setNormalizedCoefficients(-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -318,6 +352,9 @@ void BiquadFilterNode::applyFilter() {
   auto Q = QParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   auto gain = gainParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
 
+  // NyquistFrequency is half of the sample rate.
+  // Normalized frequency is therefore:
+  // frequency / (sampleRate / 2) = (2 * frequency) / sampleRate
   float normalizedFrequency = frequency / context_->getNyquistFrequency();
   if (detune != 0.0f) {
     normalizedFrequency *= std::pow(2.0f, detune / 1200.0f);

package/common/cpp/audioapi/core/effects/BiquadFilterNode.h

@@ -1,8 +1,39 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #pragma once
 
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/types/BiquadFilterType.h>
+#ifdef AUDIO_API_TEST_SUITE
+#include <gtest/gtest_prod.h>
+#endif
 
 #include <algorithm>
 #include <cmath>
@@ -17,6 +48,11 @@ namespace audioapi {
 class AudioBus;
 
 class BiquadFilterNode : public AudioNode {
+#ifdef AUDIO_API_TEST_SUITE
+  friend class BiquadFilterTest;
+  FRIEND_TEST(BiquadFilterTest, GetFrequencyResponse);
+#endif
+
  public:
   explicit BiquadFilterNode(BaseAudioContext *context);
 
@@ -30,7 +66,7 @@ class BiquadFilterNode : public AudioNode {
       const float *frequencyArray,
       float *magResponseOutput,
       float *phaseResponseOutput,
-      int length);
+      size_t length);
 
  protected:
   std::shared_ptr<AudioBus> processNode(

package/common/cpp/audioapi/core/utils/Constants.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <numbers>
 #include <cmath>
 #include <limits>
 
@@ -19,7 +20,7 @@ static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
-static constexpr float PI = static_cast<float>(M_PI);
+static constexpr float PI = std::numbers::pi_v<float>;
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -277,8 +277,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
 
   constexpr size_t buffer_size = 4096;
-  auto io_buffer = std::unique_ptr<uint8_t, decltype(&av_free)>(
-      static_cast<uint8_t *>(av_malloc(buffer_size)), &av_free);
+  uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
   if (io_buffer == nullptr) {
     return nullptr;
   }
@@ -286,7 +285,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   auto avio_ctx =
       std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
           avio_alloc_context(
-              io_buffer.get(),
+              io_buffer,
               buffer_size,
               0,
               &io_ctx,

package/common/cpp/test/CMakeLists.txt

@@ -12,6 +12,7 @@ FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/3983f67e32fb3e9294487b9d4f9586efa6e5d088.zip
 )
+
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
@@ -57,6 +58,8 @@ target_include_directories(rnaudioapi PUBLIC
   ${JSI_DIR}
   "${REACT_NATIVE_DIR}/ReactCommon"
   "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  ${gtest_SOURCE_DIR}/include
+  ${gmock_SOURCE_DIR}/include
 )
 
 target_include_directories(rnaudioapi_libs PUBLIC

package/common/cpp/test/src/biquad/BiquadFilterChromium.cpp

@@ -0,0 +1,389 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <assert.h>
+#include <audioapi/core/utils/Constants.h>
+#include <test/src/biquad/BiquadFilterChromium.h>
+#include <algorithm>
+#include <cmath>
+#include <complex>
+#include <span>
+#include <vector>
+
+namespace audioapi {
+
+// Compute 10^x = exp(x*log(10))
+static double pow10(double x) {
+  return std::exp(x * 2.30258509299404568402);
+}
+
+void getFrequencyResponse(
+    const BiquadCoefficients &coeffs,
+    std::span<const float> frequency,
+    std::span<float> mag_response,
+    std::span<float> phase_response,
+    float nyquistFrequency) {
+  assert(!frequency.empty());
+  assert(!mag_response.empty());
+  assert(!phase_response.empty());
+
+  std::vector<float> normalizedFreq(frequency.size());
+  for (size_t i = 0; i < frequency.size(); ++i) {
+    normalizedFreq[i] = frequency[i] / nyquistFrequency;
+  }
+
+  // Evaluate the Z-transform of the filter at given normalized
+  // frequency from 0 to 1.  (1 corresponds to the Nyquist
+  // frequency.)
+  //
+  // The z-transform of the filter is
+  //
+  // H(z) = (b0 + b1*z^(-1) + b2*z^(-2))/(1 + a1*z^(-1) + a2*z^(-2))
+  //
+  // Evaluate as
+  //
+  // b0 + (b1 + b2*z1)*z1
+  // --------------------
+  // 1 + (a1 + a2*z1)*z1
+  //
+  // with z1 = 1/z and z = exp(j*pi*frequency). Hence z1 = exp(-j*pi*frequency)
+
+  double b0 = coeffs.b0;
+  double b1 = coeffs.b1;
+  double b2 = coeffs.b2;
+  double a1 = coeffs.a1;
+  double a2 = coeffs.a2;
+
+  for (size_t k = 0; k < normalizedFreq.size(); ++k) {
+    if (normalizedFreq[k] < 0.0 || normalizedFreq[k] > 1.0) {
+      // Out-of-bounds frequencies should return NaN.
+      mag_response[k] = std::nanf("");
+      phase_response[k] = std::nanf("");
+    } else {
+      double omega = -PI * normalizedFreq[k];
+      std::complex<double> z =
+          std::complex<double>(std::cos(omega), std::sin(omega));
+      std::complex<double> numerator = b0 + (b1 + b2 * z) * z;
+      std::complex<double> denominator =
+          std::complex<double>(1, 0) + (a1 + a2 * z) * z;
+      std::complex<double> response = numerator / denominator;
+      mag_response[k] = static_cast<float>(abs(response));
+      phase_response[k] =
+          static_cast<float>(std::atan2(imag(response), real(response)));
+    }
+  }
+}
+
+BiquadCoefficients normalizeCoefficients(
+    double b0,
+    double b1,
+    double b2,
+    double a0,
+    double a1,
+    double a2) {
+  return BiquadCoefficients{b0 / a0, b1 / a0, b2 / a0, a1 / a0, a2 / a0};
+}
+
+BiquadCoefficients calculateLowpassCoefficients(
+    double cutoff,
+    double resonance) {
+  // Limit cutoff to 0 to 1.
+  cutoff = std::clamp(cutoff, 0.0, 1.0);
+
+  if (cutoff == 1) {
+    // When cutoff is 1, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  } else if (cutoff > 0) {
+    // Compute biquad coefficients for lowpass filter
+
+    resonance = pow10(resonance / 20);
+
+    double theta = kPiDouble * cutoff;
+    double alpha = std::sin(theta) / (2 * resonance);
+    double cosw = std::cos(theta);
+    double beta = (1 - cosw) / 2;
+
+    double b0 = beta;
+    double b1 = 2 * beta;
+    double b2 = beta;
+
+    double a0 = 1 + alpha;
+    double a1 = -2 * cosw;
+    double a2 = 1 - alpha;
+
+    return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    // When cutoff is zero, nothing gets through the filter, so set
+    // coefficients up correctly.
+    return normalizeCoefficients(0, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateHighpassCoefficients(
+    double cutoff,
+    double resonance) {
+  // Limit cutoff to 0 to 1.
+  cutoff = std::clamp(cutoff, 0.0, 1.0);
+
+  if (cutoff == 1) {
+    // The z-transform is 0.
+    return normalizeCoefficients(0, 0, 0, 1, 0, 0);
+  } else if (cutoff > 0) {
+    // Compute biquad coefficients for highpass filter
+
+    resonance = pow10(resonance / 20);
+    double theta = kPiDouble * cutoff;
+    double alpha = std::sin(theta) / (2 * resonance);
+    double cosw = std::cos(theta);
+    double beta = (1 + cosw) / 2;
+
+    double b0 = beta;
+    double b1 = -2 * beta;
+    double b2 = beta;
+
+    double a0 = 1 + alpha;
+    double a1 = -2 * cosw;
+    double a2 = 1 - alpha;
+
+    return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    // When cutoff is zero, we need to be careful because the above
+    // gives a quadratic divided by the same quadratic, with poles
+    // and zeros on the unit circle in the same place. When cutoff
+    // is zero, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateLowshelfCoefficients(
+    double frequency,
+    double db_gain) {
+  // Clip frequencies to between 0 and 1, inclusive.
+  frequency = std::clamp(frequency, 0.0, 1.0);
+
+  double a = pow10(db_gain / 40);
+
+  if (frequency == 1) {
+    // The z-transform is a constant gain.
+    return normalizeCoefficients(a * a, 0, 0, 1, 0, 0);
+  } else if (frequency > 0) {
+    double w0 = kPiDouble * frequency;
+    double s = 1; // filter slope (1 is max value)
+    double alpha = 0.5 * std::sin(w0) * sqrt((a + 1 / a) * (1 / s - 1) + 2);
+    double k = std::cos(w0);
+    double k2 = 2 * sqrt(a) * alpha;
+    double a_plus_one = a + 1;
+    double a_minus_one = a - 1;
+
+    double b0 = a * (a_plus_one - a_minus_one * k + k2);
+    double b1 = 2 * a * (a_minus_one - a_plus_one * k);
+    double b2 = a * (a_plus_one - a_minus_one * k - k2);
+    double a0 = a_plus_one + a_minus_one * k + k2;
+    double a1 = -2 * (a_minus_one + a_plus_one * k);
+    double a2 = a_plus_one + a_minus_one * k - k2;
+
+    return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    // When frequency is 0, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateHighshelfCoefficients(
+    double frequency,
+    double db_gain) {
+  // Clip frequencies to between 0 and 1, inclusive.
+  frequency = std::clamp(frequency, 0.0, 1.0);
+
+  double a = pow10(db_gain / 40);
+
+  if (frequency == 1) {
+    // The z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  } else if (frequency > 0) {
+    double w0 = kPiDouble * frequency;
+    double s = 1; // filter slope (1 is max value)
+    double alpha = 0.5 * std::sin(w0) * sqrt((a + 1 / a) * (1 / s - 1) + 2);
+    double k = std::cos(w0);
+    double k2 = 2 * sqrt(a) * alpha;
+    double a_plus_one = a + 1;
+    double a_minus_one = a - 1;
+
+    double b0 = a * (a_plus_one + a_minus_one * k + k2);
+    double b1 = -2 * a * (a_minus_one + a_plus_one * k);
+    double b2 = a * (a_plus_one + a_minus_one * k - k2);
+    double a0 = a_plus_one - a_minus_one * k + k2;
+    double a1 = 2 * (a_minus_one - a_plus_one * k);
+    double a2 = a_plus_one - a_minus_one * k - k2;
+
+    return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    // When frequency = 0, the filter is just a gain, A^2.
+    return normalizeCoefficients(a * a, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients
+calculatePeakingCoefficients(double frequency, double q, double db_gain) {
+  // Clip frequencies to between 0 and 1, inclusive.
+  frequency = std::clamp(frequency, 0.0, 1.0);
+
+  // Don't let Q go negative, which causes an unstable filter.
+  q = std::max(0.0, q);
+
+  double a = pow10(db_gain / 40);
+
+  if (frequency > 0 && frequency < 1) {
+    if (q > 0) {
+      double w0 = kPiDouble * frequency;
+      double alpha = std::sin(w0) / (2 * q);
+      double k = std::cos(w0);
+
+      double b0 = 1 + alpha * a;
+      double b1 = -2 * k;
+      double b2 = 1 - alpha * a;
+      double a0 = 1 + alpha / a;
+      double a1 = -2 * k;
+      double a2 = 1 - alpha / a;
+
+      return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // When Q = 0, the above formulas have problems. If we look at
+      // the z-transform, we can see that the limit as Q->0 is A^2, so
+      // set the filter that way.
+      return normalizeCoefficients(a * a, 0, 0, 1, 0, 0);
+    }
+  } else {
+    // When frequency is 0 or 1, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateAllpassCoefficients(double frequency, double q) {
+  // Clip frequencies to between 0 and 1, inclusive.
+  frequency = std::clamp(frequency, 0.0, 1.0);
+
+  // Don't let Q go negative, which causes an unstable filter.
+  q = std::max(0.0, q);
+
+  if (frequency > 0 && frequency < 1) {
+    if (q > 0) {
+      double w0 = kPiDouble * frequency;
+      double alpha = std::sin(w0) / (2 * q);
+      double k = std::cos(w0);
+
+      double b0 = 1 - alpha;
+      double b1 = -2 * k;
+      double b2 = 1 + alpha;
+      double a0 = 1 + alpha;
+      double a1 = -2 * k;
+      double a2 = 1 - alpha;
+
+      return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // When Q = 0, the above formulas have problems. If we look at
+      // the z-transform, we can see that the limit as Q->0 is -1, so
+      // set the filter that way.
+      return normalizeCoefficients(-1, 0, 0, 1, 0, 0);
+    }
+  } else {
+    // When frequency is 0 or 1, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateNotchCoefficients(double frequency, double q) {
+  // Clip frequencies to between 0 and 1, inclusive.
+  frequency = std::clamp(frequency, 0.0, 1.0);
+
+  // Don't let Q go negative, which causes an unstable filter.
+  q = std::max(0.0, q);
+
+  if (frequency > 0 && frequency < 1) {
+    if (q > 0) {
+      double w0 = kPiDouble * frequency;
+      double alpha = std::sin(w0) / (2 * q);
+      double k = std::cos(w0);
+
+      double b0 = 1;
+      double b1 = -2 * k;
+      double b2 = 1;
+      double a0 = 1 + alpha;
+      double a1 = -2 * k;
+      double a2 = 1 - alpha;
+
+      return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // When Q = 0, the above formulas have problems. If we look at
+      // the z-transform, we can see that the limit as Q->0 is 0, so
+      // set the filter that way.
+      return normalizeCoefficients(0, 0, 0, 1, 0, 0);
+    }
+  } else {
+    // When frequency is 0 or 1, the z-transform is 1.
+    return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+  }
+}
+
+BiquadCoefficients calculateBandpassCoefficients(double frequency, double q) {
+  // No negative frequencies allowed.
+  frequency = std::max(0.0, frequency);
+
+  // Don't let Q go negative, which causes an unstable filter.
+  q = std::max(0.0, q);
+
+  if (frequency > 0 && frequency < 1) {
+    double w0 = kPiDouble * frequency;
+    if (q > 0) {
+      double alpha = std::sin(w0) / (2 * q);
+      double k = std::cos(w0);
+
+      double b0 = alpha;
+      double b1 = 0;
+      double b2 = -alpha;
+      double a0 = 1 + alpha;
+      double a1 = -2 * k;
+      double a2 = 1 - alpha;
+
+      return normalizeCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // When Q = 0, the above formulas have problems. If we look at
+      // the z-transform, we can see that the limit as Q->0 is 1, so
+      // set the filter that way.
+      return normalizeCoefficients(1, 0, 0, 1, 0, 0);
+    }
+  } else {
+    // When the cutoff is zero, the z-transform approaches 0, if Q
+    // > 0. When both Q and cutoff are zero, the z-transform is
+    // pretty much undefined. What should we do in this case?
+    // For now, just make the filter 0. When the cutoff is 1, the
+    // z-transform also approaches 0.
+    return normalizeCoefficients(0, 0, 0, 1, 0, 0);
+  }
+}
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterChromium.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <numbers>
+#include <span>
+
+namespace audioapi {
+
+constexpr double kPiDouble = std::numbers::pi_v<double>;
+
+struct BiquadCoefficients {
+  double b0;
+  double b1;
+  double b2;
+  double a1;
+  double a2;
+};
+
+void getFrequencyResponse(
+const BiquadCoefficients &coeffs,
+std::span<const float> frequency,
+std::span<float> mag_response,
+std::span<float> phase_response,
+float nyquistFrequency);
+
+BiquadCoefficients normalizeCoefficients(double b0, double b1, double b2, double a0, double a1, double a2);
+
+BiquadCoefficients calculateLowpassCoefficients(double cutoff, double Q);
+BiquadCoefficients calculateHighpassCoefficients(double cutoff, double Q);
+BiquadCoefficients calculateBandpassCoefficients(double frequency, double Q);
+BiquadCoefficients calculateNotchCoefficients(double frequency, double Q);
+BiquadCoefficients calculateAllpassCoefficients(double frequency, double Q);
+BiquadCoefficients calculatePeakingCoefficients(double frequency, double Q, double db_gain);
+BiquadCoefficients calculateLowshelfCoefficients(double frequency, double db_gain);
+BiquadCoefficients calculateHighshelfCoefficients(double frequency, double db_gain);
+
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterTest.cpp

@@ -0,0 +1,284 @@
+#include <test/src/biquad/BiquadFilterChromium.h>
+#include <test/src/biquad/BiquadFilterTest.h>
+
+namespace audioapi {
+
+void BiquadFilterTest::expectCoefficientsNear(
+    const std::shared_ptr<BiquadFilterNode> &biquadNode,
+    const BiquadCoefficients &expected) {
+  EXPECT_NEAR(biquadNode->b0_, expected.b0, tolerance);
+  EXPECT_NEAR(biquadNode->b1_, expected.b1, tolerance);
+  EXPECT_NEAR(biquadNode->b2_, expected.b2, tolerance);
+  EXPECT_NEAR(biquadNode->a1_, expected.a1, tolerance);
+  EXPECT_NEAR(biquadNode->a2_, expected.a2, tolerance);
+}
+
+void BiquadFilterTest::testLowpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateLowpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testHighpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateHighpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testBandpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setBandpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateBandpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testNotch(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setNotchCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateNotchCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testAllpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setAllpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateAllpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setPeakingCoefficients(normalizedFrequency, Q, gain);
+  expectCoefficientsNear(
+      node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
+}
+
+void BiquadFilterTest::testLowshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateLowshelfCoefficients(normalizedFrequency, gain));
+}
+
+void BiquadFilterTest::testHighshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateHighshelfCoefficients(normalizedFrequency, gain));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Frequencies,
+    BiquadFilterFrequencyTest,
+    ::testing::Values(
+        0.0f, // 0 Hz - the filter should block all input signal
+        10.0f, // very low frequency
+        350.0f, // default
+        nyquistFrequency - 0.0001f, // frequency near Nyquist
+        nyquistFrequency)); // maximal frequency
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestLowpassHighpass,
+    ::testing::Values(
+        -770.63678f, // min value for lowpass and highpass
+        0.0f, // default
+        770.63678f)); // max value for lowpass and highpass
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestRestTypes, // bandpass, notch, allpass, peaking
+    ::testing::Values(
+        0.0f, // default and min value
+        MOST_POSITIVE_SINGLE_FLOAT));
+
+INSTANTIATE_TEST_SUITE_P(
+    GainEdgeCases,
+    BiquadFilterGainTest,
+    ::testing::Values(
+        -40.0f,
+        0.0f, // default
+        40.0f));
+
+TEST_P(BiquadFilterFrequencyTest, SetLowpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetBandpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetNotchCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetAllpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetPeakingCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetLowshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testHighshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetLowpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetHighpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetBandpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetNotchCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetAllpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float gain = GetParam();
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetLowshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testHighshelf(frequency, gain);
+}
+
+TEST_F(BiquadFilterTest, GetFrequencyResponse) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
+
+  std::vector<float> TestFrequencies = {
+      -0.0001f,
+      0.0f,
+      0.0001f,
+      0.25f * nyquistFrequency,
+      0.5f * nyquistFrequency,
+      0.75f * nyquistFrequency,
+      nyquistFrequency - 0.0001f,
+      nyquistFrequency,
+      nyquistFrequency + 0.0001f};
+
+  std::vector<float> magResponseNode(TestFrequencies.size());
+  std::vector<float> phaseResponseNode(TestFrequencies.size());
+  std::vector<float> magResponseExpected(TestFrequencies.size());
+  std::vector<float> phaseResponseExpected(TestFrequencies.size());
+
+  node->getFrequencyResponse(
+      TestFrequencies.data(),
+      magResponseNode.data(),
+      phaseResponseNode.data(),
+      TestFrequencies.size());
+  getFrequencyResponse(
+      coeffs,
+      TestFrequencies,
+      magResponseExpected,
+      phaseResponseExpected,
+      nyquistFrequency);
+
+  for (size_t i = 0; i < TestFrequencies.size(); ++i) {
+    float f = TestFrequencies[i];
+    if (std::isnan(magResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(magResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
+          << "Magnitude mismatch at " << f << " Hz";
+    }
+
+    if (std::isnan(phaseResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
+          << "Phase mismatch at " << f << " Hz";
+    }
+  }
+}
+
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+static constexpr int sampleRate = 44100;
+static constexpr float nyquistFrequency = sampleRate / 2.0f;
+static constexpr float tolerance = 0.0001f;
+
+namespace audioapi {
+class BiquadFilterTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+
+  void expectCoefficientsNear(const std::shared_ptr<BiquadFilterNode> &node, const BiquadCoefficients &expected);
+  void testLowpass(float frequency, float Q);
+  void testHighpass(float frequency, float Q);
+  void testBandpass(float frequency, float Q);
+  void testNotch(float frequency, float Q);
+  void testAllpass(float frequency, float Q);
+  void testPeaking(float frequency, float Q, float gain);
+  void testLowshelf(float frequency, float gain);
+  void testHighshelf(float frequency, float gain);
+};
+
+class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestRestTypes : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterFrequencyTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterGainTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -18,8 +18,7 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry);
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.10.0-nightly-2d11b56-20251021",
+  "version": "0.10.0-nightly-75aa9d0-20251022",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"