react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.3

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

@@ -1,29 +1,55 @@
+/*
+ * 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>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
 // formulas for filters
 
 namespace audioapi {
 
-BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
-    : AudioNode(context) {
-  frequencyParam_ = std::make_shared<AudioParam>(
-      350.0, 0.0f, context->getNyquistFrequency(), context);
+BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context) : AudioNode(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,
-      MOST_NEGATIVE_SINGLE_FLOAT,
-      40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT,
-      context);
+      0.0f, MOST_NEGATIVE_SINGLE_FLOAT, 40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT, context);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
   channelCountMode_ = ChannelCountMode::MAX;
@@ -76,30 +102,36 @@ 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));
-    auto response = (b0 + (b1 + b2 * z) * z) /
-        (std::complex<float>(1, 0) + (a1 + a2 * z) * z);
+    double omega = -PI * normalizedFreq;
+    auto z = std::complex<double>(std::cos(omega), std::sin(omega));
+    auto response = (b0 + (b1 + b2 * 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)));
+    phaseResponseOutput[i] = static_cast<float>(atan2(imag(response), real(response)));
   }
 }
 
@@ -120,17 +152,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;
@@ -138,21 +169,19 @@ void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
   float cosW = std::cos(theta);
   float beta = (1 - cosW) / 2;
 
-  setNormalizedCoefficients(
-      beta, 2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
+  setNormalizedCoefficients(beta, 2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 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;
@@ -160,19 +189,18 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
   float cosW = std::cos(theta);
   float beta = (1 + cosW) / 2;
 
-  setNormalizedCoefficients(
-      beta, -2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
+  setNormalizedCoefficients(beta, -2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 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;
   }
@@ -181,19 +209,18 @@ void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
   float alpha = std::sin(w0) / (2 * Q);
   float cosW = std::cos(w0);
 
-  setNormalizedCoefficients(
-      alpha, 0.0f, -alpha, 1.0f + alpha, -2 * cosW, 1.0f - alpha);
+  setNormalizedCoefficients(alpha, 0.0f, -alpha, 1.0f + alpha, -2 * cosW, 1.0f - alpha);
 }
 
 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 +242,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;
   }
@@ -241,18 +268,15 @@ void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
       A + 1 - (A - 1) * cosW - gamma);
 }
 
-void BiquadFilterNode::setPeakingCoefficients(
-    float frequency,
-    float Q,
-    float gain) {
+void BiquadFilterNode::setPeakingCoefficients(float frequency, float Q, 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;
   }
@@ -262,21 +286,16 @@ void BiquadFilterNode::setPeakingCoefficients(
   float cosW = std::cos(w0);
 
   setNormalizedCoefficients(
-      1 + alpha * A,
-      -2 * cosW,
-      1 - alpha * A,
-      1 + alpha / A,
-      -2 * cosW,
-      1 - alpha / A);
+      1 + alpha * A, -2 * cosW, 1 - alpha * A, 1 + alpha / A, -2 * cosW, 1 - alpha / A);
 }
 
 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;
   }
@@ -285,17 +304,16 @@ void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
   float alpha = std::sin(w0) / (2 * Q);
   float cosW = std::cos(w0);
 
-  setNormalizedCoefficients(
-      1.0f, -2 * cosW, 1.0f, 1 + alpha, -2 * cosW, 1 - alpha);
+  setNormalizedCoefficients(1.0f, -2 * cosW, 1.0f, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 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;
   }
@@ -304,20 +322,20 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
   float alpha = std::sin(w0) / (2 * Q);
   float cosW = std::cos(w0);
 
-  setNormalizedCoefficients(
-      1 - alpha, -2 * cosW, 1 + alpha, 1 + alpha, -2 * cosW, 1 - alpha);
+  setNormalizedCoefficients(1 - alpha, -2 * cosW, 1 + alpha, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 void BiquadFilterNode::applyFilter() {
   double currentTime = context_->getCurrentTime();
 
-  float frequency =
-      frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
-  float detune =
-      detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  float frequency = frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  float detune = detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
   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(
@@ -59,8 +95,7 @@ class BiquadFilterNode : public AudioNode {
 
   static BiquadFilterType fromString(const std::string &type) {
     std::string lowerType = type;
-    std::transform(
-        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
 
     if (lowerType == "lowpass")
       return BiquadFilterType::LOWPASS;
@@ -105,13 +140,7 @@ class BiquadFilterNode : public AudioNode {
     }
   }
 
-  void setNormalizedCoefficients(
-      float b0,
-      float b1,
-      float b2,
-      float a0,
-      float a1,
-      float a2);
+  void setNormalizedCoefficients(float b0, float b1, float b2, float a0, float a1, float a2);
   void setLowpassCoefficients(float frequency, float Q);
   void setHighpassCoefficients(float frequency, float Q);
   void setBandpassCoefficients(float frequency, float Q);

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

@@ -0,0 +1,201 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/FFT.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <vector>
+
+namespace audioapi {
+ConvolverNode::ConvolverNode(
+    BaseAudioContext *context,
+    const std::shared_ptr<AudioBuffer> &buffer,
+    bool disableNormalization)
+    : AudioNode(context),
+      remainingSegments_(0),
+      internalBufferIndex_(0),
+      signalledToStop_(false),
+      scaleFactor_(1.0f),
+      intermediateBus_(nullptr),
+      buffer_(nullptr),
+      internalBuffer_(nullptr) {
+  channelCount_ = 2;
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  normalize_ = !disableNormalization;
+  gainCalibrationSampleRate_ = context->getSampleRate();
+  setBuffer(buffer);
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  requiresTailProcessing_ = true;
+  isInitialized_ = true;
+}
+
+bool ConvolverNode::getNormalize_() const {
+  return normalize_;
+}
+
+const std::shared_ptr<AudioBuffer> &ConvolverNode::getBuffer() const {
+  return buffer_;
+}
+
+void ConvolverNode::setNormalize(bool normalize) {
+  if (normalize_ != normalize) {
+    normalize_ = normalize;
+    if (normalize_ && buffer_)
+      calculateNormalizationScale();
+  }
+  if (!normalize_) {
+    scaleFactor_ = 1.0f;
+  }
+}
+
+void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
+  if (buffer_ != buffer && buffer != nullptr) {
+    buffer_ = buffer;
+    if (normalize_)
+      calculateNormalizationScale();
+    threadPool_ = std::make_shared<ThreadPool>(4);
+    convolvers_.clear();
+    for (int i = 0; i < buffer->getNumberOfChannels(); ++i) {
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(channelData.getData(), buffer->getChannelData(i), buffer->getLength() * sizeof(float));
+      convolvers_.back().init(RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    if (buffer->getNumberOfChannels() == 1) {
+      // add one more convolver, because right now input is always stereo
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(channelData.getData(), buffer->getChannelData(0), buffer->getLength() * sizeof(float));
+      convolvers_.back().init(RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    internalBuffer_ =
+        std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 2, channelCount_, buffer->getSampleRate());
+    intermediateBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, convolvers_.size(), buffer->getSampleRate());
+    internalBufferIndex_ = 0;
+  }
+}
+
+void ConvolverNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
+  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+    signalledToStop_ = true;
+    remainingSegments_ = convolvers_.at(0).getSegCount();
+  }
+}
+
+std::shared_ptr<AudioBus> ConvolverNode::processInputs(
+    const std::shared_ptr<AudioBus> &outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (internalBufferIndex_ < framesToProcess) {
+    return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
+  }
+  return AudioNode::processInputs(outputBus, 0, false);
+}
+
+// processing pipeline: processingBus -> intermediateBus_ -> audioBus_ (mixing
+// with intermediateBus_)
+std::shared_ptr<AudioBus> ConvolverNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (signalledToStop_) {
+    if (remainingSegments_ > 0) {
+      remainingSegments_--;
+    } else {
+      disable();
+      signalledToStop_ = false;
+      internalBufferIndex_ = 0;
+      return processingBus;
+    }
+  }
+  if (internalBufferIndex_ < framesToProcess) {
+    performConvolution(processingBus); // result returned to intermediateBus_
+    audioBus_->sum(intermediateBus_.get());
+
+    internalBuffer_->copy(audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
+    internalBufferIndex_ += RENDER_QUANTUM_SIZE;
+  }
+  audioBus_->zero();
+  audioBus_->copy(internalBuffer_.get(), 0, 0, framesToProcess);
+  int remainingFrames = internalBufferIndex_ - framesToProcess;
+  if (remainingFrames > 0) {
+    for (int i = 0; i < internalBuffer_->getNumberOfChannels(); ++i) {
+      memmove(
+          internalBuffer_->getChannel(i)->getData(),
+          internalBuffer_->getChannel(i)->getData() + framesToProcess,
+          remainingFrames * sizeof(float));
+    }
+  }
+  internalBufferIndex_ -= framesToProcess;
+
+  for (int i = 0; i < audioBus_->getNumberOfChannels(); ++i) {
+    dsp::multiplyByScalar(
+        audioBus_->getChannel(i)->getData(),
+        scaleFactor_,
+        audioBus_->getChannel(i)->getData(),
+        framesToProcess);
+  }
+
+  return audioBus_;
+}
+
+void ConvolverNode::calculateNormalizationScale() {
+  int numberOfChannels = buffer_->getNumberOfChannels();
+  int length = buffer_->getLength();
+
+  float power = 0;
+
+  for (int channel = 0; channel < numberOfChannels; ++channel) {
+    float channelPower = 0;
+    auto channelData = buffer_->getChannelData(channel);
+    for (int i = 0; i < length; ++i) {
+      float sample = channelData[i];
+      channelPower += sample * sample;
+    }
+    power += channelPower;
+  }
+
+  power = std::sqrt(power / (numberOfChannels * length));
+  if (power < MIN_IR_POWER) {
+    power = MIN_IR_POWER;
+  }
+  scaleFactor_ = 1 / power;
+  scaleFactor_ *= std::pow(10, GAIN_CALIBRATION * 0.05f);
+  scaleFactor_ *= gainCalibrationSampleRate_ / buffer_->getSampleRate();
+}
+
+void ConvolverNode::performConvolution(const std::shared_ptr<AudioBus> &processingBus) {
+  if (processingBus->getNumberOfChannels() == 1) {
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule([&, i] {
+        convolvers_[i].process(
+            processingBus->getChannel(0)->getData(), intermediateBus_->getChannel(i)->getData());
+      });
+    }
+  } else if (processingBus->getNumberOfChannels() == 2) {
+    std::vector<int> inputChannelMap;
+    std::vector<int> outputChannelMap;
+    if (convolvers_.size() == 2) {
+      inputChannelMap = {0, 1};
+      outputChannelMap = {0, 1};
+    } else { // 4 channel IR
+      inputChannelMap = {0, 0, 1, 1};
+      outputChannelMap = {0, 3, 2, 1};
+    }
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule([this, i, inputChannelMap, outputChannelMap, &processingBus] {
+        convolvers_[i].process(
+            processingBus->getChannel(inputChannelMap[i])->getData(),
+            intermediateBus_->getChannel(outputChannelMap[i])->getData());
+      });
+    }
+  }
+  threadPool_->wait();
+}
+} // namespace audioapi

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

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/dsp/Convolver.h>
+
+#include <memory>
+#include <vector>
+
+#include <audioapi/utils/ThreadPool.hpp>
+
+static constexpr int GAIN_CALIBRATION =
+    -58; // magic number so that processed signal and dry signal have roughly the same volume
+static constexpr double MIN_IR_POWER = 0.000125;
+
+namespace audioapi {
+
+class AudioBus;
+class AudioBuffer;
+
+class ConvolverNode : public AudioNode {
+ public:
+  explicit ConvolverNode(
+      BaseAudioContext *context,
+      const std::shared_ptr<AudioBuffer> &buffer,
+      bool disableNormalization);
+
+  [[nodiscard]] bool getNormalize_() const;
+  [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;
+  void setNormalize(bool normalize);
+  void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioBus> processInputs(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed) override;
+  void onInputDisabled() override;
+  float gainCalibrationSampleRate_;
+  size_t remainingSegments_;
+  size_t internalBufferIndex_;
+  bool normalize_;
+  bool signalledToStop_;
+  float scaleFactor_;
+  std::shared_ptr<AudioBus> intermediateBus_;
+
+  // impulse response buffer
+  std::shared_ptr<AudioBuffer> buffer_;
+  // buffer to hold internal processed data
+  std::shared_ptr<AudioBus> internalBuffer_;
+  // vectors of convolvers, one per channel
+  std::vector<Convolver> convolvers_;
+  std::shared_ptr<ThreadPool> threadPool_;
+
+  void calculateNormalizationScale();
+  void performConvolution(const std::shared_ptr<AudioBus> &processingBus);
+};
+
+} // namespace audioapi