react-native-audio-api 0.1.0 → 0.3.0-rc1

package/common/cpp/core/AudioParam.h

@@ -8,22 +8,22 @@
 
 namespace audioapi {
 
-class AudioContext;
+class BaseAudioContext;
 
 class AudioParam {
  public:
   explicit AudioParam(
-      AudioContext *context,
+      BaseAudioContext *context,
       float defaultValue,
       float minValue,
       float maxValue);
 
-  float getValue() const;
+  [[nodiscard]] float getValue() const;
   float getValueAtTime(double time);
   void setValue(float value);
-  float getDefaultValue() const;
-  float getMinValue() const;
-  float getMaxValue() const;
+  [[nodiscard]] float getDefaultValue() const;
+  [[nodiscard]] float getMinValue() const;
+  [[nodiscard]] float getMaxValue() const;
   void setValueAtTime(float value, double startTime);
   void linearRampToValueAtTime(float value, double endTime);
   void exponentialRampToValueAtTime(float value, double endTime);
@@ -33,7 +33,7 @@ class AudioParam {
   float defaultValue_;
   float minValue_;
   float maxValue_;
-  AudioContext *context_;
+  BaseAudioContext *context_;
   std::set<ParamChange> changesQueue_;
 
   double startTime_;
@@ -42,7 +42,7 @@ class AudioParam {
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
 
-  void checkValue(float value) const;
+  float checkValue(float value) const;
   double getStartTime();
   float getStartValue();
 };

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -1,14 +1,19 @@
 #include "AudioScheduledSourceNode.h"
-#include "AudioContext.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
-AudioScheduledSourceNode::AudioScheduledSourceNode(AudioContext *context)
-    : AudioNode(context), isPlaying_(false) {
+AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
+    : AudioNode(context), playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  isInitialized_ = true;
 }
 
 void AudioScheduledSourceNode::start(double time) {
+  context_->getNodeManager()->addSourceNode(shared_from_this());
+
+  playbackState_ = PlaybackState::SCHEDULED;
   waitAndExecute(time, [this](double time) { startPlayback(); });
 }
 
@@ -16,12 +21,21 @@ void AudioScheduledSourceNode::stop(double time) {
   waitAndExecute(time, [this](double time) { stopPlayback(); });
 }
 
+bool AudioScheduledSourceNode::isPlaying() {
+  return playbackState_ == PlaybackState::PLAYING;
+}
+
+bool AudioScheduledSourceNode::isFinished() {
+  return playbackState_ == PlaybackState::FINISHED;
+}
+
 void AudioScheduledSourceNode::startPlayback() {
-  isPlaying_ = true;
+  playbackState_ = PlaybackState::PLAYING;
 }
 
 void AudioScheduledSourceNode::stopPlayback() {
-  isPlaying_ = false;
+  playbackState_ = PlaybackState::FINISHED;
+  disable();
 }
 
 void AudioScheduledSourceNode::waitAndExecute(

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -13,13 +13,17 @@ namespace audioapi {
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
-  explicit AudioScheduledSourceNode(AudioContext *context);
+  enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, FINISHED };
+  explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
   void start(double time);
   void stop(double time);
 
+  bool isFinished();
+  bool isPlaying();
+
  protected:
-  std::atomic<bool> isPlaying_;
+  std::atomic<PlaybackState> playbackState_;
 
  private:
   void startPlayback();

package/common/cpp/core/BaseAudioContext.cpp

@@ -0,0 +1,191 @@
+#ifdef ANDROID
+#include "AudioPlayer.h"
+#else
+#include "IOSAudioDecoder.h"
+#include "IOSAudioPlayer.h"
+#endif
+
+#include "BaseAudioContext.h"
+
+#include "AudioArray.h"
+#include "AudioBuffer.h"
+#include "AudioBufferSourceNode.h"
+#include "AudioBus.h"
+#include "AudioDestinationNode.h"
+#include "AudioNodeManager.h"
+#include "BiquadFilterNode.h"
+#include "ContextState.h"
+#include "GainNode.h"
+#include "OscillatorNode.h"
+#include "StereoPannerNode.h"
+
+namespace audioapi {
+
+BaseAudioContext::BaseAudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+#else
+  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+  audioDecoder_ =
+      std::make_shared<IOSAudioDecoder>(audioPlayer_->getSampleRate());
+#endif
+
+  sampleRate_ = audioPlayer_->getSampleRate();
+  bufferSizeInFrames_ = audioPlayer_->getBufferSizeInFrames();
+
+  nodeManager_ = std::make_shared<AudioNodeManager>();
+  destination_ = std::make_shared<AudioDestinationNode>(this);
+}
+
+BaseAudioContext::~BaseAudioContext() {
+  if (isRunning()) {
+    return;
+  }
+
+  state_ = ContextState::CLOSED;
+  audioPlayer_->stop();
+}
+
+std::string BaseAudioContext::getState() {
+  return BaseAudioContext::toString(state_);
+}
+
+int BaseAudioContext::getSampleRate() const {
+  return sampleRate_;
+}
+
+int BaseAudioContext::getBufferSizeInFrames() const {
+  return bufferSizeInFrames_;
+}
+
+std::size_t BaseAudioContext::getCurrentSampleFrame() const {
+  return destination_->getCurrentSampleFrame();
+}
+
+double BaseAudioContext::getCurrentTime() const {
+  return destination_->getCurrentTime();
+}
+
+std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
+  return destination_;
+}
+
+std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
+  return std::make_shared<OscillatorNode>(this);
+}
+
+std::shared_ptr<GainNode> BaseAudioContext::createGain() {
+  return std::make_shared<GainNode>(this);
+}
+
+std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
+  return std::make_shared<StereoPannerNode>(this);
+}
+
+std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
+  return std::make_shared<BiquadFilterNode>(this);
+}
+
+std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource() {
+  return std::make_shared<AudioBufferSourceNode>(this);
+}
+
+std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
+    int numberOfChannels,
+    int length,
+    int sampleRate) {
+  return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
+}
+
+std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
+    float *real,
+    float *imag,
+    bool disableNormalization,
+    int length) {
+  return std::make_shared<PeriodicWave>(
+      sampleRate_, real, imag, length, disableNormalization);
+}
+
+#ifdef ANDROID
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &source) {
+  return {nullptr};
+}
+#else
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &source) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(source);
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+#endif
+
+std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
+  if (isClosed()) {
+    return [](AudioBus *, int) {};
+  }
+
+  return [this](AudioBus *data, int frames) {
+    destination_->renderAudio(data, frames);
+  };
+}
+
+AudioNodeManager *BaseAudioContext::getNodeManager() {
+  return nodeManager_.get();
+}
+
+bool BaseAudioContext::isRunning() const {
+  return state_ == ContextState::RUNNING;
+}
+
+bool BaseAudioContext::isClosed() const {
+  return state_ == ContextState::CLOSED;
+}
+
+std::string BaseAudioContext::toString(ContextState state) {
+  switch (state) {
+    case ContextState::SUSPENDED:
+      return "suspended";
+    case ContextState::RUNNING:
+      return "running";
+    case ContextState::CLOSED:
+      return "closed";
+    default:
+      throw std::invalid_argument("Unknown context state");
+  }
+}
+
+std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(
+    OscillatorType type) {
+  switch (type) {
+    case OscillatorType::SINE:
+      if (cachedSineWave_ == nullptr) {
+        cachedSineWave_ =
+            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+      }
+      return cachedSineWave_;
+    case OscillatorType::SQUARE:
+      if (cachedSquareWave_ == nullptr) {
+        cachedSquareWave_ =
+            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+      }
+      return cachedSquareWave_;
+    case OscillatorType::SAWTOOTH:
+      if (cachedSawtoothWave_ == nullptr) {
+        cachedSawtoothWave_ =
+            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+      }
+      return cachedSawtoothWave_;
+    case OscillatorType::TRIANGLE:
+      if (cachedTriangleWave_ == nullptr) {
+        cachedTriangleWave_ =
+            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+      }
+      return cachedTriangleWave_;
+    case OscillatorType::CUSTOM:
+      throw std::invalid_argument(
+          "You can't get a custom wave form. You need to create it.");
+      break;
+  }
+}
+
+} // namespace audioapi

