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

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp

@@ -8,6 +8,13 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
+#include <algorithm>
+#include <memory>
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
@@ -22,10 +29,9 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
     // to compensate for processing latency.
     addExtraTailFrames_ = true;
 
-    int extraTailFrames =
-        static_cast<int>(stretch_->inputLatency() + stretch_->outputLatency());
-    tailBuffer_ = std::make_shared<AudioBuffer>(
-        channelCount_, extraTailFrames, context_->getSampleRate());
+    int extraTailFrames = static_cast<int>(stretch_->inputLatency() + stretch_->outputLatency());
+    tailBuffer_ =
+        std::make_shared<AudioBuffer>(channelCount_, extraTailFrames, context_->getSampleRate());
 
     tailBuffer_->bus_->zero();
   }
@@ -54,8 +60,7 @@ void AudioBufferQueueSourceNode::start(double when, double offset) {
   }
 
   offset = std::min(offset, buffers_.front().second->getDuration());
-  vReadIndex_ =
-      static_cast<double>(buffers_.front().second->getSampleRate() * offset);
+  vReadIndex_ = static_cast<double>(buffers_.front().second->getSampleRate() * offset);
 }
 
 void AudioBufferQueueSourceNode::pause() {
@@ -63,8 +68,7 @@ void AudioBufferQueueSourceNode::pause() {
   isPaused_ = true;
 }
 
-std::string AudioBufferQueueSourceNode::enqueueBuffer(
-    const std::shared_ptr<AudioBuffer> &buffer) {
+std::string AudioBufferQueueSourceNode::enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
   auto locker = Locker(getBufferLock());
   buffers_.emplace(bufferId_, buffer);
 
@@ -140,8 +144,7 @@ std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
 }
 
 double AudioBufferQueueSourceNode::getCurrentPosition() const {
-  return dsp::sampleFrameToTime(
-             static_cast<int>(vReadIndex_), context_->getSampleRate()) +
+  return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), context_->getSampleRate()) +
       playedBuffersDuration_;
 }
 
@@ -173,8 +176,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
     assert(readIndex + framesToCopy <= buffer->getLength());
     assert(writeIndex + framesToCopy <= processingBus->getSize());
 
-    processingBus->copy(
-        buffer->bus_.get(), readIndex, writeIndex, framesToCopy);
+    processingBus->copy(buffer->bus_.get(), readIndex, writeIndex, framesToCopy);
 
     writeIndex += framesToCopy;
     readIndex += framesToCopy;
@@ -229,8 +231,7 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
   while (framesLeft > 0) {
     auto readIndex = static_cast<size_t>(vReadIndex_);
     size_t nextReadIndex = readIndex + 1;
-    auto factor =
-        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
+    auto factor = static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
 
     bool crossBufferInterpolation = false;
     std::shared_ptr<AudioBuffer> nextBuffer = nullptr;
@@ -255,11 +256,10 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
         const float *nextSource = nextBuffer->bus_->getChannel(i)->getData();
         float currentSample = currentSource[readIndex];
         float nextSample = nextSource[nextReadIndex];
-        destination[writeIndex] =
-            currentSample + factor * (nextSample - currentSample);
+        destination[writeIndex] = currentSample + factor * (nextSample - currentSample);
       } else {
-        destination[writeIndex] = dsp::linearInterpolate(
-            currentSource, readIndex, nextReadIndex, factor);
+        destination[writeIndex] =
+            dsp::linearInterpolate(currentSource, readIndex, nextReadIndex, factor);
       }
     }
 
@@ -272,8 +272,7 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
       playedBuffersDuration_ += buffer->getDuration();
       buffers_.pop();
 
-      std::unordered_map<std::string, EventValue> body = {
-          {"bufferId", std::to_string(bufferId)}};
+      std::unordered_map<std::string, EventValue> body = {{"bufferId", std::to_string(bufferId)}};
       context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
           "ended", onEndedCallbackId_, body);
 

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h

@@ -4,11 +4,11 @@
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
-#include <memory>
-#include <cstddef>
 #include <algorithm>
-#include <string>
+#include <cstddef>
+#include <memory>
 #include <queue>
