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

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

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

@@ -1,4 +1,8 @@
 #include <audioapi/core/effects/WorkletNode.h>
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -12,8 +16,7 @@ WorkletNode::WorkletNode(
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  bus_ = std::make_shared<AudioBus>(
-      bufferLength, inputChannelCount, context->getSampleRate());
+  bus_ = std::make_shared<AudioBus>(bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 
@@ -21,9 +24,8 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t processed = 0;
-  size_t channelCount_ = std::min(
-      inputChannelCount_,
-      static_cast<size_t>(processingBus->getNumberOfChannels()));
+  size_t channelCount_ =
+      std::min(inputChannelCount_, static_cast<size_t>(processingBus->getNumberOfChannels()));
   while (processed < framesToProcess) {
     size_t framesToWorkletInvoke = bufferLength_ - curBuffIndex_;
     size_t needsToProcess = framesToProcess - processed;
@@ -43,8 +45,7 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     }
     // Reset buffer index, channel buffers and execute worklet
     curBuffIndex_ = 0;
-    workletRunner_.executeOnRuntimeSync([this, channelCount_](
-                                            jsi::Runtime &uiRuntimeRaw) {
+    workletRunner_.executeOnRuntimeSync([this, channelCount_](jsi::Runtime &uiRuntimeRaw) {
       /// Arguments preparation
       auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
       for (size_t ch = 0; ch < channelCount_; ch++) {
@@ -52,10 +53,8 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
         audioArray->copy(bus_->getChannel(ch));
         auto sharedAudioArray = std::make_shared<AudioArrayBuffer>(audioArray);
         auto sharedAudioArraySize = sharedAudioArray->size();
-        auto arrayBuffer =
-            jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
-        arrayBuffer.setExternalMemoryPressure(
-            uiRuntimeRaw, sharedAudioArraySize);
+        auto arrayBuffer = jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+        arrayBuffer.setExternalMemoryPressure(uiRuntimeRaw, sharedAudioArraySize);
         jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
       }
 
@@ -63,8 +62,7 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
 
       /// Call the worklet
       workletRunner_.callUnsafe(
-          std::move(jsArray),
-          jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
+          std::move(jsArray), jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
 
       return jsi::Value::undefined();
     });

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

@@ -1,13 +1,12 @@
 #pragma once
 
-
-#include <jsi/jsi.h>
-#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/AudioArray.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <vector>
@@ -21,11 +20,15 @@ class WorkletNode : public AudioNode {
       BaseAudioContext *context,
       size_t bufferLength,
       size_t inputChannelCount,
-      WorkletsRunner &&workletRunner
-  ) : AudioNode(context) {}
+      WorkletsRunner &&workletRunner)
+      : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
@@ -37,14 +40,14 @@ class WorkletNode : public AudioNode {
       BaseAudioContext *context,
       size_t bufferLength,
       size_t inputChannelCount,
-      WorkletsRunner &&workletRunner
-  );
+      WorkletsRunner &&workletRunner);
 
   ~WorkletNode() override = default;
 
  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:
   WorkletsRunner workletRunner_;

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

@@ -1,5 +1,7 @@
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -19,8 +21,7 @@ WorkletProcessingNode::WorkletProcessingNode(
     inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(inputAudioArray);
 
     auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
-    outputBuffsHandles_[i] =
-        std::make_shared<AudioArrayBuffer>(outputAudioArray);
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
 }
 
@@ -52,8 +53,7 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
           inputJsArray.setValueAtIndex(rt, ch, inputArrayBuffer);
 
           // Create output array buffer
-          auto outputArrayBuffer =
-              jsi::ArrayBuffer(rt, outputBuffsHandles_[ch]);
+          auto outputArrayBuffer = jsi::ArrayBuffer(rt, outputBuffsHandles_[ch]);
           outputJsArray.setValueAtIndex(rt, ch, outputArrayBuffer);
         }
 

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

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <jsi/jsi.h>
-#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/AudioArray.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <vector>
@@ -16,13 +16,15 @@ namespace audioapi {
 #if RN_AUDIO_API_TEST
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(
-      BaseAudioContext *context,
-      WorkletsRunner &&workletRunner
-  ) : AudioNode(context) {}
+  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+      : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
@@ -30,13 +32,12 @@ using namespace facebook;
 
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(
-      BaseAudioContext *context,
-      WorkletsRunner &&workletRunner
-  );
+  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
 
  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:
   WorkletsRunner workletRunner_;

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -6,6 +6,10 @@
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -30,8 +34,7 @@ void AudioRecorder::invokeOnAudioReadyCallback(
     const std::shared_ptr<AudioBus> &bus,
     int numFrames) {
   auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject =
-      std::make_shared<AudioBufferHostObject>(audioBuffer);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
 
   std::unordered_map<std::string, EventValue> body = {};
   body.insert({"buffer", audioBufferHostObject});
@@ -44,14 +47,12 @@ void AudioRecorder::invokeOnAudioReadyCallback(
 }
 
 void AudioRecorder::sendRemainingData() {
-  auto bus = std::make_shared<AudioBus>(
-      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
+  auto bus =
+      std::make_shared<AudioBus>(circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
   auto *outputChannel = bus->getChannel(0)->getData();
-  auto availableFrames =
-      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+  auto availableFrames = static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
 
-  circularBuffer_->pop_front(
-      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  circularBuffer_->pop_front(outputChannel, circularBuffer_->getNumberOfAvailableFrames());
 
   invokeOnAudioReadyCallback(bus, availableFrames);
 }

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <memory>
 #include <atomic>
+#include <memory>
 #include <mutex>
 
 namespace audioapi {
@@ -15,10 +15,9 @@ class AudioEventHandlerRegistry;
 class AudioRecorder {
  public:
   explicit AudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
-  );
+      float sampleRate,
+      int bufferLength,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
   virtual ~AudioRecorder() = default;
 

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

@@ -2,14 +2,13 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
+#include <algorithm>
+#include <memory>
 #include <utility>
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(
-    int numberOfChannels,
-    size_t length,
-    float sampleRate) {
+AudioBuffer::AudioBuffer(int numberOfChannels, size_t length, float sampleRate) {
   bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
 }
 
@@ -45,8 +44,7 @@ void AudioBuffer::copyFromChannel(
   memcpy(
       destination,
       bus_->getChannel(channelNumber)->getData() + startInChannel,
-      std::min(destinationLength, getLength() - startInChannel) *
-          sizeof(float));
+      std::min(destinationLength, getLength() - startInChannel) * sizeof(float));
 }
 
 void AudioBuffer::copyToChannel(

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

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <algorithm>
+#include <cstddef>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
-#include <cstddef>
-#include <cstring>
 
 namespace audioapi {
 
@@ -28,11 +28,8 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
       size_t destinationLength,
       int channelNumber,
       size_t startInChannel) const;
-  void copyToChannel(
-      const float *source,
-      size_t sourceLength,
-      int channelNumber,
-      size_t startInChannel);
+  void
+  copyToChannel(const float *source, size_t sourceLength, int channelNumber, size_t startInChannel);
 
  private:
   friend class AudioBufferSourceNode;

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

@@ -5,14 +5,15 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
     BaseAudioContext *context,
     bool pitchCorrection)
-    : AudioScheduledSourceNode(context),
-      pitchCorrection_(pitchCorrection),
-      vReadIndex_(0.0) {
+    : AudioScheduledSourceNode(context), pitchCorrection_(pitchCorrection), vReadIndex_(0.0) {
   onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
 
   detuneParam_ = std::make_shared<AudioParam>(
@@ -20,36 +21,31 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
   playbackRateParam_ = std::make_shared<AudioParam>(
       1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
 
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+  playbackRateBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+  stretch_ = std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }
 
-std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
-    const {
+std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam() const {
   return playbackRateParam_;
 }
 
-void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
-    uint64_t callbackId) {
-  auto oldCallbackId = onPositionChangedCallbackId_.exchange(
-      callbackId, std::memory_order_acq_rel);
+void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(uint64_t callbackId) {
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
-    audioEventHandlerRegistry_->unregisterHandler(
-        "positionChanged", oldCallbackId);
+    audioEventHandlerRegistry_->unregisterHandler("positionChanged", oldCallbackId);
   }
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
-  onPositionChangedInterval_ = static_cast<int>(
-      context_->getSampleRate() * static_cast<float>(interval) / 1000);
+  onPositionChangedInterval_ =
+      static_cast<int>(context_->getSampleRate() * static_cast<float>(interval) / 1000);
 }
 
 int AudioBufferBaseSourceNode::getOnPositionChangedInterval() const {
@@ -62,28 +58,23 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
 
 double AudioBufferBaseSourceNode::getInputLatency() const {
   if (pitchCorrection_) {
-    return static_cast<double>(stretch_->inputLatency()) /
-        context_->getSampleRate();
+    return static_cast<double>(stretch_->inputLatency()) / context_->getSampleRate();
   }
   return 0;
 }
 
 double AudioBufferBaseSourceNode::getOutputLatency() const {
   if (pitchCorrection_) {
-    return static_cast<double>(stretch_->outputLatency()) /
-        context_->getSampleRate();
+    return static_cast<double>(stretch_->outputLatency()) / context_->getSampleRate();
   }
   return 0;
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  auto onPositionChangedCallbackId =
-      onPositionChangedCallbackId_.load(std::memory_order_acquire);
+  auto onPositionChangedCallbackId = onPositionChangedCallbackId_.load(std::memory_order_acquire);
 
-  if (onPositionChangedCallbackId != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_) {
-    std::unordered_map<std::string, EventValue> body = {
-        {"value", getCurrentPosition()}};
+  if (onPositionChangedCallbackId != 0 && onPositionChangedTime_ > onPositionChangedInterval_) {
+    std::unordered_map<std::string, EventValue> body = {{"value", getCurrentPosition()}};
 
     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
         "positionChanged", onPositionChangedCallbackId, body);
@@ -101,34 +92,26 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
   size_t offsetLength = 0;
 
   auto time = context_->getCurrentTime();
-  auto playbackRate = std::clamp(
-      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
-  auto detune = std::clamp(
-      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
-      -12.0f,
-      12.0f);
+  auto playbackRate =
+      std::clamp(playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune =
+      std::clamp(detuneParam_->processKRateParam(framesToProcess, time) / 100.0f, -12.0f, 12.0f);
 
   playbackRateBus_->zero();
 
-  auto framesNeededToStretch =
-      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+  auto framesNeededToStretch = static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
 
-  updatePlaybackInfo(
-      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+  updatePlaybackInfo(playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
   if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }
 
-  processWithoutInterpolation(
-      playbackRateBus_, startOffset, offsetLength, playbackRate);
+  processWithoutInterpolation(playbackRateBus_, startOffset, offsetLength, playbackRate);
 
   stretch_->process(
-      playbackRateBus_.get()[0],
-      framesNeededToStretch,
-      processingBus.get()[0],
-      framesToProcess);
+      playbackRateBus_.get()[0], framesNeededToStretch, processingBus.get()[0], framesToProcess);
 
   if (detune != 0.0f) {
     stretch_->setTransposeSemitones(detune);
@@ -152,24 +135,19 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   }
 
   if (std::fabs(computedPlaybackRate) == 1.0) {
-    processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
+    processWithoutInterpolation(processingBus, startOffset, offsetLength, computedPlaybackRate);
   } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
+    processWithInterpolation(processingBus, startOffset, offsetLength, computedPlaybackRate);
   }
 
   sendOnPositionChangedEvent();
 }
 
-float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(
-    int framesToProcess) {
+float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
   auto time = context_->getCurrentTime();
 
-  auto playbackRate =
-      playbackRateParam_->processKRateParam(framesToProcess, time);
-  auto detune = std::pow(
-      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
+  auto playbackRate = playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto detune = std::pow(2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
 
   return playbackRate * detune;
 }

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

@@ -3,9 +3,9 @@
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
+#include <atomic>
 #include <memory>
 #include <mutex>
-#include <atomic>
 
 namespace audioapi {
 
@@ -26,49 +26,51 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] double getOutputLatency() const;
 
  protected:
-    // pitch correction
-    bool pitchCorrection_;
+  // pitch correction
+  bool pitchCorrection_;
 
-    std::mutex bufferLock_;
+  std::mutex bufferLock_;
 
-    // pitch correction
-    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
-    std::shared_ptr<AudioBus> playbackRateBus_;
+  // pitch correction
+  std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+  std::shared_ptr<AudioBus> playbackRateBus_;
 
-    // k-rate params
-    std::shared_ptr<AudioParam> detuneParam_;
-    std::shared_ptr<AudioParam> playbackRateParam_;
+  // k-rate params
+  std::shared_ptr<AudioParam> detuneParam_;
+  std::shared_ptr<AudioParam> playbackRateParam_;
 
-    // internal helper
-    double vReadIndex_;
+  // internal helper
+  double vReadIndex_;
 
-    std::atomic<uint64_t> onPositionChangedCallbackId_ = 0; // 0 means no callback
-    int onPositionChangedInterval_;
-    int onPositionChangedTime_ = 0;
+  std::atomic<uint64_t> onPositionChangedCallbackId_ = 0; // 0 means no callback
+  int onPositionChangedInterval_;
+  int onPositionChangedTime_ = 0;
 
-    std::mutex &getBufferLock();
-    virtual double getCurrentPosition() const = 0;
+  std::mutex &getBufferLock();
+  virtual double getCurrentPosition() const = 0;
 
-    void sendOnPositionChangedEvent();
+  void sendOnPositionChangedEvent();
 
-    void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                    int framesToProcess);
-    void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                       int framesToProcess);
+  void processWithPitchCorrection(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess);
+  void processWithoutPitchCorrection(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess);
 
-    float getComputedPlaybackRateValue(int framesToProcess);
+  float getComputedPlaybackRateValue(int framesToProcess);
 
-    virtual void processWithoutInterpolation(
-            const std::shared_ptr<AudioBus>& processingBus,
-            size_t startOffset,
-            size_t offsetLength,
-            float playbackRate) = 0;
+  virtual void processWithoutInterpolation(
+      const std::shared_ptr<AudioBus> &processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate) = 0;
 
-    virtual void processWithInterpolation(
-            const std::shared_ptr<AudioBus>& processingBus,
-            size_t startOffset,
-            size_t offsetLength,
-            float playbackRate) = 0;
+  virtual void processWithInterpolation(
+      const std::shared_ptr<AudioBus> &processingBus,
+      size_t startOffset,
+      size_t offsetLength,
+      float playbackRate) = 0;
 };
 
 } // namespace audioapi