package/common/cpp/core/BaseAudioContext.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "ContextState.h"
+#include "OscillatorType.h"
+
+namespace audioapi {
+
+class AudioBus;
+class GainNode;
+class AudioBuffer;
+class PeriodicWave;
+class OscillatorNode;
+class StereoPannerNode;
+class AudioNodeManager;
+class BiquadFilterNode;
+class AudioDestinationNode;
+class AudioBufferSourceNode;
+
+#ifdef ANDROID
+class AudioPlayer;
+#else
+class IOSAudioPlayer;
+class IOSAudioDecoder;
+#endif
+
+class BaseAudioContext {
+ public:
+  BaseAudioContext();
+  ~BaseAudioContext();
+  std::string getState();
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getCurrentTime() const;
+  [[nodiscard]] int getBufferSizeInFrames() const;
+  [[nodiscard]] std::size_t getCurrentSampleFrame() const;
+
+  std::shared_ptr<AudioDestinationNode> getDestination();
+  std::shared_ptr<OscillatorNode> createOscillator();
+  std::shared_ptr<GainNode> createGain();
+  std::shared_ptr<StereoPannerNode> createStereoPanner();
+  std::shared_ptr<BiquadFilterNode> createBiquadFilter();
+  std::shared_ptr<AudioBufferSourceNode> createBufferSource();
+  static std::shared_ptr<AudioBuffer>
+  createBuffer(int numberOfChannels, int length, int sampleRate);
+  std::shared_ptr<PeriodicWave> createPeriodicWave(
+      float *real,
+      float *imag,
+      bool disableNormalization,
+      int length);
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &source);
+
+  std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
+  std::function<void(AudioBus *, int)> renderAudio();
+
+  AudioNodeManager *getNodeManager();
+  [[nodiscard]] bool isRunning() const;
+  [[nodiscard]] bool isClosed() const;
+
+ protected:
+  static std::string toString(ContextState state);
+  std::shared_ptr<AudioDestinationNode> destination_;
+
+#ifdef ANDROID
+  std::shared_ptr<AudioPlayer> audioPlayer_;
+#else
+  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+  std::shared_ptr<IOSAudioDecoder> audioDecoder_;
+#endif
+
+  int sampleRate_;
+  int bufferSizeInFrames_;
+  ContextState state_ = ContextState::RUNNING;
+  std::shared_ptr<AudioNodeManager> nodeManager_;
+
+ private:
+  std::shared_ptr<PeriodicWave> cachedSineWave_ = nullptr;
+  std::shared_ptr<PeriodicWave> cachedSquareWave_ = nullptr;
+  std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
+  std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
+};
+
+} // namespace audioapi

