react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-bfab178-20251107

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -56,7 +56,7 @@ float AudioParam::getValueAtTime(double time) {
 void AudioParam::setValueAtTime(float value, double startTime) {
   auto event = [value, startTime](AudioParam &param) {
     // Ignore events scheduled before the end of existing automation
-    if (startTime <= param.getQueueEndTime()) {
+    if (startTime < param.getQueueEndTime()) {
       return;
     }
 
@@ -87,7 +87,7 @@ void AudioParam::setValueAtTime(float value, double startTime) {
 void AudioParam::linearRampToValueAtTime(float value, double endTime) {
   auto event = [value, endTime](AudioParam &param) {
     // Ignore events scheduled before the end of existing automation
-    if (endTime <= param.getQueueEndTime()) {
+    if (endTime < param.getQueueEndTime()) {
       return;
     }
 

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -2,6 +2,7 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
@@ -182,6 +183,15 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
+    std::shared_ptr<AudioBuffer> buffer,
+    bool disableNormalization) {
+  auto convolver =
+      std::make_shared<ConvolverNode>(this, buffer, disableNormalization);
+  nodeManager_->addProcessingNode(convolver);
+  return convolver;
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -28,6 +28,7 @@ class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
+class ConvolverNode;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
 class WorkletSourceNode;
@@ -76,6 +77,7 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
+  std::shared_ptr<ConvolverNode> createConvolver(std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;

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/effects/ConvolverNode.cpp

@@ -0,0 +1,210 @@
+#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 <thread>
+
+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());
+  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,55 @@
+#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