react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -6,6 +6,10 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace audioapi {
 AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
@@ -18,8 +22,7 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
   inputBuffer_ = std::make_unique<CircularAudioArray>(MAX_FFT_SIZE * 2);
   tempBuffer_ = std::make_unique<AudioArray>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
-  downMixBus_ = std::make_unique<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+  downMixBus_ = std::make_unique<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   fft_ = std::make_unique<dsp::FFT>(fftSize_);
   complexData_ = std::vector<std::complex<float>>(fftSize_);
@@ -100,9 +103,8 @@ void AnalyserNode::getByteFrequencyData(uint8_t *data, int length) {
       maxDecibels_ == minDecibels_ ? 1 : 1 / (maxDecibels_ - minDecibels_);
 
   for (int i = 0; i < length; i++) {
-    auto dbMag = magnitudeBufferData[i] == 0
-        ? minDecibels_
-        : dsp::linearToDecibels(magnitudeBufferData[i]);
+    auto dbMag =
+        magnitudeBufferData[i] == 0 ? minDecibels_ : dsp::linearToDecibels(magnitudeBufferData[i]);
     auto scaledValue = UINT8_MAX * (dbMag - minDecibels_) * rangeScaleFactor;
 
     if (scaledValue < 0) {
@@ -124,8 +126,7 @@ void AnalyserNode::getFloatTimeDomainData(float *data, int length) {
 void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   auto size = std::min(fftSize_, length);
 
-  inputBuffer_->pop_back(
-      tempBuffer_->getData(), fftSize_, std::max(0, fftSize_ - size), true);
+  inputBuffer_->pop_back(tempBuffer_->getData(), fftSize_, std::max(0, fftSize_ - size), true);
 
   for (int i = 0; i < size; i++) {
     auto value = tempBuffer_->getData()[i];
@@ -152,8 +153,7 @@ std::shared_ptr<AudioBus> AnalyserNode::processNode(
   // Down mix the input bus to mono
   downMixBus_->copy(processingBus.get());
   // Copy the down mixed bus to the input buffer (circular buffer)
-  inputBuffer_->push_back(
-      downMixBus_->getChannel(0)->getData(), framesToProcess, true);
+  inputBuffer_->push_back(downMixBus_->getChannel(0)->getData(), framesToProcess, true);
 
   shouldDoFFTAnalysis_ = true;
 
@@ -171,11 +171,7 @@ void AnalyserNode::doFFTAnalysis() {
   // the window.
   inputBuffer_->pop_back(tempBuffer_->getData(), fftSize_, 0, true);
 
-  dsp::multiply(
-      tempBuffer_->getData(),
-      windowData_->getData(),
-      tempBuffer_->getData(),
-      fftSize_);
+  dsp::multiply(tempBuffer_->getData(), windowData_->getData(), tempBuffer_->getData(), fftSize_);
 
   // do fft analysis - get frequency domain data
   fft_->doFFT(tempBuffer_->getData(), complexData_);
@@ -194,9 +190,7 @@ void AnalyserNode::doFFTAnalysis() {
   }
 }
 
-void AnalyserNode::setWindowData(
-    audioapi::AnalyserNode::WindowType type,
-    int size) {
+void AnalyserNode::setWindowData(audioapi::AnalyserNode::WindowType type, int size) {
   if (windowType_ == type && windowData_ && windowData_->getSize() == size) {
     return;
   }
@@ -207,12 +201,10 @@ void AnalyserNode::setWindowData(
 
   switch (windowType_) {
     case WindowType::BLACKMAN:
-      dsp::Blackman().apply(
-          windowData_->getData(), static_cast<int>(windowData_->getSize()));
+      dsp::Blackman().apply(windowData_->getData(), static_cast<int>(windowData_->getSize()));
       break;
     case WindowType::HANN:
-      dsp::Hann().apply(
-          windowData_->getData(), static_cast<int>(windowData_->getSize()));
+      dsp::Hann().apply(windowData_->getData(), static_cast<int>(windowData_->getSize()));
       break;
   }
 }

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -3,10 +3,11 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/dsp/FFT.h>
 
-#include <memory>
+#include <algorithm>
+#include <complex>
 #include <cstddef>
+#include <memory>
 #include <string>
-#include <complex>
 #include <vector>
 
 namespace audioapi {
@@ -39,7 +40,9 @@ class AnalyserNode : public AudioNode {
   void getByteTimeDomainData(uint8_t *data, int length);
 
  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:
   int fftSize_;
@@ -57,12 +60,11 @@ class AnalyserNode : public AudioNode {
   std::unique_ptr<dsp::FFT> fft_;
   std::vector<std::complex<float>> complexData_;
   std::unique_ptr<AudioArray> magnitudeBuffer_;
-  bool shouldDoFFTAnalysis_ { true };
+  bool shouldDoFFTAnalysis_{true};
 
   static WindowType 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 == "blackman") {
       return WindowType::BLACKMAN;
     }

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 namespace audioapi {
 

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.h

@@ -3,9 +3,9 @@
 #include <audioapi/core/AudioNode.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 
@@ -19,12 +19,14 @@ class AudioDestinationNode : public AudioNode {
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;
 
-  void renderAudio(const std::shared_ptr<AudioBus>& audioData, int numFrames);
+  void renderAudio(const std::shared_ptr<AudioBus> &audioData, int numFrames);
 
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int) final { return processingBus; };
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &processingBus, int) final {
+    return processingBus;
+  };
 
  private:
   std::size_t currentSampleFrame_;

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

@@ -30,16 +30,17 @@
 #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.0f,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
@@ -48,10 +49,7 @@ BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
   QParam_ = std::make_shared<AudioParam>(
       1.0f, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   gainParam_ = std::make_shared<AudioParam>(
-      0.0f,
-      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;
@@ -131,11 +129,9 @@ void BiquadFilterNode::getFrequencyResponse(
 
     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);
+    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)));
   }
 }
 
@@ -173,8 +169,7 @@ 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) {
@@ -194,8 +189,7 @@ 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) {
@@ -215,8 +209,7 @@ 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) {
@@ -275,10 +268,7 @@ 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.0f || frequency >= 1.0f) {
@@ -296,12 +286,7 @@ 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) {
@@ -319,8 +304,7 @@ 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) {
@@ -338,17 +322,14 @@ 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);
 

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

@@ -95,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;
@@ -141,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

@@ -6,7 +6,9 @@
 #include <audioapi/dsp/FFT.h>
 #include <audioapi/utils/AudioArray.h>
 #include <iostream>
+#include <memory>
 #include <thread>
+#include <vector>
 
 namespace audioapi {
 ConvolverNode::ConvolverNode(
@@ -26,8 +28,8 @@ ConvolverNode::ConvolverNode(
   normalize_ = !disableNormalization;
   gainCalibrationSampleRate_ = context->getSampleRate();
   setBuffer(buffer);
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
   isInitialized_ = true;
 }
 
@@ -60,26 +62,18 @@ void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
     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());
+      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());
+      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());
+    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;
@@ -123,8 +117,7 @@ std::shared_ptr<AudioBus> ConvolverNode::processNode(
     performConvolution(processingBus); // result returned to intermediateBus_
     audioBus_->sum(intermediateBus_.get());
 
-    internalBuffer_->copy(
-        audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
+    internalBuffer_->copy(audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
     internalBufferIndex_ += RENDER_QUANTUM_SIZE;
   }
   audioBus_->zero();
@@ -176,14 +169,12 @@ void ConvolverNode::calculateNormalizationScale() {
   scaleFactor_ *= gainCalibrationSampleRate_ / buffer_->getSampleRate();
 }
 
-void ConvolverNode::performConvolution(
-    const std::shared_ptr<AudioBus> &processingBus) {
+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());
+            processingBus->getChannel(0)->getData(), intermediateBus_->getChannel(i)->getData());
       });
     }
   } else if (processingBus->getNumberOfChannels() == 2) {
@@ -197,12 +188,11 @@ void ConvolverNode::performConvolution(
       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_->schedule([this, i, inputChannelMap, outputChannelMap, &processingBus] {
+        convolvers_[i].process(
+            processingBus->getChannel(inputChannelMap[i])->getData(),
+            intermediateBus_->getChannel(outputChannelMap[i])->getData());
+      });
     }
   }
   threadPool_->wait();

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

@@ -9,7 +9,8 @@
 
 #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 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 {
@@ -19,18 +20,26 @@ class AudioBuffer;
 
 class ConvolverNode : public AudioNode {
  public:
-    explicit ConvolverNode(BaseAudioContext *context, const std::shared_ptr<AudioBuffer>& buffer, bool disableNormalization);
+  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);
+  [[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;
+  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;
+  std::shared_ptr<AudioBus> processInputs(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed) override;
   void onInputDisabled() override;
   float gainCalibrationSampleRate_;
   size_t remainingSegments_;
@@ -38,7 +47,7 @@ class ConvolverNode : public AudioNode {
   bool normalize_;
   bool signalledToStop_;
   float scaleFactor_;
-  std::shared_ptr<AudioBus>intermediateBus_;
+  std::shared_ptr<AudioBus> intermediateBus_;
 
   // impulse response buffer
   std::shared_ptr<AudioBuffer> buffer_;
@@ -49,7 +58,7 @@ class ConvolverNode : public AudioNode {
   std::shared_ptr<ThreadPool> threadPool_;
 
   void calculateNormalizationScale();
-  void performConvolution(const std::shared_ptr<AudioBus>& processingBus);
+  void performConvolution(const std::shared_ptr<AudioBus> &processingBus);
 };
 
 } // 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/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