react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

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

@@ -0,0 +1,101 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <memory>
+
+namespace audioapi {
+
+DelayNode::DelayNode(BaseAudioContext *context, float maxDelayTime) : AudioNode(context) {
+  delayTimeParam_ = std::make_shared<AudioParam>(0, 0, maxDelayTime, context);
+  delayBuffer_ = std::make_shared<AudioBus>(
+      static_cast<size_t>(
+          maxDelayTime * context->getSampleRate() +
+          1), // +1 to enable delayTime equal to maxDelayTime
+      channelCount_,
+      context->getSampleRate());
+  requiresTailProcessing_ = true;
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> DelayNode::getDelayTimeParam() const {
+  return delayTimeParam_;
+}
+
+void DelayNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
+  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+    signalledToStop_ = true;
+    remainingFrames_ = delayTimeParam_->getValue() * context_->getSampleRate();
+  }
+}
+
+void DelayNode::delayBufferOperation(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess,
+    size_t &operationStartingIndex,
+    DelayNode::BufferAction action) {
+  size_t processingBusStartIndex = 0;
+
+  // handle buffer wrap around
+  if (operationStartingIndex + framesToProcess > delayBuffer_->getSize()) {
+    int framesToEnd = operationStartingIndex + framesToProcess - delayBuffer_->getSize();
+
+    if (action == BufferAction::WRITE) {
+      delayBuffer_->sum(
+          processingBus.get(), processingBusStartIndex, operationStartingIndex, framesToEnd);
+    } else { // READ
+      processingBus->sum(
+          delayBuffer_.get(), operationStartingIndex, processingBusStartIndex, framesToEnd);
+    }
+
+    operationStartingIndex = 0;
+    processingBusStartIndex += framesToEnd;
+    framesToProcess -= framesToEnd;
+  }
+
+  if (action == BufferAction::WRITE) {
+    delayBuffer_->sum(
+        processingBus.get(), processingBusStartIndex, operationStartingIndex, framesToProcess);
+    processingBus->zero();
+  } else { // READ
+    processingBus->sum(
+        delayBuffer_.get(), operationStartingIndex, processingBusStartIndex, framesToProcess);
+    delayBuffer_->zero(operationStartingIndex, framesToProcess);
+  }
+
+  operationStartingIndex += framesToProcess;
+}
+
+// delay buffer always has channelCount_ channels
+// processing is split into two parts
+// 1. writing to delay buffer (mixing if needed) from processing bus
+// 2. reading from delay buffer to processing bus (mixing if needed) with delay
+std::shared_ptr<AudioBus> DelayNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  // handling tail processing
+  if (signalledToStop_) {
+    if (remainingFrames_ <= 0) {
+      disable();
+      signalledToStop_ = false;
+      return processingBus;
+    }
+
+    delayBufferOperation(processingBus, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
+    remainingFrames_ -= framesToProcess;
+    return processingBus;
+  }
+
+  // normal processing
+  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context_->getCurrentTime());
+  size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context_->getSampleRate()) %
+      delayBuffer_->getSize();
+  delayBufferOperation(processingBus, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
+  delayBufferOperation(processingBus, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
+
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+
+#include <functional>
+#include <memory>
+
+namespace audioapi {
+
+class AudioBus;
+
+class DelayNode : public AudioNode {
+ public:
+  explicit DelayNode(BaseAudioContext *context, float maxDelayTime);
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  void onInputDisabled() override;
+  enum class BufferAction { READ, WRITE };
+  void delayBufferOperation(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess,
+      size_t &operationStartingIndex,
+      BufferAction action);
+  std::shared_ptr<AudioParam> delayTimeParam_;
+  std::shared_ptr<AudioBus> delayBuffer_;
+  size_t readIndex_ = 0;
+  bool signalledToStop_ = false;
+  int remainingFrames_ = 0;
+};
+
+} // namespace audioapi

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

@@ -3,6 +3,7 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 namespace audioapi {
 

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

@@ -16,7 +16,9 @@ class GainNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> gainParam_;

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

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2016 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2020 Apple 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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/IIRFilterNode.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+IIRFilterNode::IIRFilterNode(
+    BaseAudioContext *context,
+    const std::vector<float> &feedforward,
+    const std::vector<float> &feedback)
+    : AudioNode(context), feedforward_(feedforward), feedback_(feedback) {
+  isInitialized_ = true;
+  channelCountMode_ = ChannelCountMode::MAX;
+
+  int maxChannels = MAX_CHANNEL_COUNT;
+  xBuffers_.resize(maxChannels);
+  yBuffers_.resize(maxChannels);
+  bufferIndices.resize(maxChannels, 0);
+
+  for (int c = 0; c < maxChannels; ++c) {
+    xBuffers_[c].resize(bufferLength, 0.0f);
+    yBuffers_[c].resize(bufferLength, 0.0f);
+  }
+
+  size_t feedforwardLength = feedforward_.size();
+  size_t feedbackLength = feedback_.size();
+
+  if (feedback_[0] != 1) {
+    float scale = feedback_[0];
+    for (unsigned k = 1; k < feedbackLength; ++k)
+      feedback_[k] /= scale;
+
+    for (unsigned k = 0; k < feedforwardLength; ++k)
+      feedforward_[k] /= scale;
+
+    feedback_[0] = 1.0f;
+  }
+}
+
+// Compute Z-transform of the filter
+//
+// frequency response -  H(z)
+//          sum(b[k]*z^(-k), k, 0, M)
+//  H(z) = -------------------------------
+//           sum(a[k]*z^(-k), k, 0, N)
+//
+//          sum(b[k]*z1^k, k, 0, M)
+//       = -------------------------------
+//           sum(a[k]*z1^k, k, 0, N)
+//
+// where z1 = 1/z and z = e^(j * pi * frequency)
+// z1 = e^(-j * pi * frequency)
+//
+// phase response - angle of the frequency response
+//
+
+void IIRFilterNode::getFrequencyResponse(
+    const float *frequencyArray,
+    float *magResponseOutput,
+    float *phaseResponseOutput,
+    size_t length) {
+  float nyquist = context_->getNyquistFrequency();
+
+  for (size_t k = 0; k < length; ++k) {
+    float normalizedFreq = frequencyArray[k] / nyquist;
+
+    if (normalizedFreq < 0.0f || normalizedFreq > 1.0f) {
+      // Out-of-bounds frequencies should return NaN.
+      magResponseOutput[k] = std::nanf("");
+      phaseResponseOutput[k] = std::nanf("");
+      continue;
+    }
+
+    float omega = -PI * normalizedFreq;
+    auto z = std::complex<float>(std::cos(omega), std::sin(omega));
+
+    auto numerator = IIRFilterNode::evaluatePolynomial(feedforward_, z, feedforward_.size() - 1);
+    auto denominator = IIRFilterNode::evaluatePolynomial(feedback_, z, feedback_.size() - 1);
+    auto response = numerator / denominator;
+
+    magResponseOutput[k] = static_cast<float>(std::abs(response));
+    phaseResponseOutput[k] = static_cast<float>(atan2(imag(response), real(response)));
+  }
+}
+
+// y[n] = sum(b[k] * x[n - k], k = 0, M) - sum(a[k] * y[n - k], k = 1, N)
+// where b[k] are the feedforward coefficients and a[k] are the feedback coefficients of the filter
+
+// TODO: tail
+
+std::shared_ptr<AudioBus> IIRFilterNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  int numChannels = processingBus->getNumberOfChannels();
+
+  size_t feedforwardLength = feedforward_.size();
+  size_t feedbackLength = feedback_.size();
+  int minLength = std::min(feedbackLength, feedforwardLength);
+
+  int mask = bufferLength - 1;
+
+  for (int c = 0; c < numChannels; ++c) {
+    auto channelData = processingBus->getChannel(c)->getData();
+    auto &x = xBuffers_[c];
+    auto &y = yBuffers_[c];
+    size_t bufferIndex = bufferIndices[c];
+
+    for (int n = 0; n < framesToProcess; ++n) {
+      float yn = feedforward_[0] * channelData[n];
+
+      for (int k = 1; k < minLength; ++k) {
+        int m = (bufferIndex - k) & mask;
+        yn = std::fma(feedforward_[k], x[m], yn);
+        yn = std::fma(-feedback_[k], y[m], yn);
+      }
+
+      for (int k = minLength; k < feedforwardLength; ++k) {
+        yn = std::fma(feedforward_[k], x[(bufferIndex - k) & mask], yn);
+      }
+      for (int k = minLength; k < feedbackLength; ++k) {
+        yn = std::fma(-feedback_[k], y[(bufferIndex - k) & (bufferLength - 1)], yn);
+      }
+
+      channelData[n] = yn;
+
+      x[bufferIndex] = channelData[n];
+      y[bufferIndex] = yn;
+
+      bufferIndex = (bufferIndex + 1) & (bufferLength - 1);
+    }
+    bufferIndices[c] = bufferIndex;
+  }
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2016 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2020 Apple 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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 <complex>
+#include <vector>
+
+#include <memory>
+
+namespace audioapi {
+
+class IIRFilterNode : public AudioNode {
+
+ public:
+  explicit IIRFilterNode(
+      BaseAudioContext *context,
+      const std::vector<float> &feedforward,
+      const std::vector<float> &feedback);
+
+  void getFrequencyResponse(
+      const float *frequencyArray,
+      float *magResponseOutput,
+      float *phaseResponseOutput,
+      size_t length);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  static constexpr size_t bufferLength = 32;
+
+  std::vector<float> feedforward_;
+  std::vector<float> feedback_;
+
+  std::vector<std::vector<float>> xBuffers_; // xBuffers_[channel][index]
+  std::vector<std::vector<float>> yBuffers_;
+  std::vector<size_t> bufferIndices;
+
+  static std::complex<float>
+  evaluatePolynomial(const std::vector<float> coefficients, std::complex<float> z, int order) {
+    // Use Horner's method to evaluate the polynomial P(z) = sum(coef[k]*z^k, k, 0, order);
+    std::complex<float> result = 0;
+    for (int k = order; k >= 0; --k)
+      result = result * z + std::complex<float>(coefficients[k]);
+    return result;
+  }
+};
+} // namespace audioapi

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

@@ -29,6 +29,9 @@
 #include <audioapi/core/effects/PeriodicWave.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <algorithm>
+#include <memory>
+#include <vector>
 
 constexpr unsigned NumberOfOctaveBands = 3;
 constexpr float CentsPerRange = 1200.0f / NumberOfOctaveBands;
@@ -38,13 +41,12 @@ constexpr float interpolate3Point = 0.16;
 namespace audioapi {
 PeriodicWave::PeriodicWave(float sampleRate, bool disableNormalization)
     : sampleRate_(sampleRate), disableNormalization_(disableNormalization) {
-  numberOfRanges_ = static_cast<int>(round(
-      NumberOfOctaveBands * log2f(static_cast<float>(getPeriodicWaveSize()))));
+  numberOfRanges_ = static_cast<int>(
+      round(NumberOfOctaveBands * log2f(static_cast<float>(getPeriodicWaveSize()))));
   auto nyquistFrequency = sampleRate_ / 2;
-  lowestFundamentalFrequency_ = static_cast<float>(nyquistFrequency) /
-      static_cast<float>(getMaxNumberOfPartials());
-  scale_ = static_cast<float>(getPeriodicWaveSize()) /
-      static_cast<float>(sampleRate_);
+  lowestFundamentalFrequency_ =
+      static_cast<float>(nyquistFrequency) / static_cast<float>(getMaxNumberOfPartials());
+  scale_ = static_cast<float>(getPeriodicWaveSize()) / static_cast<float>(sampleRate_);
   bandLimitedTables_ = new float *[numberOfRanges_];
 
   fft_ = std::make_unique<dsp::FFT>(getPeriodicWaveSize());
@@ -91,22 +93,14 @@ float PeriodicWave::getScale() const {
   return scale_;
 }
 
-float PeriodicWave::getSample(
-    float fundamentalFrequency,
-    float phase,
-    float phaseIncrement) {
+float PeriodicWave::getSample(float fundamentalFrequency, float phase, float phaseIncrement) {
   float *lowerWaveData = nullptr;
   float *higherWaveData = nullptr;
 
-  auto interpolationFactor = getWaveDataForFundamentalFrequency(
-      fundamentalFrequency, lowerWaveData, higherWaveData);
+  auto interpolationFactor =
+      getWaveDataForFundamentalFrequency(fundamentalFrequency, lowerWaveData, higherWaveData);
 
-  return doInterpolation(
-      phase,
-      phaseIncrement,
-      interpolationFactor,
-      lowerWaveData,
-      higherWaveData);
+  return doInterpolation(phase, phaseIncrement, interpolationFactor, lowerWaveData, higherWaveData);
 }
 
 int PeriodicWave::getMaxNumberOfPartials() const {
@@ -122,7 +116,7 @@ int PeriodicWave::getNumberOfPartialsPerRange(int rangeIndex) const {
 
   // The very top range will have all the partials culled.
   int numberOfPartials =
-      int(static_cast<float>(getMaxNumberOfPartials()) * cullingScale);
+      static_cast<int>(static_cast<float>(getMaxNumberOfPartials()) * cullingScale);
 
   return numberOfPartials;
 }
@@ -230,8 +224,7 @@ void PeriodicWave::createBandLimitedTables(
     fft_->doInverseFFT(complexFFTData, bandLimitedTables_[rangeIndex]);
 
     if (!disableNormalization_ && rangeIndex == 0) {
-      float maxValue =
-          dsp::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
+      float maxValue = dsp::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
       if (maxValue != 0) {
         normalizationFactor = 1.0f / maxValue;
       }
@@ -254,20 +247,17 @@ float PeriodicWave::getWaveDataForFundamentalFrequency(
 
   // calculating lower and higher range index for the given fundamental
   // frequency.
-  float ratio = fundamentalFrequency > 0
-      ? fundamentalFrequency / lowestFundamentalFrequency_
-      : 0.5f;
+  float ratio =
+      fundamentalFrequency > 0 ? fundamentalFrequency / lowestFundamentalFrequency_ : 0.5f;
   float centsAboveLowestFrequency = log2f(ratio) * 1200;
 
   float pitchRange = 1 + centsAboveLowestFrequency / CentsPerRange;
 
-  pitchRange =
-      std::clamp(pitchRange, 0.0f, static_cast<float>(numberOfRanges_ - 1));
+  pitchRange = std::clamp(pitchRange, 0.0f, static_cast<float>(numberOfRanges_ - 1));
 
   int lowerRangeIndex = static_cast<int>(pitchRange);
-  int higherRangeIndex = lowerRangeIndex < numberOfRanges_ - 1
-      ? lowerRangeIndex + 1
-      : lowerRangeIndex;
+  int higherRangeIndex =
+      lowerRangeIndex < numberOfRanges_ - 1 ? lowerRangeIndex + 1 : lowerRangeIndex;
 
   // get the wave data for the lower and higher range index.
   lowerWaveData = bandLimitedTables_[lowerRangeIndex];
@@ -297,8 +287,7 @@ float PeriodicWave::doInterpolation(
 
     for (int i = 0; i < 2; i++) {
       indices[i] = (index + i) &
-          (getPeriodicWaveSize() -
-           1); // more efficient alternative to % getPeriodicWaveSize()
+          (getPeriodicWaveSize() - 1); // more efficient alternative to % getPeriodicWaveSize()
     }
 
     auto lowerWaveDataSample1 = lowerWaveData[indices[0]];
@@ -306,10 +295,8 @@ float PeriodicWave::doInterpolation(
     auto higherWaveDataSample1 = higherWaveData[indices[0]];
     auto higherWaveDataSample2 = higherWaveData[indices[1]];
 
-    lowerWaveDataSample =
-        (1 - factor) * lowerWaveDataSample1 + factor * lowerWaveDataSample2;
-    higherWaveDataSample =
-        (1 - factor) * higherWaveDataSample1 + factor * higherWaveDataSample2;
+    lowerWaveDataSample = (1 - factor) * lowerWaveDataSample1 + factor * lowerWaveDataSample2;
+    higherWaveDataSample = (1 - factor) * higherWaveDataSample1 + factor * higherWaveDataSample2;
   } else if (phaseIncrement >= interpolate3Point) { // 3-point Lagrange
                                                     // interpolation
     int indices[3];

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

@@ -33,17 +33,14 @@
 
 #include <algorithm>
 #include <cmath>
+#include <complex>
 #include <memory>
 #include <vector>
-#include <complex>
 
 namespace audioapi {
 class PeriodicWave {
  public:
-  explicit PeriodicWave(
-      float sampleRate,
-      OscillatorType type,
-      bool disableNormalization);
+  explicit PeriodicWave(float sampleRate, OscillatorType type, bool disableNormalization);
   explicit PeriodicWave(
       float sampleRate,
       const std::vector<std::complex<float>> &complexData,
@@ -54,8 +51,7 @@ class PeriodicWave {
   [[nodiscard]] int getPeriodicWaveSize() const;
   [[nodiscard]] float getScale() const;
 
-  float
-  getSample(float fundamentalFrequency, float phase, float phaseIncrement);
+  float getSample(float fundamentalFrequency, float phase, float phaseIncrement);
 
  private:
   explicit PeriodicWave(float sampleRate, bool disableNormalization);
@@ -80,8 +76,7 @@ class PeriodicWave {
   // The higher frequencies are culled to band-limit the waveform.
   // For each range, the inverse FFT is performed to get the time domain
   // representation of the band-limited waveform.
-  void
-  createBandLimitedTables(const std::vector<std::complex<float>> &complexData, int size);
+  void createBandLimitedTables(const std::vector<std::complex<float>> &complexData, int size);
 
   // This function returns the interpolation factor between the lower and higher
   // range data and sets the lower and higher wave data for the given

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

@@ -3,13 +3,13 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 // https://webaudio.github.io/web-audio-api/#stereopanner-algorithm
 
 namespace audioapi {
 
-StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
-    : AudioNode(context) {
+StereoPannerNode::StereoPannerNode(BaseAudioContext *context) : AudioNode(context) {
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
   panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context);
   isInitialized_ = true;
@@ -26,9 +26,8 @@ std::shared_ptr<AudioBus> StereoPannerNode::processNode(
   double deltaTime = 1.0 / context_->getSampleRate();
 
   auto *inputLeft = processingBus->getChannelByType(AudioBus::ChannelLeft);
-  auto panParamValues = panParam_->processARateParam(framesToProcess, time)
-                            ->getChannel(0)
-                            ->getData();
+  auto panParamValues =
+      panParam_->processARateParam(framesToProcess, time)->getChannel(0)->getData();
 
   auto *outputLeft = audioBus_->getChannelByType(AudioBus::ChannelLeft);
   auto *outputRight = audioBus_->getChannelByType(AudioBus::ChannelRight);

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

@@ -4,8 +4,8 @@
 #include <audioapi/core/AudioParam.h>
 
 #include <algorithm>
-#include <memory>
 #include <cassert>
+#include <memory>
 
 namespace audioapi {
 
@@ -18,7 +18,9 @@ class StereoPannerNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> panParam_;