react-native-audio-api 0.12.1 → 0.12.2

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

@@ -41,10 +41,6 @@ class ConvolverNode : public AudioNode {
       int framesToProcess) override;
 
  private:
-  std::shared_ptr<DSPAudioBuffer> processInputs(
-      const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-      int framesToProcess,
-      bool checkIsAlreadyProcessed) override;
   void onInputDisabled() override;
   const float gainCalibrationSampleRate_;
   size_t remainingSegments_;

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

@@ -8,8 +8,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <string>
-#include <unordered_map>
 
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
@@ -85,10 +83,10 @@ std::shared_ptr<DSPAudioBuffer> AudioBufferBaseSourceNode::processNode(
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
   if (onPositionChangedCallbackId_ != 0 &&
       onPositionChangedTimeInFrames_ > onPositionChangedIntervalInFrames_) {
-    std::unordered_map<std::string, EventValue> body = {{"value", getCurrentPosition()}};
-
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::POSITION_CHANGED, onPositionChangedCallbackId_, body);
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::POSITION_CHANGED,
+        onPositionChangedCallbackId_,
+        DoubleValuePayload{.value = getCurrentPosition()});
 
     onPositionChangedTimeInFrames_ = 0;
   }
@@ -119,7 +117,8 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
 
   playbackRateBuffer_->zero();
 
-  auto framesNeededToStretch = static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+  auto framesNeededToStretch =
+      std::abs(static_cast<int>(playbackRate * static_cast<float>(framesToProcess)));
 
   updatePlaybackInfo(
       playbackRateBuffer_,
@@ -134,7 +133,7 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
     return;
   }
 
-  processWithoutInterpolation(playbackRateBuffer_, startOffset, offsetLength, playbackRate);
+  runBufferProcessor(playbackRateBuffer_, startOffset, offsetLength, playbackRate, false);
 
   stretch_->process(
       playbackRateBuffer_.get()[0],
@@ -178,16 +177,19 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   }
 
   if (std::fabs(computedPlaybackRate) == 1.0) {
-    processWithoutInterpolation(processingBuffer, startOffset, offsetLength, computedPlaybackRate);
+    runBufferProcessor(processingBuffer, startOffset, offsetLength, computedPlaybackRate, false);
   } else {
-    processWithInterpolation(processingBuffer, startOffset, offsetLength, computedPlaybackRate);
+    runBufferProcessor(processingBuffer, startOffset, offsetLength, computedPlaybackRate, true);
   }
 
   sendOnPositionChangedEvent();
 }
 
 float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(int framesToProcess, double time) {
-  auto playbackRate = playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto playbackRate = std::clamp(
+      playbackRateParam_->processKRateParam(framesToProcess, time),
+      MIN_PLAYBACK_RATE,
+      MAX_PLAYBACK_RATE);
   auto detune = std::pow(
       2.0f, //NOLINT(cppcoreguidelines-avoid-magic-numbers, readability-magic-numbers)
       detuneParam_->processKRateParam(framesToProcess, time) / static_cast<float>(OCTAVE_RANGE));

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

@@ -45,17 +45,12 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
 
   virtual bool isEmpty() const = 0;
 
-  virtual void processWithoutInterpolation(
+  virtual void runBufferProcessor(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate) = 0;
-
-  virtual void processWithInterpolation(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      size_t startOffset,
-      size_t offsetLength,
-      float playbackRate) = 0;
+      float playbackRate,
+      bool interpolate) = 0;
 
  private:
   // pitch correction parameters
@@ -64,7 +59,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
   std::shared_ptr<DSPAudioBuffer> playbackRateBuffer_;
   static constexpr float MAX_PLAYBACK_RATE = 3.0f;
-  static constexpr float MIN_PLAYBACK_RATE = 0.0f;
+  static constexpr float MIN_PLAYBACK_RATE = -3.0f;
 
   // k-rate params
   const std::shared_ptr<AudioParam> detuneParam_;
@@ -79,6 +74,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   void processWithPitchCorrection(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess);
+
   void processWithoutPitchCorrection(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess);

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

@@ -4,6 +4,7 @@
 #include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
+#include <audioapi/core/utils/buffer/QueueBufferProcessor.h>
 #include <audioapi/dsp/AudioUtils.hpp>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/types/NodeOptions.h>
@@ -11,8 +12,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <string>
-#include <unordered_map>
 #include <utility>
 
 namespace audioapi {
@@ -28,6 +27,22 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
   }
 
   isInitialized_.store(true, std::memory_order_release);
+
+  auto graphManager = context->getGraphManager();
+
+  auto onBufferConsumed = [this, graphManager](
+                              size_t bufferId,
+                              std::shared_ptr<AudioBuffer> buffer,
+                              bool isLastInQueue,
+                              bool fireBufferEndedEvent) {
+    playedBuffersDuration_ += buffer->getDuration();
+    if (fireBufferEndedEvent) {
+      sendOnBufferEndedEvent(bufferId, isLastInQueue);
+    }
+    graphManager->addAudioBufferForDestruction(std::move(buffer));
+  };
+
+  processor_ = std::make_unique<QueueBufferProcessor>(&buffers_, onBufferConsumed);
 }
 
 void AudioBufferQueueSourceNode::stop(double when) {
@@ -132,6 +147,14 @@ void AudioBufferQueueSourceNode::unregisterOnBufferEndedCallback(uint64_t callba
   audioEventHandlerRegistry_->unregisterHandler(AudioEvent::BUFFER_ENDED, callbackId);
 }
 
+void AudioBufferQueueSourceNode::setChannelCount(int channelCount) {
+  if (channelCount_ != channelCount) {
+    channelCount_ = channelCount;
+    audioBuffer_ = std::make_shared<DSPAudioBuffer>(
+        RENDER_QUANTUM_SIZE, channelCount_, getContextSampleRate());
+  }
+}
+
 double AudioBufferQueueSourceNode::getCurrentPosition() const {
   return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), getContextSampleRate()) +
       playedBuffersDuration_;