+#include <string>
 
 namespace audioapi {
 
@@ -17,46 +17,48 @@ class AudioParam;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
-    explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
-    ~AudioBufferQueueSourceNode() override;
+  explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  ~AudioBufferQueueSourceNode() override;
 
-    void stop(double when) override;
+  void stop(double when) override;
 
-    using AudioScheduledSourceNode::start;
-    void start(double when, double offset);
-    void pause();
+  using AudioScheduledSourceNode::start;
+  void start(double when, double offset);
+  void pause();
 
-    std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-    void dequeueBuffer(size_t bufferId);
-    void clearBuffers();
-    void disable() override;
+  std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+  void dequeueBuffer(size_t bufferId);
+  void clearBuffers();
+  void disable() override;
 
  protected:
-    std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-    double getCurrentPosition() const override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+  double getCurrentPosition() const override;
 
  private:
-    // User provided buffers
-    std::queue<std::pair<size_t, std::shared_ptr<AudioBuffer>>> buffers_;
-    size_t bufferId_ = 0;
-
-    bool isPaused_ = false;
-    bool addExtraTailFrames_ = false;
-    std::shared_ptr<AudioBuffer> tailBuffer_;
-
-    double playedBuffersDuration_ = 0;
-
-    void processWithoutInterpolation(
-            const std::shared_ptr<AudioBus>& processingBus,
-            size_t startOffset,
-            size_t offsetLength,
-            float playbackRate) override;
-
-    void processWithInterpolation(
-            const std::shared_ptr<AudioBus>& processingBus,
-            size_t startOffset,
-            size_t offsetLength,
-            float playbackRate) override;
+  // User provided buffers
+  std::queue<std::pair<size_t, std::shared_ptr<AudioBuffer>>> buffers_;
+  size_t bufferId_ = 0;
+
+  bool isPaused_ = false;
+  bool addExtraTailFrames_ = false;
+  std::shared_ptr<AudioBuffer> tailBuffer_;
+
+  double playedBuffersDuration_ = 0;
+
+  void processWithoutInterpolation(
+      const std::shared_ptr<AudioBus> &processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate) override;
+
+  void processWithInterpolation(
+      const std::shared_ptr<AudioBus> &processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate) override;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -7,12 +7,12 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
-AudioBufferSourceNode::AudioBufferSourceNode(
-    BaseAudioContext *context,
-    bool pitchCorrection)
+AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection)
     : AudioBufferBaseSourceNode(context, pitchCorrection),
       loop_(false),
       loopSkip_(false),
@@ -70,8 +70,7 @@ void AudioBufferSourceNode::setLoopEnd(double loopEnd) {
   loopEnd_ = loopEnd;
 }
 
-void AudioBufferSourceNode::setBuffer(
-    const std::shared_ptr<AudioBuffer> &buffer) {
+void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
   Locker locker(getBufferLock());
 
   if (!buffer) {
@@ -87,12 +86,11 @@ void AudioBufferSourceNode::setBuffer(
   stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
 
   if (pitchCorrection_) {
-    int extraTailFrames = static_cast<int>(
-        (getInputLatency() + getOutputLatency()) * context_->getSampleRate());
+    int extraTailFrames =
+        static_cast<int>((getInputLatency() + getOutputLatency()) * context_->getSampleRate());
     size_t totalSize = buffer_->getLength() + extraTailFrames;
 
-    alignedBus_ = std::make_shared<AudioBus>(
-        totalSize, channelCount_, buffer_->getSampleRate());
+    alignedBus_ = std::make_shared<AudioBus>(totalSize, channelCount_, buffer_->getSampleRate());
     alignedBus_->copy(buffer_->bus_.get(), 0, 0, buffer_->getLength());
 
     alignedBus_->zero(buffer_->getLength(), extraTailFrames);
@@ -100,10 +98,10 @@ void AudioBufferSourceNode::setBuffer(
     alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
   }
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  playbackRateBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
 }
@@ -119,10 +117,8 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
     return;
   }
 
-  offset = std::min(
-      offset,
-      static_cast<double>(alignedBus_->getSize()) /
-          alignedBus_->getSampleRate());
+  offset =
+      std::min(offset, static_cast<double>(alignedBus_->getSize()) / alignedBus_->getSampleRate());
 
   if (loop_) {
     offset = std::min(offset, loopEnd_);
@@ -137,8 +133,7 @@ void AudioBufferSourceNode::disable() {
 }
 
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  auto oldCallbackId =
-      onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+  auto oldCallbackId = onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
     audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
@@ -170,16 +165,13 @@ std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
 }
 
 double AudioBufferSourceNode::getCurrentPosition() const {
-  return dsp::sampleFrameToTime(
-      static_cast<int>(vReadIndex_), buffer_->getSampleRate());
+  return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), buffer_->getSampleRate());
 }
 
 void AudioBufferSourceNode::sendOnLoopEndedEvent() {
-  auto onLoopEndedCallbackId =
-      onLoopEndedCallbackId_.load(std::memory_order_acquire);
+  auto onLoopEndedCallbackId = onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("loopEnded", onLoopEndedCallbackId, {});
   }
 }
 