package/common/cpp/core/BiquadFilterNode.cpp

@@ -1,14 +1,15 @@
 #include "BiquadFilterNode.h"
-#include "AudioContext.h"
+#include "AudioArray.h"
+#include "AudioBus.h"
+#include "BaseAudioContext.h"
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
 // formulas for filters
-// https://github.com/LabSound/LabSound/blob/main/src/internal/src/Biquad.cpp -
-// implementation of filters on which I based mine
 
 namespace audioapi {
 
-BiquadFilterNode::BiquadFilterNode(AudioContext *context) : AudioNode(context) {
+BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
+    : AudioNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
       context, 350.0, MIN_FILTER_FREQUENCY, MAX_FILTER_FREQUENCY);
   detuneParam_ =
@@ -17,10 +18,11 @@ BiquadFilterNode::BiquadFilterNode(AudioContext *context) : AudioNode(context) {
       std::make_shared<AudioParam>(context, 1.0, -MAX_FILTER_Q, MAX_FILTER_Q);
   gainParam_ = std::make_shared<AudioParam>(
       context, 0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
-  type_ = FilterType::LOWPASS;
+  type_ = BiquadFilterType::LOWPASS;
+  isInitialized_ = true;
 }
 
-std::string BiquadFilterNode::getType() const {
+std::string BiquadFilterNode::getType() {
   return BiquadFilterNode::toString(type_);
 }
 
@@ -44,8 +46,37 @@ std::shared_ptr<AudioParam> BiquadFilterNode::getGainParam() const {
   return gainParam_;
 }
 
-float BiquadFilterNode::clamp(float value, float min, float max) {
-  return std::min(std::max(value, min), max);
+// Compute Z-transform of the filter
+// 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
+
+void BiquadFilterNode::getFrequencyResponse(
+    const std::vector<float> &frequencyArray,
+    std::vector<float> &magResponseOutput,
+    std::vector<float> &phaseResponseOutput) {
+  applyFilter();
+
+  auto frequencyArraySize = frequencyArray.size();
+
+  float b0 = b0_;
+  float b1 = b1_;
+  float b2 = b2_;
+  float a1 = a1_;
+  float a2 = a2_;
+
+  for (size_t i = 0; i < frequencyArraySize; i++) {
+    auto omega =
+        static_cast<float>(M_PI) * frequencyArray[i] / NYQUIST_FREQUENCY;
+    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));
+    phaseResponseOutput[i] =
+        static_cast<float>(atan2(imag(response), real(response)));
+  }
 }
 
 void BiquadFilterNode::resetCoefficients() {
@@ -62,16 +93,16 @@ void BiquadFilterNode::setNormalizedCoefficients(
     float a0,
     float a1,
     float a2) {
-  auto a0Inversed = 1.0f / a0;
-  b0_ = b0 * a0Inversed;
-  b1_ = b1 * a0Inversed;
-  b2_ = b2 * a0Inversed;
-  a1_ = a1 * a0Inversed;
-  a2_ = a2 * a0Inversed;
+  auto a0Inverted = 1.0f / a0;
+  b0_ = b0 * a0Inverted;
+  b1_ = b1 * a0Inverted;
+  b2_ = b2 * a0Inverted;
+  a1_ = a1 * a0Inverted;
+  a2_ = a2 * a0Inverted;
 }
 
 void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   if (frequency == 1.0) {
     setNormalizedCoefficients(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -83,20 +114,18 @@ void BiquadFilterNode::setLowpassCoefficients(float frequency, float Q) {
 
   Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
-  float d = std::sqrt((4 - std::sqrt(16 - 16 / (g * g))) / 2);
 
   float theta = M_PI * frequency;
-  float sn = 0.5f * d * std::sin(theta);
-  float beta = 0.5f * (1 - sn) / (1 + sn);
-  float gamma = (0.5f + beta) * std::cos(theta);
-  float alpha = 0.25f * (0.5f + beta - gamma);
+  float alpha = std::sin(theta) / (2 * g);
+  float cosW = std::cos(theta);
+  float beta = (1 - cosW) / 2;
 
   setNormalizedCoefficients(
-      2 * alpha, 4 * alpha, 2 * alpha, 1.0f, -2 * gamma, 2 * beta);
+      beta, 2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   if (frequency == 1.0) {
     setNormalizedCoefficients(0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
     return;
@@ -108,20 +137,18 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
 
   Q = std::max(0.0f, Q);
   float g = std::pow(10.0f, 0.05f * Q);
-  float d = std::sqrt((4 - std::sqrt(16 - 16 / (g * g))) / 2);
 
   float theta = M_PI * frequency;
-  float sn = 0.5f * d * std::sin(theta);
-  float beta = 0.5f * (1 - sn) / (1 + sn);
-  float gamma = (0.5f + beta) * std::cos(theta);
-  float alpha = 0.25f * (0.5f + beta - gamma);
+  float alpha = std::sin(theta) / (2 * g);
+  float cosW = std::cos(theta);
+  float beta = (1 - cosW) / 2;
 
   setNormalizedCoefficients(
-      2 * alpha, -4 * alpha, 2 * alpha, 1.0f, -2 * gamma, 2 * beta);
+      beta, -2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
 void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   Q = std::max(0.0f, Q);
 
   if (frequency <= 0.0 || frequency >= 1.0) {
@@ -143,7 +170,7 @@ void BiquadFilterNode::setBandpassCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   float A = std::pow(10.0f, gain / 40.0f);
 
   if (frequency == 1.0) {
@@ -172,7 +199,7 @@ void BiquadFilterNode::setLowshelfCoefficients(float frequency, float gain) {
 }
 
 void BiquadFilterNode::setHighshelfCoefficients(float frequency, float gain) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   float A = std::pow(10.0f, gain / 40.0f);
 
   if (frequency == 1.0) {
@@ -204,7 +231,7 @@ void BiquadFilterNode::setPeakingCoefficients(
     float frequency,
     float Q,
     float gain) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   Q = std::max(0.0f, Q);
   float A = std::pow(10.0f, gain / 40.0f);
 
@@ -232,7 +259,7 @@ void BiquadFilterNode::setPeakingCoefficients(
 }
 
 void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   Q = std::max(0.0f, Q);
 
   if (frequency <= 0.0 || frequency >= 1.0) {
@@ -253,7 +280,7 @@ void BiquadFilterNode::setNotchCoefficients(float frequency, float Q) {
 }
 
 void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
-  frequency = clamp(frequency, 0.0, 1.0);
+  frequency = std::clamp(frequency, 0.0f, 1.0f);
   Q = std::max(0.0f, Q);
 
   if (frequency <= 0.0 || frequency >= 1.0) {
@@ -286,37 +313,37 @@ void BiquadFilterNode::applyFilter() {
   }
 
   switch (type_) {
-    case FilterType::LOWPASS:
+    case BiquadFilterType::LOWPASS:
       setLowpassCoefficients(
           normalizedFrequency, QParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::HIGHPASS:
+    case BiquadFilterType::HIGHPASS:
       setHighpassCoefficients(
           normalizedFrequency, QParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::BANDPASS:
+    case BiquadFilterType::BANDPASS:
       setBandpassCoefficients(
           normalizedFrequency, QParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::LOWSHELF:
+    case BiquadFilterType::LOWSHELF:
       setLowshelfCoefficients(
           normalizedFrequency, gainParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::HIGHSHELF:
+    case BiquadFilterType::HIGHSHELF:
       setHighshelfCoefficients(
           normalizedFrequency, gainParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::PEAKING:
+    case BiquadFilterType::PEAKING:
       setPeakingCoefficients(
           normalizedFrequency,
           QParam_->getValueAtTime(currentTime),
           gainParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::NOTCH:
+    case BiquadFilterType::NOTCH:
       setNotchCoefficients(
           normalizedFrequency, QParam_->getValueAtTime(currentTime));
       break;
-    case FilterType::ALLPASS:
+    case BiquadFilterType::ALLPASS:
       setAllpassCoefficients(
           normalizedFrequency, QParam_->getValueAtTime(currentTime));
       break;
@@ -325,40 +352,36 @@ void BiquadFilterNode::applyFilter() {
   }
 }
 
-bool BiquadFilterNode::processAudio(float *audioData, int32_t numFrames) {
-  if (!AudioNode::processAudio(audioData, numFrames)) {
-    return false;
-  }
-
+void BiquadFilterNode::processNode(
+    AudioBus *processingBus,
+    int framesToProcess) {
   resetCoefficients();
   applyFilter();
 
-  float x1 = x1_;
-  float x2 = x2_;
-  float y1 = y1_;
-  float y2 = y2_;
+  for (int c = 0; c < processingBus->getNumberOfChannels(); c += 1) {
+    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_;
+    float b0 = b0_;
+    float b1 = b1_;
+    float b2 = b2_;
+    float a1 = a1_;
+    float a2 = a2_;
 
-  for (int i = 0; i < numFrames; i++) {
-    auto input = audioData[i * channelCount_];
-    auto output =
-        static_cast<float>(b0 * input + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2);
+    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;
 
-    for (int j = 0; j < channelCount_; j++) {
-      audioData[i * channelCount_ + j] = output;
-    }
+      (*processingBus->getChannel(c))[i] = output;
 
-    x2 = x1;
-    x1 = input;
-    y2 = y1;
-    y1 = output;
+      x2 = x1;
+      x1 = input;
+      y2 = y1;
+      y1 = output;
+    }
   }
-
-  return true;
 }
+
 } // namespace audioapi