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

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

@@ -1,135 +1,58 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
 
 namespace audioapi {
 
-AudioRecorder::AudioRecorder(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  isRunning_.store(false);
-  fileOutputEnabled_.store(false);
-  callbackOutputEnabled_.store(false);
-  isConnected_.store(false);
-}
+void AudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-bool AudioRecorder::isRecording() {
-  return isRunning_.load();
-}
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  // node->init();
-  // adapterNodeLock_.lock();
-  // adapterNode_ = node;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(true);
-  //   node->init(ringBufferSize_);
-  //   adapterNodeLock_.lock();
-  //   adapterNode_ = node;
-  //   adapterNodeLock_.unlock();
-}
+  if (usesCallback()) {
+    dataCallback_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::disconnect() {
-  // adapterNodeLock_.lock();
-  // adapterNode_ = nullptr;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(false);
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
-void AudioRecorder::setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId) {
-  callbackProperties_.sampleRate = sampleRate;
-  callbackProperties_.bufferLength = bufferLength;
-  callbackProperties_.channelCount = channelCount;
-  callbackProperties_.callbackId = callbackId;
-
-  callbackOutputEnabled_.store(true);
-}
+void AudioRecorder::clearOnErrorCallback() {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-void AudioRecorder::clearOnAudioReadyCallback() {
-  callbackOutputEnabled_.store(false);
-  callbackProperties_ = CallbackProperties{};
-}
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
 
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
-
-  //   auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  //   auto audioBufferHostObject =
-  //       std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  //   std::unordered_map<std::string, EventValue> body = {};
-  //   body.insert({"buffer", audioBufferHostObject});
-  //   body.insert({"numFrames", numFrames});
-
-  //   if (audioEventHandlerRegistry_ != nullptr) {
-  //     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-  //         "audioReady", onAudioReadyCallbackId_, body);
-  //   }
-}
+  if (usesCallback()) {
+    dataCallback_->clearOnErrorCallback();
+  }
 
-void AudioRecorder::sendRemainingCallbackData() {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
+  errorCallbackId_.store(0, std::memory_order_release);
+}
 
-  //   auto bus = std::make_shared<AudioBus>(
-  //       circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  //   auto *outputChannel = bus->getChannel(0)->getData();
-  //   auto availableFrames =
-  //       static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+double AudioRecorder::getCurrentDuration() const {
+  double duration = 0.0;
 
-  //   circularBuffer_->pop_front(
-  //       outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  if (usesFileOutput()) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  //   invokeOnAudioReadyCallback(bus, availableFrames);
+  return duration;
 }
 
 bool AudioRecorder::usesCallback() const {
-  return callbackOutputEnabled_.load();
+  return callbackOutputEnabled_.load(std::memory_order_acquire);
 }
 
 bool AudioRecorder::usesFileOutput() const {
-  return fileOutputEnabled_.load();
+  return fileOutputEnabled_.load(std::memory_order_acquire);
 }
 
 bool AudioRecorder::isConnected() const {
-  return isConnected_.load();
+  return isConnected_.load(std::memory_order_acquire);
 }
 
-// AudioRecorder::AudioRecorder(
-//     const std::shared_ptr<AudioEventHandlerRegistry>
-//     &audioEventHandlerRegistry)
-//       audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-//   constexpr int minRingBufferSize = 8192;
-//   ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-
-//   circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-//   isRunning_.store(false);
-// }
-
-// void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-//   if (adapterNodeLock_.try_lock()) {
-//     if (adapterNode_ != nullptr) {
-//       adapterNode_->buff_->write(data, numFrames);
-//     }
-//     adapterNodeLock_.unlock();
-//   }
-
-//   if (hasCallback()) {
-//     circularBuffer_->push_back(data, numFrames);
-//   }
-// }
-
 } // namespace audioapi

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

@@ -1,81 +1,81 @@
 #pragma once
 
-#include <memory>
+#include <audioapi/utils/Result.hpp>
 #include <atomic>
+#include <memory>
 #include <mutex>
 #include <string>
+#include <tuple>
 
 namespace audioapi {
 
-class RecorderAdapterNode;
 class AudioBus;
+class AudioFileWriter;
 class CircularAudioArray;
+class RecorderAdapterNode;
+class AudioFileProperties;
+class AudioRecorderCallback;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  enum class RecorderState { Idle = 0, Recording, Paused };
+  explicit AudioRecorder(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+      : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  virtual void start() = 0;
-  virtual std::string stop() = 0;
+  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
 
-  bool isRecording();
-
-  virtual void enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) = 0;
+  virtual Result<std::string, std::string> enableFileOutput(
+      std::shared_ptr<AudioFileProperties> properties) = 0;
   virtual void disableFileOutput() = 0;
 
   virtual void pause() = 0;
   virtual void resume() = 0;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
-  void disconnect();
+  virtual void connect(const std::shared_ptr<RecorderAdapterNode> &node) = 0;
+  virtual void disconnect() = 0;
+
+  virtual Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
 
-  void setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId);
-  void clearOnAudioReadyCallback();
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
 
-  void invokeOnAudioReadyCallback(
-      const std::shared_ptr<AudioBus> &bus,
-      int numFrames);
-  void sendRemainingCallbackData();
+  virtual double getCurrentDuration() const;
 
   bool usesCallback() const;
   bool usesFileOutput() const;
   bool isConnected() const;
 
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
+
  protected:
-  struct CallbackProperties {
-    float sampleRate;
-    size_t bufferLength;
-    size_t channelCount;
-    uint64_t callbackId;
-  };
-
-  CallbackProperties callbackProperties_;
-  // size_t ringBufferSize_;
-
-  std::atomic<bool> isRunning_;
-  std::atomic<bool> fileOutputEnabled_;
-  std::atomic<bool> callbackOutputEnabled_;
-  std::atomic<bool> isConnected_;
-  // std::shared_ptr<CircularAudioArray> circularBuffer_;
-
-  mutable std::mutex adapterNodeLock_;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::atomic<RecorderState> state_{RecorderState::Idle};
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
+  std::atomic<bool> isConnected_{false};
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
+
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+  std::mutex errorCallbackMutex_;
+  mutable std::mutex adapterNodeMutex_;
 
-  // void writeToBuffers(const float *data, int numFrames);
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
+  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

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,41 +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::clearOnPositionChangedCallback() {
-  if (onPositionChangedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "positionChanged", onPositionChangedCallbackId_);
-  onPositionChangedCallbackId_ = 0;
-}
+void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(uint64_t callbackId) {
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
-void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
-    uint64_t callbackId) {
-  onPositionChangedCallbackId_ = callbackId;
+  if (oldCallbackId != 0) {
+    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 {
@@ -65,15 +56,28 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
   return bufferLock_;
 }
 
+double AudioBufferBaseSourceNode::getInputLatency() const {
+  if (pitchCorrection_) {
+    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 0;
+}
+
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_ &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    std::unordered_map<std::string, EventValue> body = {
-        {"value", getCurrentPosition()}};
+  auto onPositionChangedCallbackId = onPositionChangedCallbackId_.load(std::memory_order_acquire);
+
+  if (onPositionChangedCallbackId != 0 && onPositionChangedTime_ > onPositionChangedInterval_) {
+    std::unordered_map<std::string, EventValue> body = {{"value", getCurrentPosition()}};
 
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "positionChanged", onPositionChangedCallbackId_, body);
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "positionChanged", onPositionChangedCallbackId, body);
 
     onPositionChangedTime_ = 0;
   }
@@ -88,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);
@@ -139,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;
 }