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

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

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