@@ -139,11 +162,10 @@ double AudioBufferQueueSourceNode::getCurrentPosition() const {
 
 void AudioBufferQueueSourceNode::sendOnBufferEndedEvent(size_t bufferId, bool isLastBufferInQueue) {
   if (onBufferEndedCallbackId_ != 0) {
-    std::unordered_map<std::string, EventValue> body = {
-        {"bufferId", std::to_string(bufferId)}, {"isLastBufferInQueue", isLastBufferInQueue}};
-
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::BUFFER_ENDED, onBufferEndedCallbackId_, body);
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::BUFFER_ENDED,
+        onBufferEndedCallbackId_,
+        BufferEndedPayload{.bufferId = bufferId, .isLastBufferInQueue = isLastBufferInQueue});
   }
 }
 
@@ -155,147 +177,33 @@ bool AudioBufferQueueSourceNode::isEmpty() const {
   return buffers_.empty();
 }
 
-// todo: refactor so its less complex and more readable
-void AudioBufferQueueSourceNode::processWithoutInterpolation(
+void AudioBufferQueueSourceNode::runBufferProcessor(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     size_t startOffset,
     size_t offsetLength,
-    float playbackRate) {
-  if (auto context = context_.lock()) {
-    auto readIndex = static_cast<size_t>(vReadIndex_);
-    size_t writeIndex = startOffset;
-
-    auto data = buffers_.front();
-    auto bufferId = data.first;
-    auto buffer = data.second;
-
-    size_t framesLeft = offsetLength;
-
-    while (framesLeft > 0) {
-      size_t framesToEnd = buffer->getSize() - readIndex;
-      size_t framesToCopy = std::min(framesToEnd, framesLeft);
-      framesToCopy = framesToCopy > 0 ? framesToCopy : 0;
-
-      assert(readIndex >= 0);
-      assert(writeIndex >= 0);
-      assert(readIndex + framesToCopy <= buffer->getSize());
-      assert(writeIndex + framesToCopy <= processingBuffer->getSize());
-
-      processingBuffer->copy(*buffer, readIndex, writeIndex, framesToCopy);
-
-      writeIndex += framesToCopy;
-      readIndex += framesToCopy;
-      framesLeft -= framesToCopy;
-
-      if (readIndex >= buffer->getSize()) {
-        playedBuffersDuration_ += buffer->getDuration();
-        buffers_.pop_front();
-
-        if (!(buffers_.empty() && addExtraTailFrames_)) {
-          sendOnBufferEndedEvent(bufferId, buffers_.empty());
-        }
-
-        if (buffers_.empty()) {
-          if (addExtraTailFrames_) {
-            buffers_.emplace_back(bufferId, tailBuffer_);
-            addExtraTailFrames_ = false;
-          } else {
-            context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
-            processingBuffer->zero(writeIndex, framesLeft);
-            readIndex = 0;
-
-            break;
-          }
-        }
-
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
-        data = buffers_.front();
-        bufferId = data.first;
-        buffer = data.second;
-        readIndex = 0;
-      }
-    }
+    float playbackRate,
+    bool interpolate) {
+  if (!processingBuffer) {
+    return;
+  }
 
-    // update reading index for next render quantum
-    vReadIndex_ = static_cast<double>(readIndex);
+  if (buffers_.empty()) {
+    processingBuffer->zero(startOffset, offsetLength);
+    return;
   }
-}
 
-// todo: refactor so its less complex and more readable
-void AudioBufferQueueSourceNode::processWithInterpolation(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    size_t startOffset,
-    size_t offsetLength,
-    float playbackRate) {
-  if (auto context = context_.lock()) {
-    size_t writeIndex = startOffset;
-    size_t framesLeft = offsetLength;
-
-    auto data = buffers_.front();
-    auto bufferId = data.first;
-    auto buffer = data.second;
-
-    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));
-
-      bool crossBufferInterpolation = false;
-      std::shared_ptr<AudioBuffer> nextBuffer = nullptr;
-
-      if (nextReadIndex >= buffer->getSize()) {
-        if (buffers_.size() > 1) {
-          auto tempQueue = buffers_;
-          tempQueue.pop_front();
-          nextBuffer = tempQueue.front().second;
-          nextReadIndex = 0;
-          crossBufferInterpolation = true;
-        } else {
-          nextReadIndex = readIndex;
-        }
-      }
+  if (addExtraTailFrames_ && tailBuffer_ != nullptr) {
+    processor_->setPendingTail(tailBuffer_);
+  }
 
-      for (size_t i = 0; i < processingBuffer->getNumberOfChannels(); i += 1) {
-        const auto destination = processingBuffer->getChannel(i)->span();
-        const auto currentSource = buffer->getChannel(i)->span();
-
-        if (crossBufferInterpolation) {
-          const auto nextSource = nextBuffer->getChannel(i)->span();
-          float currentSample = currentSource[readIndex];
-          float nextSample = nextSource[nextReadIndex];
-          destination[writeIndex] = currentSample + factor * (nextSample - currentSample);
-        } else {
-          destination[writeIndex] =
-              dsp::linearInterpolate(currentSource, readIndex, nextReadIndex, factor);
-        }
-      }
+  processor_->setPosition(vReadIndex_);
+  processor_->process(processingBuffer, startOffset, offsetLength, playbackRate, interpolate);
 
-      writeIndex += 1;
-      // queue source node always use positive playbackRate
-      vReadIndex_ += std::abs(playbackRate);
-      framesLeft -= 1;
-
-      if (vReadIndex_ >= static_cast<double>(buffer->getSize())) {
-        playedBuffersDuration_ += buffer->getDuration();
-        buffers_.pop_front();
-
-        sendOnBufferEndedEvent(bufferId, buffers_.empty());
-
-        if (buffers_.empty()) {
-          context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
-          processingBuffer->zero(writeIndex, framesLeft);
-          vReadIndex_ = 0.0;
-          break;
-        }
-
-        vReadIndex_ = vReadIndex_ - static_cast<double>(buffer->getSize());
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
-        data = buffers_.front();
-        bufferId = data.first;
-        buffer = data.second;
-      }
-    }
+  if (processor_->didConsumeTail()) {
+    addExtraTailFrames_ = false;
   }
+
+  vReadIndex_ = processor_->getPosition();
 }
 
 } // namespace audioapi

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

