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

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

@@ -2,7 +2,10 @@
 #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/DelayNode.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <audioapi/core/effects/IIRFilterNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
@@ -12,7 +15,9 @@
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/core/sources/StreamerNode.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
@@ -21,12 +26,15 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
-    const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
+    const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
@@ -70,8 +78,7 @@ std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     bool shouldLockRuntime) {
   WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletSourceNode =
-      std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
+  auto workletSourceNode = std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
   nodeManager_->addSourceNode(workletSourceNode);
   return workletSourceNode;
 }
@@ -89,8 +96,7 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
   return workletNode;
 }
 
-std::shared_ptr<WorkletProcessingNode>
-BaseAudioContext::createWorkletProcessingNode(
+std::shared_ptr<WorkletProcessingNode> BaseAudioContext::createWorkletProcessingNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     bool shouldLockRuntime) {
@@ -119,13 +125,15 @@ std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
   return constantSource;
 }
 
-#ifndef AUDIO_API_TEST_SUITE
 std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   auto streamer = std::make_shared<StreamerNode>(this);
   nodeManager_->addSourceNode(streamer);
   return streamer;
+#else
+  return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
-#endif
 
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   auto gain = std::make_shared<GainNode>(this);
@@ -133,6 +141,12 @@ std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   return gain;
 }
 
+std::shared_ptr<DelayNode> BaseAudioContext::createDelay(float maxDelayTime) {
+  auto delay = std::make_shared<DelayNode>(this, maxDelayTime);
+  nodeManager_->addProcessingNode(delay);
+  return delay;
+}
+
 std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
   auto stereoPanner = std::make_shared<StereoPannerNode>(this);
   nodeManager_->addProcessingNode(stereoPanner);
@@ -145,26 +159,29 @@ std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
   return biquadFilter;
 }
 
-std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
-    bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
+std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(
+    const std::vector<float> &feedforward,
+    const std::vector<float> &feedback) {
+  auto iirFilter = std::make_shared<IIRFilterNode>(this, feedforward, feedback);
+  nodeManager_->addProcessingNode(iirFilter);
+  return iirFilter;
+}
+
+std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(bool pitchCorrection) {
+  auto bufferSource = std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
-std::shared_ptr<AudioBufferQueueSourceNode>
-BaseAudioContext::createBufferQueueSource(bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
+std::shared_ptr<AudioBufferQueueSourceNode> BaseAudioContext::createBufferQueueSource(
+    bool pitchCorrection) {
+  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
-std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
-    int numberOfChannels,
-    size_t length,
-    float sampleRate) {
+std::shared_ptr<AudioBuffer>
+BaseAudioContext::createBuffer(int numberOfChannels, size_t length, float sampleRate) {
   return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
 }
 
@@ -172,8 +189,7 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
     const std::vector<std::complex<float>> &complexData,
     bool disableNormalization,
     int length) {
-  return std::make_shared<PeriodicWave>(
-      sampleRate_, complexData, length, disableNormalization);
+  return std::make_shared<PeriodicWave>(sampleRate_, complexData, length, disableNormalization);
 }
 
 std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
@@ -182,6 +198,14 @@ 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();
 }
@@ -215,36 +239,30 @@ std::string BaseAudioContext::toString(ContextState state) {
   }
 }
 
