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

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 {
 
@@ -19,55 +19,58 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
-  void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
   [[nodiscard]] int getOnPositionChangedInterval() const;
+  [[nodiscard]] double getInputLatency() const;
+  [[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

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(
@@ -17,6 +24,18 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
   buffers_ = {};
   stretch_->presetDefault(channelCount_, context_->getSampleRate());
 
+  if (pitchCorrection) {
+    // If pitch correction is enabled, add extra frames at the end
+    // 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());
+
+    tailBuffer_->bus_->zero();
+  }
+
   isInitialized_ = true;
 }
 
@@ -31,13 +50,29 @@ void AudioBufferQueueSourceNode::stop(double when) {
   isPaused_ = false;
 }
 
+void AudioBufferQueueSourceNode::start(double when) {
+  isPaused_ = false;
+  stopTime_ = -1.0;
+  AudioScheduledSourceNode::start(when);
+}
+
+void AudioBufferQueueSourceNode::start(double when, double offset) {
+  start(when);
+
+  if (buffers_.empty()) {
+    return;
+  }
+
+  offset = std::min(offset, buffers_.front().second->getDuration());
+  vReadIndex_ = static_cast<double>(buffers_.front().second->getSampleRate() * offset);
+}
+
 void AudioBufferQueueSourceNode::pause() {
   AudioScheduledSourceNode::stop(0.0);
   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);
 
@@ -79,6 +114,7 @@ void AudioBufferQueueSourceNode::disable() {
     playbackState_ = PlaybackState::UNSCHEDULED;
     startTime_ = -1.0;
     stopTime_ = -1.0;
+    isPaused_ = false;
 
     return;
   }
@@ -112,8 +148,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_;
 }
 
@@ -145,8 +180,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;
@@ -162,10 +196,17 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
           "ended", onEndedCallbackId_, body);
 
       if (buffers_.empty()) {
-        processingBus->zero(writeIndex, framesLeft);
-        readIndex = 0;
+        if (addExtraTailFrames_) {
+          buffers_.emplace(bufferId_, tailBuffer_);
+          bufferId_++;
 
-        break;
+          addExtraTailFrames_ = false;
+        } else if (buffers_.empty()) {
+          processingBus->zero(writeIndex, framesLeft);
+          readIndex = 0;
+
+          break;
+        }
       }
 
       data = buffers_.front();
@@ -194,8 +235,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;
@@ -220,11 +260,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);
       }
     }
 
@@ -237,8 +276,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,41 +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;
-    void pause();
+  void start(double when) override;
+  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;
+  // User provided buffers
+  std::queue<std::pair<size_t, std::shared_ptr<AudioBuffer>>> buffers_;
+  size_t bufferId_ = 0;
 
-    bool isPaused_ = false;
+  bool isPaused_ = false;
+  bool addExtraTailFrames_ = false;
+  std::shared_ptr<AudioBuffer> tailBuffer_;
 
-    double playedBuffersDuration_ = 0;
+  double playedBuffersDuration_ = 0;
 
-    void processWithoutInterpolation(
-            const std::shared_ptr<AudioBus>& processingBus,
-            size_t startOffset,
-            size_t offsetLength,
-            float playbackRate) override;
+  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;
+  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) {
@@ -82,17 +81,29 @@ void AudioBufferSourceNode::setBuffer(
   }
 
   buffer_ = buffer;
-  alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
   channelCount_ = buffer_->getNumberOfChannels();
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
 
-  loopEnd_ = buffer_->getDuration();
+  if (pitchCorrection_) {
+    int extraTailFrames =
+        static_cast<int>((getInputLatency() + getOutputLatency()) * context_->getSampleRate());
+    size_t totalSize = buffer_->getLength() + extraTailFrames;
 
-  stretch_->presetDefault(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);
+  } else {
+    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());
+
+  loopEnd_ = buffer_->getDuration();
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -106,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_);
@@ -123,19 +132,12 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::clearOnLoopEndedCallback() {
-  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "loopEnded", onLoopEndedCallbackId_);
-  onLoopEndedCallbackId_ = 0;
-}
-
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  onLoopEndedCallbackId_ = callbackId;
+  auto oldCallbackId = onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
+  }
 }
 
 std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
@@ -163,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) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("loopEnded", onLoopEndedCallbackId, {});
   }
 }
 
@@ -199,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) {
@@ -217,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) {
@@ -234,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_) {
@@ -272,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;
@@ -290,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;
@@ -315,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

@@ -4,9 +4,9 @@
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
-#include <memory>
-#include <cstddef>
 #include <algorithm>
+#include <cstddef>
+#include <memory>
 #include <string>
 
 namespace audioapi {
@@ -31,14 +31,16 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void setLoopEnd(double loopEnd);
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
 
+  using AudioScheduledSourceNode::start;
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
-  void clearOnLoopEndedCallback();
   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:
@@ -56,13 +58,13 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void sendOnLoopEndedEvent();
 
   void processWithoutInterpolation(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate) override;
 
   void processWithInterpolation(
-      const std::shared_ptr<AudioBus>& processingBus,
+      const std::shared_ptr<AudioBus> &processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate) override;

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

@@ -6,6 +6,14 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
+#if !RN_AUDIO_API_TEST
+#include <audioapi/core/AudioContext.h>
+#endif // RN_AUDIO_API_TEST
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
@@ -14,9 +22,16 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
       stopTime_(-1.0),
       playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  audioEventHandlerRegistry_ = context_->audioEventHandlerRegistry_;
 }
 
 void AudioScheduledSourceNode::start(double when) {
+#if !RN_AUDIO_API_TEST
+  if (auto context = dynamic_cast<AudioContext *>(context_)) {
+    context->start();
+  }
+#endif // RN_AUDIO_API_TEST
+
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;
 }
@@ -45,19 +60,12 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::clearOnEndedCallback() {
-  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "ended", onEndedCallbackId_);
-  onEndedCallbackId_ = 0;
-}
-
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
-  onEndedCallbackId_ = callbackId;
+  auto oldCallbackId = onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
+  }
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -76,14 +84,11 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
-  size_t lastFrame = firstFrame + framesToProcess;
-
-  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 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);
   if (isFinished()) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
@@ -105,7 +110,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
     nonSilentFramesToProcess =
-        std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+        std::max(std::min(lastFrame, stopFrame) + 1, startFrame) - startFrame;
 
     assert(startOffset <= framesToProcess);
     assert(nonSilentFramesToProcess <= framesToProcess);
@@ -124,7 +129,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
   // stop will happen in this render quantum
   // zero remaining frames after stop frame
-  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+  if (stopFrame <= lastFrame && stopFrame >= firstFrame) {
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
@@ -160,9 +165,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "ended", onEndedCallbackId_, {});
+  auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
+  if (onEndedCallbackId != 0) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("ended", onEndedCallbackId, {});
   }
 }