@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <list>
 #include <memory>
+#include "audioapi/core/utils/buffer/QueueBufferProcessor.h"
 
 namespace audioapi {
 
@@ -48,6 +49,11 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
 
   void unregisterOnBufferEndedCallback(uint64_t callbackId);
 
+  /// @brief Set the channel count of the node. Channel count is set only once when the first buffer is enqueued.
+  /// @param channelCount The channel count to set.
+  /// @note Audio Thread only
+  void setChannelCount(int channelCount);
+
  protected:
   double getCurrentPosition() const override;
 
@@ -55,17 +61,12 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
 
   bool isEmpty() const final;
 
-  void processWithoutInterpolation(
+  void runBufferProcessor(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate) final;
-
-  void processWithInterpolation(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      size_t startOffset,
-      size_t offsetLength,
-      float playbackRate) final;
+      float playbackRate,
+      bool interpolate) final;
 
  private:
   // User provided buffers
@@ -78,6 +79,8 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
   double playedBuffersDuration_ = 0;
 
   uint64_t onBufferEndedCallbackId_ = 0; // 0 means no callback
+
+  std::unique_ptr<QueueBufferProcessor> processor_;
 };
 
 } // namespace audioapi

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

@@ -9,7 +9,9 @@
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
 
+#include <audioapi/core/utils/buffer/SingleBufferProcessor.h>
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <utility>
 