-std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(
-    OscillatorType type) {
+std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType type) {
   switch (type) {
     case OscillatorType::SINE:
       if (cachedSineWave_ == nullptr) {
-        cachedSineWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSineWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSineWave_;
     case OscillatorType::SQUARE:
       if (cachedSquareWave_ == nullptr) {
-        cachedSquareWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSquareWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSquareWave_;
     case OscillatorType::SAWTOOTH:
       if (cachedSawtoothWave_ == nullptr) {
-        cachedSawtoothWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        cachedSawtoothWave_ = std::make_shared<PeriodicWave>(sampleRate_, type, false);
       }
       return cachedSawtoothWave_;
     case OscillatorType::TRIANGLE:
       if (cachedTriangleWave_ == nullptr) {
-        cachedTriangleWave_ =
-            std::make_shared<PeriodicWave>(sampleRate_, type, false);
+        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.");
+      throw std::invalid_argument("You can't get a custom wave form. You need to create it.");
       break;
   }
 }

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

@@ -16,6 +16,7 @@ namespace audioapi {
 
 class AudioBus;
 class GainNode;
+class DelayNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
@@ -23,11 +24,13 @@ class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
+class IIRFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
+class ConvolverNode;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
 class WorkletSourceNode;
@@ -37,7 +40,9 @@ class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit BaseAudioContext(
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -48,25 +53,29 @@ class BaseAudioContext {
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
   std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      bool shouldLockRuntime = true);
   std::shared_ptr<WorkletNode> createWorkletNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    size_t bufferLength,
-    size_t inputChannelCount,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      size_t bufferLength,
+      size_t inputChannelCount,
+      bool shouldLockRuntime = true);
   std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime = true);
+      std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
+      bool shouldLockRuntime = true);
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
   std::shared_ptr<GainNode> createGain();
+  std::shared_ptr<DelayNode> createDelay(float maxDelayTime);
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
+  std::shared_ptr<IIRFilterNode> createIIRFilter(
+      const std::vector<float> &feedforward,
+      const std::vector<float> &feedback);
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
   std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
   static std::shared_ptr<AudioBuffer>
@@ -76,6 +85,9 @@ 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;
@@ -103,8 +115,8 @@ class BaseAudioContext {
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 
  public:
-    std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
-    RuntimeRegistry runtimeRegistry_;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <cassert>
 #include <iostream>
+#include <memory>
 #include <thread>
 #include <utility>
 
@@ -21,16 +22,15 @@ OfflineAudioContext::OfflineAudioContext(
     int numberOfChannels,
     size_t length,
     float sampleRate,
-    const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
+    const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
     : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
-  resultBus_ = std::make_shared<AudioBus>(
-      static_cast<int>(length_), numberOfChannels_, sampleRate_);
+  resultBus_ =
+      std::make_shared<AudioBus>(static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }
 
 OfflineAudioContext::~OfflineAudioContext() {
@@ -47,21 +47,18 @@ void OfflineAudioContext::resume() {
   renderAudio();
 }
 
-void OfflineAudioContext::suspend(
-    double when,
-    const std::function<void()> &callback) {
+void OfflineAudioContext::suspend(double when, const std::function<void()> &callback) {
   Locker locker(mutex_);
 
   // we can only suspend once per render quantum at the end of the quantum
   // first quantum is [0, RENDER_QUANTUM_SIZE)
   auto frame = static_cast<size_t>(when * sampleRate_);
-  frame = RENDER_QUANTUM_SIZE *
-      ((frame + RENDER_QUANTUM_SIZE - 1) / RENDER_QUANTUM_SIZE);
+  frame = RENDER_QUANTUM_SIZE * ((frame + RENDER_QUANTUM_SIZE - 1) / RENDER_QUANTUM_SIZE);
 
   if (scheduledSuspends_.find(frame) != scheduledSuspends_.end()) {
     throw std::runtime_error(
-        "cannot schedule more than one suspend at frame " +
-        std::to_string(frame) + " (" + std::to_string(when) + " seconds)");
+        "cannot schedule more than one suspend at frame " + std::to_string(frame) + " (" +
+        std::to_string(when) + " seconds)");
   }
 
   scheduledSuspends_.emplace(frame, callback);
@@ -70,13 +67,12 @@ void OfflineAudioContext::suspend(
 void OfflineAudioContext::renderAudio() {
   state_ = ContextState::RUNNING;
   std::thread([this]() {
-    auto audioBus = std::make_shared<AudioBus>(
-        RENDER_QUANTUM_SIZE, numberOfChannels_, sampleRate_);
+    auto audioBus = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, numberOfChannels_, sampleRate_);
 
     while (currentSampleFrame_ < length_) {
       Locker locker(mutex_);
-      int framesToProcess = std::min(
-          static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
+      int framesToProcess =
+          std::min(static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
 
       destination_->renderAudio(audioBus, framesToProcess);
 
@@ -107,8 +103,7 @@ void OfflineAudioContext::renderAudio() {
   }).detach();
 }
 
-void OfflineAudioContext::startRendering(
-    OfflineAudioContextResultCallback callback) {
+void OfflineAudioContext::startRendering(OfflineAudioContextResultCallback callback) {
   Locker locker(mutex_);
 
   resultCallback_ = std::move(callback);

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

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "BaseAudioContext.h"
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include "BaseAudioContext.h"
 
-#include <mutex>
 #include <map>
-#include <unordered_map>
 #include <memory>
+#include <mutex>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -15,11 +15,16 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit OfflineAudioContext(
+      int numberOfChannels,
+      size_t length,
+      float sampleRate,
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   ~OfflineAudioContext() override;
 
   void resume();
-  void suspend(double when, const OfflineAudioContextSuspendCallback& callback);
+  void suspend(double when, const OfflineAudioContextSuspendCallback &callback);
 
   void startRendering(OfflineAudioContextResultCallback callback);
 

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_;