react-native-audio-api 0.7.0-nightly-fba4835-20250722 → 0.7.0-nightly-4fc09d1-20250724

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

@@ -26,6 +26,7 @@ BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
       context);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
+  channelCountMode_ = ChannelCountMode::MAX;
 }
 
 std::string BiquadFilterNode::getType() {
@@ -56,17 +57,28 @@ std::shared_ptr<AudioParam> BiquadFilterNode::getGainParam() const {
 // https://www.dsprelated.com/freebooks/filters/Frequency_Response_Analysis.html
 // https://www.dsprelated.com/freebooks/filters/Transfer_Function_Analysis.html
 //
-// frequency response -  H(z) = (b0 + b1*z^(-1) + b2*z^(-2))/(1 + a1*z^(-1) +
-// a2*z^(-2)) = ((b0 * z + b1) * z + b2) / ((z + a1) * z + a2) phase response -
-// angle of the frequency response
+// frequency response -  H(z)
+//          b0 + b1 * z^(-1) + b2 * z^(-2)
+//  H(z) = -------------------------------
+//           1 + a1 * z^(-1) + a2 * z^(-2)
+//
+//         b0 + (b1 + b2 * z1) * z1
+//     =  --------------------------
+//         (1 + (a1 + a2 * z1) * z1
+//
+// where z1 = 1/z and z = e^(j * pi * frequency)
+// z1 = e^(-j * pi * frequency)
+//
+// phase response - angle of the frequency response
+//
 
 void BiquadFilterNode::getFrequencyResponse(
     const float *frequencyArray,
     float *magResponseOutput,
     float *phaseResponseOutput,
     const int length) {
-  applyFilter();
 
+  // Local copies for micro-optimization
   float b0 = b0_;
   float b1 = b1_;
   float b2 = b2_;
@@ -74,10 +86,17 @@ void BiquadFilterNode::getFrequencyResponse(
   float a2 = a2_;
 
   for (size_t i = 0; i < length; i++) {
-    auto omega = PI * frequencyArray[i] / context_->getNyquistFrequency();
+    if (frequencyArray[i] < 0.0 || frequencyArray[i] > 1.0) {
+      magResponseOutput[i] = std::nanf("");
+      phaseResponseOutput[i] = std::nanf("");
+      continue;
+    }
+
+    auto omega = -PI * frequencyArray[i];
     auto z = std::complex<float>(cos(omega), sin(omega));
-    auto response = ((b0 * z + b1) * z + b2) / ((z + a1) * z + a2);
-    magResponseOutput[i] = static_cast<float>(abs(response));
+    auto response = (b0 + (b1 + b2 * z) * z) /
+        (std::complex<float>(1, 0) + (a1 + a2 * z) * z);
+    magResponseOutput[i] = static_cast<float>(std::abs(response));
     phaseResponseOutput[i] =
         static_cast<float>(atan2(imag(response), real(response)));
   }
@@ -106,11 +125,12 @@ void BiquadFilterNode::setNormalizedCoefficients(
 }
 
 void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  if (frequency == 1.0) {
+  // Limit frequency to [0, 1] range
+  if (frequency >= 1.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
+
   if (frequency <= 0.0) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -129,8 +149,7 @@ void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  if (frequency == 1.0) {
+  if (frequency >= 1.0) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -152,14 +171,13 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  Q = std::max(0.0f, Q);
-
+  // Limit frequency to [0, 1] range
   if (frequency <= 0.0 || frequency >= 1.0) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
 
+  // Limit Q to positive values
   if (Q <= 0.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -167,17 +185,16 @@ void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
 
   float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
-  float k = std::cos(w0);
+  float cosW = std::cos(w0);
 
   setNormalizedCoefficients(
-      alpha, 0.0f, -alpha, 1.0f + alpha, -2 * k, 1.0f - alpha);
+      alpha, 0.0f, -alpha, 1.0f + alpha, -2 * cosW, 1.0f - alpha);
 }
 
 void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
   float A = std::pow(10.0f, gain / 40.0f);
 
-  if (frequency == 1.0) {
+  if (frequency >= 1.0) {
     setNormalizedCoefficients(A * A, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -188,25 +205,23 @@ void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
   }
 
   float w0 = PI * frequency;
-  float alpha =
-      0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
-  float k = std::cos(w0);
-  float k2 = 2.0f * std::sqrt(A) * alpha;
+  float alpha = 0.5f * std::sin(w0) * std::sqrt(2.0f);
+  float cosW = std::cos(w0);
+  float gamma = 2.0f * std::sqrt(A) * alpha;
 
   setNormalizedCoefficients(
-      A * (A + 1 - (A - 1) * k + k2),
-      2.0f * A * (A - 1 - (A + 1) * k),
-      A * (A + 1 - (A - 1) * k - k2),
-      A + 1 + (A - 1) * k + k2,
-      -2.0f * (A - 1 + (A + 1) * k),
-      A + 1 + (A - 1) * k - k2);
+      A * (A + 1 - (A - 1) * cosW + gamma),
+      2.0f * A * (A - 1 - (A + 1) * cosW),
+      A * (A + 1 - (A - 1) * cosW - gamma),
+      A + 1 + (A - 1) * cosW + gamma,
+      -2.0f * (A - 1 + (A + 1) * cosW),
+      A + 1 + (A - 1) * cosW - gamma);
 }
 
 void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
   float A = std::pow(10.0f, gain / 40.0f);
 
-  if (frequency == 1.0) {
+  if (frequency >= 1.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
   }
@@ -217,26 +232,25 @@ void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
   }
 
   float w0 = PI * frequency;
-  float alpha =
-      0.5f * std::sin(w0) * std::sqrt((A + 1 / A) * (1 / 1.0f - 1) + 2);
-  float k = std::cos(w0);
-  float k2 = 2.0f * std::sqrt(A) * alpha;
+  // In the original formula: sqrt((A + 1/A) * (1/S - 1) + 2), but we assume
+  // the maximum value S = 1, so it becomes 0 + 2 under the square root
+  float alpha = 0.5f * std::sin(w0) * std::sqrt(2.0f);
+  float cosW = std::cos(w0);
+  float gamma = 2.0f * std::sqrt(A) * alpha;
 
   setNormalizedCoefficients(
-      A * (A + 1 + (A - 1) * k + k2),
-      -2.0f * A * (A - 1 + (A + 1) * k),
-      A * (A + 1 + (A - 1) * k - k2),
-      A + 1 - (A - 1) * k + k2,
-      2.0f * (A - 1 - (A + 1) * k),
-      A + 1 - (A - 1) * k - k2);
+      A * (A + 1 + (A - 1) * cosW + gamma),
+      -2.0f * A * (A - 1 + (A + 1) * cosW),
+      A * (A + 1 + (A - 1) * cosW - gamma),
+      A + 1 - (A - 1) * cosW + gamma,
+      2.0f * (A - 1 - (A + 1) * cosW),
+      A + 1 - (A - 1) * cosW - gamma);
 }
 
 void BiquadFilterNode::setPeakingCoefficients(
     float frequency,
     float Q,
     float gain) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  Q = std::max(0.0f, Q);
   float A = std::pow(10.0f, gain / 40.0f);
 
   if (frequency <= 0.0 || frequency >= 1.0) {
@@ -251,21 +265,18 @@ void BiquadFilterNode::setPeakingCoefficients(
 
   float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
-  float k = std::cos(w0);
+  float cosW = std::cos(w0);
 
   setNormalizedCoefficients(
       1 + alpha * A,
-      -2 * k,
+      -2 * cosW,
       1 - alpha * A,
       1 + alpha / A,
-      -2 * k,
+      -2 * cosW,
       1 - alpha / A);
 }
 
 void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  Q = std::max(0.0f, Q);
-
   if (frequency <= 0.0 || frequency >= 1.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -278,15 +289,13 @@ void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
 
   float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
-  float k = std::cos(w0);
+  float cosW = std::cos(w0);
 
-  setNormalizedCoefficients(1.0f, -2 * k, 1.0f, 1 + alpha, -2 * k, 1 - alpha);
+  setNormalizedCoefficients(
+      1.0f, -2 * cosW, 1.0f, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
-  frequency = std::clamp(frequency, 0.0f, 1.0f);
-  Q = std::max(0.0f, Q);
-
   if (frequency <= 0.0 || frequency >= 1.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -299,55 +308,47 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
 
   float w0 = PI * frequency;
   float alpha = std::sin(w0) / (2 * Q);
-  float k = std::cos(w0);
+  float cosW = std::cos(w0);
 
   setNormalizedCoefficients(
-      1 - alpha, -2 * k, 1 + alpha, 1 + alpha, -2 * k, 1 - alpha);
+      1 - alpha, -2 * cosW, 1 + alpha, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
-void BiquadFilterNode::applyFilter() {
-  double currentTime = context_->getCurrentTime();
-
-  float frequencyParamValue =
-      frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
-  float normalizedFrequency =
-      frequencyParamValue / context_->getNyquistFrequency();
-
-  float detuneValue =
-      detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+void BiquadFilterNode::updateCoefficientsForFrame(
+    float frequency,
+    float detune,
+    float Q,
+    float gain) {
+  float normalizedFrequency = frequency / context_->getNyquistFrequency();
 
-  if (detuneValue != 0.0) {
-    normalizedFrequency *= std::pow(2.0f, detuneValue / 1200.0f);
+  if (detune != 0.0f) {
+    normalizedFrequency *= std::pow(2.0f, detune / 1200.0f);
   }
 
-  auto qparamValue =
-      QParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
-  auto gainParamValue =
-      gainParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   switch (type_) {
     case BiquadFilterType::LOWPASS:
-      setLowpassCoefficients(normalizedFrequency, qparamValue);
+      setLowpassCoefficients(normalizedFrequency, Q);
       break;
     case BiquadFilterType::HIGHPASS:
-      setHighpassCoefficients(normalizedFrequency, qparamValue);
+      setHighpassCoefficients(normalizedFrequency, Q);
       break;
     case BiquadFilterType::BANDPASS:
-      setBandpassCoefficients(normalizedFrequency, qparamValue);
+      setBandpassCoefficients(normalizedFrequency, Q);
       break;
     case BiquadFilterType::LOWSHELF:
-      setLowshelfCoefficients(normalizedFrequency, gainParamValue);
+      setLowshelfCoefficients(normalizedFrequency, gain);
       break;
     case BiquadFilterType::HIGHSHELF:
-      setHighshelfCoefficients(normalizedFrequency, gainParamValue);
+      setHighshelfCoefficients(normalizedFrequency, gain);
       break;
     case BiquadFilterType::PEAKING:
-      setPeakingCoefficients(normalizedFrequency, qparamValue, gainParamValue);
+      setPeakingCoefficients(normalizedFrequency, Q, gain);
       break;
     case BiquadFilterType::NOTCH:
-      setNotchCoefficients(normalizedFrequency, qparamValue);
+      setNotchCoefficients(normalizedFrequency, Q);
       break;
     case BiquadFilterType::ALLPASS:
-      setAllpassCoefficients(normalizedFrequency, qparamValue);
+      setAllpassCoefficients(normalizedFrequency, Q);
       break;
     default:
       break;
@@ -357,24 +358,34 @@ void BiquadFilterNode::applyFilter() {
 void BiquadFilterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  resetCoefficients();
-  applyFilter();
-
-  for (int c = 0; c < processingBus->getNumberOfChannels(); c += 1) {
+  double currentTime = context_->getCurrentTime();
+  auto frequencyValues =
+      frequencyParam_->processARateParam(framesToProcess, currentTime)
+          ->getChannel(0)
+          ->getData();
+  auto detuneValues =
+      detuneParam_->processARateParam(framesToProcess, currentTime)
+          ->getChannel(0)
+          ->getData();
+  auto qValues = QParam_->processARateParam(framesToProcess, currentTime)
+                     ->getChannel(0)
+                     ->getData();
+  auto gainValues = gainParam_->processARateParam(framesToProcess, currentTime)
+                        ->getChannel(0)
+                        ->getData();
+
+  for (int c = 0; c < processingBus->getNumberOfChannels(); c++) {
     float x1 = x1_;
     float x2 = x2_;
     float y1 = y1_;
     float y2 = y2_;
 
-    float b0 = b0_;
-    float b1 = b1_;
-    float b2 = b2_;
-    float a1 = a1_;
-    float a2 = a2_;
+    for (int i = 0; i < framesToProcess; i++) {
+      updateCoefficientsForFrame(
+          frequencyValues[i], detuneValues[i], qValues[i], gainValues[i]);
 
-    for (int i = 0; i < framesToProcess; i += 1) {
       float input = (*processingBus->getChannel(c))[i];
-      float output = b0 * input + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+      float output = b0_ * input + b1_ * x1 + b2_ * x2 - a1_ * y1 - a2_ * y2;
 
       (*processingBus->getChannel(c))[i] = output;
 
@@ -383,6 +394,10 @@ void BiquadFilterNode::processNode(
       y2 = y1;
       y1 = output;
     }
+    x1_ = x1;
+    x2_ = x2;
+    y1_ = y1;
+    y2_ = y2;
   }
 }
 

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

@@ -33,7 +33,9 @@ class BiquadFilterNode : public AudioNode {
       int length);
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  void processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;
@@ -119,7 +121,11 @@ class BiquadFilterNode : public AudioNode {
   void setPeakingCoefficients(float frequency, float Q, float gain);
   void setNotchCoefficients(float frequency, float Q);
   void setAllpassCoefficients(float frequency, float Q);
-  void applyFilter();
+  void updateCoefficientsForFrame(
+      float frequency,
+      float detune,
+      float q,
+      float gain);
 };
 
 } // namespace audioapi

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

@@ -10,7 +10,7 @@ namespace audioapi {
 
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
-  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
   panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context);
   isInitialized_ = true;
 }
@@ -31,26 +31,42 @@ void StereoPannerNode::processNode(
                             ->getChannel(0)
                             ->getData();
 
-  for (int i = 0; i < framesToProcess; i += 1) {
-    auto pan = panParamValues[i];
+  // Input is mono
+  if (processingBus->getNumberOfChannels() == 1) {
+    for (int i = 0; i < framesToProcess; i++) {
+      auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
+      auto x = (pan + 1) / 2;
 
-    auto x = (pan <= 0 ? pan + 1 : pan);
+      auto gainL = static_cast<float>(cos(x * PI / 2));
+      auto gainR = static_cast<float>(sin(x * PI / 2));
 
-    auto gainL = static_cast<float>(cos(x * PI / 2));
-    auto gainR = static_cast<float>(sin(x * PI / 2));
+      float input = (*left)[i];
 
-    float inputL = (*left)[i];
-    float inputR = (*right)[i];
-
-    if (pan <= 0) {
-      (*left)[i] = inputL + inputR * gainL;
-      (*right)[i] = inputR * gainR;
-    } else {
-      (*left)[i] = inputL * gainL;
-      (*right)[i] = inputR + inputL * gainR;
+      (*left)[i] = input * gainL;
+      (*right)[i] = input * gainR;
+      time += deltaTime;
     }
+  } else { // Input is stereo
+    for (int i = 0; i < framesToProcess; i++) {
+      auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
+      auto x = (pan <= 0 ? pan + 1 : pan);
+
+      auto gainL = static_cast<float>(cos(x * PI / 2));
+      auto gainR = static_cast<float>(sin(x * PI / 2));
+
+      float inputL = (*left)[i];
+      float inputR = (*right)[i];
 
-    time += deltaTime;
+      if (pan <= 0) {
+        (*left)[i] = inputL + inputR * gainL;
+        (*right)[i] = inputR * gainR;
+      } else {
+        (*left)[i] = inputL * gainL;
+        (*right)[i] = inputR + inputL * gainR;
+      }
+
+      time += deltaTime;
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.7.0-nightly-fba4835-20250722",
+  "version": "0.7.0-nightly-4fc09d1-20250724",
   "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"