@@ -23,11 +25,13 @@ AudioBufferSourceNode::AudioBufferSourceNode(
       loopSkip_(options.loopSkip),
       loopStart_(options.loopStart),
       loopEnd_(options.loopEnd) {
+  processor_ = std::make_unique<SingleBufferProcessor>();
   isInitialized_.store(true, std::memory_order_release);
 }
 
 void AudioBufferSourceNode::setLoop(bool loop) {
   loop_ = loop;
+  processor_->setLoop(loop_);
 }
 
 void AudioBufferSourceNode::setLoopSkip(bool loopSkip) {
@@ -67,6 +71,7 @@ void AudioBufferSourceNode::setBuffer(
     channelCount_ = 1;
 
     buffer_ = nullptr;
+    processor_->setBuffer(nullptr);
     return;
   }
 
@@ -74,6 +79,7 @@ void AudioBufferSourceNode::setBuffer(
   audioBuffer_ = audioBuffer;
   channelCount_ = static_cast<int>(buffer_->getNumberOfChannels());
   loopEnd_ = buffer_->getDuration();
+  processor_->setBuffer(buffer_);
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -114,8 +120,8 @@ double AudioBufferSourceNode::getCurrentPosition() const {
 
 void AudioBufferSourceNode::sendOnLoopEndedEvent() {
   if (onLoopEndedCallbackId_ != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::LOOP_ENDED, onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::LOOP_ENDED, onLoopEndedCallbackId_, EmptyPayload{});
   }
 }
 
@@ -127,129 +133,38 @@ bool AudioBufferSourceNode::isEmpty() const {
   return buffer_ == nullptr;
 }
 
-// todo: refactor so its less complex and more readable
-void AudioBufferSourceNode::processWithoutInterpolation(
+void AudioBufferSourceNode::runBufferProcessor(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     size_t startOffset,
     size_t offsetLength,
-    float playbackRate) {
-  size_t direction = playbackRate < 0.0f ? -1 : 1;
-
-  auto readIndex = static_cast<size_t>(vReadIndex_);
-  size_t writeIndex = startOffset;
-
-  auto frameStart = static_cast<size_t>(getVirtualStartFrame(getContextSampleRate()));
-  auto frameEnd = static_cast<size_t>(getVirtualEndFrame(getContextSampleRate()));
-  size_t frameDelta = frameEnd - frameStart;
-
-  size_t framesLeft = offsetLength;
-
-  // 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 = frameStart +
-        (static_cast<int64_t>(readIndex) - static_cast<int64_t>(frameStart)) % frameDelta;
+    float playbackRate,
+    bool interpolate) {
+  if (!processingBuffer) {
+    return;
   }
 
-  while (framesLeft > 0) {
-    size_t framesToEnd = frameEnd - readIndex;
-    size_t framesToCopy = std::min(framesToEnd, framesLeft);
-    framesToCopy = framesToCopy > 0 ? framesToCopy : 0;
-
-    assert(readIndex >= 0);
-    assert(writeIndex >= 0);
-    assert(readIndex + framesToCopy <= buffer_->getSize());
-    assert(writeIndex + framesToCopy <= processingBuffer->getSize());
-
-    // Direction is forward, we can normally copy the data
-    if (direction == 1) {
-      processingBuffer->copy(*buffer_, readIndex, writeIndex, framesToCopy);
-    } else {
-      for (size_t ch = 0; ch < processingBuffer->getNumberOfChannels(); ch += 1) {
-        processingBuffer->getChannel(ch)->copyReverse(
-            *buffer_->getChannel(ch), readIndex, writeIndex, framesToCopy);
-      }
-    }
-
-    writeIndex += framesToCopy;
-    readIndex += framesToCopy * direction;
-    framesLeft -= framesToCopy;
-
-    // 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)) {
-      readIndex -= direction * frameDelta;
+  const float sampleRate = getContextSampleRate();
+  const double startFrame = getVirtualStartFrame(sampleRate);
+  const double endFrame = getVirtualEndFrame(sampleRate);
 
-      if (!loop_) {
-        processingBuffer->zero(writeIndex, framesLeft);
-        playbackState_ = PlaybackState::STOP_SCHEDULED;
-        break;
-      }
-
-      sendOnLoopEndedEvent();
-    }
+  // start(when, offset=duration) sets vReadIndex_ to endFrame, so clamp it
+  if (playbackRate < 0 && vReadIndex_ >= endFrame && endFrame > startFrame) {
+    vReadIndex_ = endFrame - 1.0;
   }
 
-  // update reading index for next render quantum
-  vReadIndex_ = static_cast<double>(readIndex);
-}
-
-void AudioBufferSourceNode::processWithInterpolation(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    size_t startOffset,
-    size_t offsetLength,
-    float playbackRate) {
-  size_t direction = playbackRate < 0.0f ? -1 : 1;
-
-  size_t writeIndex = startOffset;
+  processor_->setPosition(vReadIndex_);
+  processor_->setEndFrame(static_cast<size_t>(endFrame));
+  processor_->setStartFrame(static_cast<size_t>(startFrame));
+  processor_->process(processingBuffer, startOffset, offsetLength, playbackRate, interpolate);
 
-  auto vFrameStart = getVirtualStartFrame(getContextSampleRate());
-  auto vFrameEnd = getVirtualEndFrame(getContextSampleRate());
-  auto vFrameDelta = vFrameEnd - vFrameStart;
-
-  auto frameStart = static_cast<size_t>(vFrameStart);
-  auto frameEnd = static_cast<size_t>(vFrameEnd);
-
-  size_t framesLeft = offsetLength;
-
-  // Wrap to the start of the loop if necessary
-  if (loop_ && (vReadIndex_ >= vFrameEnd || vReadIndex_ < vFrameStart)) {
-    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));
-
-    if (nextReadIndex >= frameEnd) {
-      nextReadIndex = loop_ ? frameStart : readIndex;
-    }
-
-    for (size_t i = 0; i < processingBuffer->getNumberOfChannels(); i++) {
-      auto destination = processingBuffer->getChannel(i)->span();
-      const auto source = buffer_->getChannel(i)->span();
-
-      destination[writeIndex] = dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
-    }
-
-    writeIndex += 1;
-    vReadIndex_ += playbackRate * static_cast<double>(direction);
-    framesLeft -= 1;
-
-    if (vReadIndex_ < vFrameStart || vReadIndex_ >= vFrameEnd) {
-      vReadIndex_ -= static_cast<double>(direction) * vFrameDelta;
-
-      if (!loop_) {
-        processingBuffer->zero(writeIndex, framesLeft);
-        playbackState_ = PlaybackState::STOP_SCHEDULED;
-        break;
-      }
-
-      sendOnLoopEndedEvent();
+  if (processor_->atBoundary()) {
+    if (processor_->shouldStop()) {
+      playbackState_ = PlaybackState::STOP_SCHEDULED;
     }
+    sendOnLoopEndedEvent();
   }
+
+  vReadIndex_ = processor_->getPosition();
 }
 
 double AudioBufferSourceNode::getVirtualStartFrame(float sampleRate) const {

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

@@ -4,6 +4,7 @@
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
+#include <audioapi/core/utils/buffer/SingleBufferProcessor.h>
 #include <cstddef>
 #include <memory>
 
@@ -52,17 +53,12 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
 
   bool isEmpty() const final;
 
-  void processWithoutInterpolation(
+  void runBufferProcessor(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate) final;
-
-  void processWithInterpolation(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      size_t startOffset,
-      size_t offsetLength,
-      float playbackRate) final;
+      float playbackRate,
+      bool interpolate) final;
 
  private:
   // Looping related properties
@@ -79,6 +75,8 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
 
   double getVirtualStartFrame(float sampleRate) const;
   double getVirtualEndFrame(float sampleRate);
+
+  std::unique_ptr<SingleBufferProcessor> processor_;
 };
 
 } // namespace audioapi