@@ -206,10 +198,9 @@ void AudioBufferSourceNode::processWithoutInterpolation(
   // if we are moving towards loop, we do nothing because we will achieve it
   // otherwise, we wrap to the start of the loop if necessary
   if (loop_ &&
-      ((readIndex >= frameEnd && direction == 1) ||
-       (readIndex < frameStart && direction == -1))) {
+      ((readIndex >= frameEnd && direction == 1) || (readIndex < frameStart && direction == -1))) {
     readIndex = frameStart +
-        ((long long int)readIndex - (long long int)frameStart) % frameDelta;
+        (static_cast<int64_t>(readIndex) - static_cast<int64_t>(frameStart)) % frameDelta;
   }
 
   while (framesLeft > 0) {
@@ -224,8 +215,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 
     // Direction is forward, we can normally copy the data
     if (direction == 1) {
-      processingBus->copy(
-          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
+      processingBus->copy(alignedBus_.get(), readIndex, writeIndex, framesToCopy);
     } else {
       for (int i = 0; i < framesToCopy; i += 1) {
         for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
@@ -241,8 +231,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 
     // if we are moving towards loop, we do nothing because we will achieve it
     // otherwise, we wrap to the start of the loop if necessary
-    if ((readIndex >= frameEnd && direction == 1) ||
-        (readIndex < frameStart && direction == -1)) {
+    if ((readIndex >= frameEnd && direction == 1) || (readIndex < frameStart && direction == -1)) {
       readIndex -= direction * frameDelta;
 
       if (!loop_) {
@@ -279,15 +268,13 @@ void AudioBufferSourceNode::processWithInterpolation(
 
   // Wrap to the start of the loop if necessary
   if (loop_ && (vReadIndex_ >= vFrameEnd || vReadIndex_ < vFrameStart)) {
-    vReadIndex_ =
-        vFrameStart + std::fmod(vReadIndex_ - vFrameStart, vFrameDelta);
+    vReadIndex_ = vFrameStart + std::fmod(vReadIndex_ - vFrameStart, vFrameDelta);
   }
 
   while (framesLeft > 0) {
     auto readIndex = static_cast<size_t>(vReadIndex_);
     size_t nextReadIndex = readIndex + 1;
-    auto factor =
-        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
+    auto factor = static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
 
     if (nextReadIndex >= frameEnd) {
       nextReadIndex = loop_ ? frameStart : readIndex;
@@ -297,8 +284,7 @@ void AudioBufferSourceNode::processWithInterpolation(
       float *destination = processingBus->getChannel(i)->getData();
       const float *source = alignedBus_->getChannel(i)->getData();
 
-      destination[writeIndex] =
-          dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
+      destination[writeIndex] = dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
     }
 
     writeIndex += 1;
@@ -322,8 +308,7 @@ void AudioBufferSourceNode::processWithInterpolation(
 double AudioBufferSourceNode::getVirtualStartFrame() {
   auto loopStartFrame = loopStart_ * context_->getSampleRate();
 
-  return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame
-                                                               : 0.0;
+  return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame : 0.0;
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h

@@ -38,7 +38,9 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
  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;
   double getCurrentPosition() const override;
 
  private:

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -10,6 +10,10 @@
 #include <audioapi/core/AudioContext.h>
 #endif
 
+#include <algorithm>
+#include <limits>
+#include <memory>
+
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
@@ -57,8 +61,7 @@ bool AudioScheduledSourceNode::isStopScheduled() {
 }
 
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
-  auto oldCallbackId =
-      onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+  auto oldCallbackId = onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
     audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
@@ -83,11 +86,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   size_t firstFrame = context_->getCurrentSampleFrame();
   size_t lastFrame = firstFrame + framesToProcess - 1;
 
-  size_t startFrame =
-      std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
-  size_t stopFrame = stopTime_ == -1.0
-      ? std::numeric_limits<size_t>::max()
-      : dsp::timeToSampleFrame(stopTime_, sampleRate);
+  size_t startFrame = std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t stopFrame = stopTime_ == -1.0 ? std::numeric_limits<size_t>::max()
+                                       : dsp::timeToSampleFrame(stopTime_, sampleRate);
   if (isFinished()) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
@@ -166,8 +167,7 @@ void AudioScheduledSourceNode::disable() {
 
   auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
   if (onEndedCallbackId != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "ended", onEndedCallbackId, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("ended", onEndedCallbackId, {});
   }
 }
 

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -4,14 +4,14 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cassert>
 #include <chrono>
+#include <cstddef>
 #include <functional>
 #include <iostream>
 #include <limits>
 #include <memory>
 #include <thread>
-#include <cstddef>
-#include <cassert>
 #include <utility>
 
 namespace audioapi {
@@ -51,7 +51,7 @@ class AudioScheduledSourceNode : public AudioNode {
   std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   void updatePlaybackInfo(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess,
       size_t &startOffset,
       size_t &nonSilentFramesToProcess);

package/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 
 namespace audioapi {
 ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
@@ -29,13 +30,11 @@ std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
     return processingBus;
   }
 
-  auto offsetBus = offsetParam_->processARateParam(
-      framesToProcess, context_->getCurrentTime());
+  auto offsetBus = offsetParam_->processARateParam(framesToProcess, context_->getCurrentTime());
 
   auto offsetChannelData = offsetBus->getChannel(0)->getData();
 
-  for (int channel = 0; channel < processingBus->getNumberOfChannels();
-       ++channel) {
+  for (int channel = 0; channel < processingBus->getNumberOfChannels(); ++channel) {
     auto outputChannelData = processingBus->getChannel(channel)->getData();
 
     std::copy(

package/common/cpp/audioapi/core/sources/ConstantSourceNode.h

@@ -18,7 +18,9 @@ class ConstantSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() 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> offsetParam_;

package/common/cpp/audioapi/core/sources/OscillatorNode.cpp

@@ -3,16 +3,14 @@
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context) {
+OscillatorNode::OscillatorNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0,
-      -context_->getNyquistFrequency(),
-      context_->getNyquistFrequency(),
-      context);
+      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
@@ -21,8 +19,7 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   isInitialized_ = true;
 }
@@ -44,8 +41,7 @@ void OscillatorNode::setType(const std::string &type) {
   periodicWave_ = context_->getBasicWaveForm(type_);
 }
 
-void OscillatorNode::setPeriodicWave(
-    const std::shared_ptr<PeriodicWave> &periodicWave) {
+void OscillatorNode::setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave) {
   periodicWave_ = periodicWave;
   type_ = OscillatorType::CUSTOM;
 }
@@ -65,29 +61,22 @@ std::shared_ptr<AudioBus> OscillatorNode::processNode(
 
   auto time = context_->getCurrentTime() +
       static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
-  auto detuneParamValues =
-      detuneParam_->processARateParam(framesToProcess, time);
-  auto frequencyParamValues =
-      frequencyParam_->processARateParam(framesToProcess, time);
+  auto detuneParamValues = detuneParam_->processARateParam(framesToProcess, time);
+  auto frequencyParamValues = frequencyParam_->processARateParam(framesToProcess, time);
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
-    auto detuneRatio = std::pow(
-        2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
-    auto detunedFrequency =
-        frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
+    auto detuneRatio = std::pow(2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
+    auto detunedFrequency = frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
-    float sample =
-        periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
+    float sample = periodicWave_->getSample(detunedFrequency, phase_, phaseIncrement);
 
     for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
       (*processingBus->getChannel(j))[i] = sample;
     }
 
     phase_ += phaseIncrement;
-    phase_ -=
-        floor(
-            phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
+    phase_ -= floor(phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
         static_cast<float>(periodicWave_->getPeriodicWaveSize());
   }
 

package/common/cpp/audioapi/core/sources/OscillatorNode.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/PeriodicWave.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/types/OscillatorType.h>
-#include <audioapi/core/effects/PeriodicWave.h>
 
+#include <algorithm>
 #include <cmath>
 #include <memory>
 #include <string>
@@ -24,7 +25,9 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  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> frequencyParam_;
@@ -35,8 +38,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
 
   static OscillatorType 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 == "sine")
       return OscillatorType::SINE;

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp

@@ -2,6 +2,7 @@
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
 #include <type_traits>
 
 namespace audioapi {
@@ -30,8 +31,7 @@ std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
   readFrames(outputChannel, framesToProcess);
 
   for (int i = 1; i < processingBus->getNumberOfChannels(); i++) {
-    processingBus->getChannel(i)->copy(
-        processingBus->getChannel(0), 0, framesToProcess);
+    processingBus->getChannel(i)->copy(processingBus->getChannel(0), 0, framesToProcess);
   }
 
   return processingBus;
@@ -42,8 +42,7 @@ void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {
 
   if (readFrames < framesToRead) {
     // Fill the rest with silence
-    std::memset(
-        output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
+    std::memset(output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
   }
 }