react-native-audio-api 0.8.3 → 0.9.0-nightly-96a5bcd-20251007

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
@@ -11,8 +11,9 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    BaseAudioContext *context)
-    : AudioBufferBaseSourceNode(context) {
+    BaseAudioContext *context,
+    bool pitchCorrection)
+    : AudioBufferBaseSourceNode(context, pitchCorrection) {
   buffers_ = {};
   stretch_->presetDefault(channelCount_, context_->getSampleRate());
 
@@ -86,22 +87,28 @@ void AudioBufferQueueSourceNode::disable() {
   buffers_ = {};
 }
 
-void AudioBufferQueueSourceNode::processNode(
+std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   if (auto locker = Locker::tryLock(getBufferLock())) {
-    // No audio data to fill, zero the output and return.
+    // no audio data to fill, zero the output and return.
     if (buffers_.empty()) {
       processingBus->zero();
-      return;
+      return processingBus;
     }
 
-    processWithPitchCorrection(processingBus, framesToProcess);
+    if (!pitchCorrection_) {
+      processWithoutPitchCorrection(processingBus, framesToProcess);
+    } else {
+      processWithPitchCorrection(processingBus, framesToProcess);
+    }
 
     handleStopScheduled();
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferQueueSourceNode::getCurrentPosition() const {
@@ -135,6 +142,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
 
     assert(readIndex >= 0);
     assert(writeIndex >= 0);
+    assert(readIndex + framesToCopy <= buffer->getLength());
     assert(writeIndex + framesToCopy <= processingBus->getSize());
 
     processingBus->copy(
@@ -149,7 +157,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
       buffers_.pop();
 
       std::unordered_map<std::string, EventValue> body = {
-          {"bufferId", std::to_string(bufferId)}};
+          {"bufferId", std::to_string(bufferId)}, {"isLast", buffers_.empty()}};
       context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
           "ended", onEndedCallbackId_, body);
 
@@ -158,13 +166,12 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
         readIndex = 0;
 
         break;
-      } else {
-        data = buffers_.front();
-        bufferId = data.first;
-        buffer = data.second;
-
-        readIndex = 0;
       }
+
+      data = buffers_.front();
+      bufferId = data.first;
+      buffer = data.second;
+      readIndex = 0;
     }
   }
 
@@ -172,4 +179,81 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
   vReadIndex_ = static_cast<double>(readIndex);
 }
 
+void AudioBufferQueueSourceNode::processWithInterpolation(
+    const std::shared_ptr<AudioBus> &processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  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->getLength()) {
+      if (buffers_.size() > 1) {
+        auto tempQueue = buffers_;
+        tempQueue.pop();
+        nextBuffer = tempQueue.front().second;
+        nextReadIndex = 0;
+        crossBufferInterpolation = true;
+      } else {
+        nextReadIndex = readIndex;
+      }
+    }
+
+    for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
+      float *destination = processingBus->getChannel(i)->getData();
+      const float *currentSource = buffer->bus_->getChannel(i)->getData();
+
+      if (crossBufferInterpolation) {
+        const float *nextSource = nextBuffer->bus_->getChannel(i)->getData();
+        float currentSample = currentSource[readIndex];
+        float nextSample = nextSource[nextReadIndex];
+        destination[writeIndex] =
+            currentSample + factor * (nextSample - currentSample);
+      } else {
+        destination[writeIndex] = dsp::linearInterpolate(
+            currentSource, readIndex, nextReadIndex, factor);
+      }
+    }
+
+    writeIndex += 1;
+    // queue source node always use positive playbackRate
+    vReadIndex_ += std::abs(playbackRate);
+    framesLeft -= 1;
+
+    if (vReadIndex_ >= static_cast<double>(buffer->getLength())) {
+      playedBuffersDuration_ += buffer->getDuration();
+      buffers_.pop();
+
+      std::unordered_map<std::string, EventValue> body = {
+          {"bufferId", std::to_string(bufferId)}};
+      context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+          "ended", onEndedCallbackId_, body);
+
+      if (buffers_.empty()) {
+        processingBus->zero(writeIndex, framesLeft);
+        vReadIndex_ = 0.0;
+        break;
+      }
+
+      vReadIndex_ = vReadIndex_ - buffer->getLength();
+      data = buffers_.front();
+      bufferId = data.first;
+      buffer = data.second;
+    }
+  }
+}
+
 } // namespace audioapi

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

@@ -17,19 +17,19 @@ class AudioParam;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
-    explicit AudioBufferQueueSourceNode(BaseAudioContext *context);
+    explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
     ~AudioBufferQueueSourceNode() override;
 
     void stop(double when) override;
     void pause();
 
     std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-    void dequeueBuffer(const size_t bufferId);
+    void dequeueBuffer(size_t bufferId);
     void clearBuffers();
     void disable() override;
 
  protected:
-    void 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:
@@ -46,6 +46,12 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
             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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
@@ -13,12 +13,11 @@ namespace audioapi {
 AudioBufferSourceNode::AudioBufferSourceNode(
     BaseAudioContext *context,
     bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context),
+    : AudioBufferBaseSourceNode(context, pitchCorrection),
       loop_(false),
       loopSkip_(false),
       loopStart_(0),
-      loopEnd_(0),
-      pitchCorrection_(pitchCorrection) {
+      loopEnd_(0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
   alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
@@ -30,6 +29,8 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
+
+  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {
@@ -124,14 +125,29 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::processNode(
+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;
+}
+
+std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   if (auto locker = Locker::tryLock(getBufferLock())) {
     // No audio data to fill, zero the output and return.
     if (!alignedBus_) {
       processingBus->zero();
-      return;
+      return processingBus;
     }
 
     if (!pitchCorrection_) {
@@ -144,6 +160,8 @@ void AudioBufferSourceNode::processNode(
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferSourceNode::getCurrentPosition() const {
@@ -151,35 +169,19 @@ double AudioBufferSourceNode::getCurrentPosition() const {
       static_cast<int>(vReadIndex_), buffer_->getSampleRate());
 }
 
+void AudioBufferSourceNode::sendOnLoopEndedEvent() {
+  auto onLoopEndedCallbackId =
+      onLoopEndedCallbackId_.load(std::memory_order_acquire);
+  if (onLoopEndedCallbackId != 0) {
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId_, {});
+  }
+}
+
 /**
  * Helper functions
  */
 
-void AudioBufferSourceNode::processWithoutPitchCorrection(
-    const std::shared_ptr<AudioBus> &processingBus,
-    int framesToProcess) {
-  size_t startOffset = 0;
-  size_t offsetLength = 0;
-
-  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-
-  if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
-    processingBus->zero();
-    return;
-  }
-
-  if (std::fabs(computedPlaybackRate) == 1.0) {
-    processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
-  } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
-  }
-
-  sendOnPositionChangedEvent();
-}
-
 void AudioBufferSourceNode::processWithoutInterpolation(
     const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
@@ -243,6 +245,8 @@ void AudioBufferSourceNode::processWithoutInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 
@@ -304,23 +308,12 @@ void AudioBufferSourceNode::processWithInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 }
 
-float AudioBufferSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
-  auto time = context_->getCurrentTime();
-
-  auto sampleRateFactor =
-      alignedBus_->getSampleRate() / context_->getSampleRate();
-  auto playbackRate =
-      playbackRateParam_->processKRateParam(framesToProcess, time);
-  auto detune = std::pow(
-      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
-
-  return playbackRate * sampleRateFactor * detune;
-}
-
 double AudioBufferSourceNode::getVirtualStartFrame() {
   auto loopStartFrame = loopStart_ * context_->getSampleRate();
 

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

@@ -34,8 +34,11 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
+  void clearOnLoopEndedCallback();
+  void setOnLoopEndedCallbackId(uint64_t callbackId);
+
  protected:
-  void 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:
@@ -45,15 +48,12 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   double loopStart_;
   double loopEnd_;
 
-  // pitch correction
-  bool pitchCorrection_;
-
   // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
   std::shared_ptr<AudioBus> alignedBus_;
 
-  void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                     int framesToProcess);
+  std::atomic<uint64_t> onLoopEndedCallbackId_ = 0; // 0 means no callback
+  void sendOnLoopEndedEvent();
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
@@ -65,9 +65,7 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
       const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate);
-
-  float getComputedPlaybackRateValue(int framesToProcess);
+      float playbackRate) override;
 
   double getVirtualStartFrame();
   double getVirtualEndFrame();

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

@@ -17,12 +17,7 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
 }
 
 AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  if (onEndedCallbackId_ != 0 &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->unregisterHandler(
-        "ended", onEndedCallbackId_);
-    onEndedCallbackId_ = 0;
-  }
+  clearOnEndedCallback();
 }
 
 void AudioScheduledSourceNode::start(double when) {

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

@@ -27,7 +27,7 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  virtual ~AudioScheduledSourceNode();
+  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

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

@@ -0,0 +1,53 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context) {
+  offsetParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
+  return offsetParam_;
+}
+
+std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  auto offsetBus = offsetParam_->processARateParam(
+      framesToProcess, context_->getCurrentTime());
+
+  auto offsetChannelData = offsetBus->getChannel(0)->getData();
+
+  for (int channel = 0; channel < processingBus->getNumberOfChannels();
+       ++channel) {
+    auto outputChannelData = processingBus->getChannel(channel)->getData();
+
+    std::copy(
+        offsetChannelData + startOffset,
+        offsetChannelData + startOffset + offsetLength,
+        outputChannelData + startOffset);
+  }
+
+  if (isStopScheduled()) {
+    handleStopScheduled();
+  }
+
+  return processingBus;
+}
+} // namespace audioapi

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+
+#include <cmath>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class ConstantSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit ConstantSourceNode(BaseAudioContext *context);
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioParam> offsetParam_;
+};
+} // namespace audioapi

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

@@ -21,6 +21,9 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+
   isInitialized_ = true;
 }
 
@@ -47,7 +50,7 @@ void OscillatorNode::setPeriodicWave(
   type_ = OscillatorType::CUSTOM;
 }
 
-void OscillatorNode::processNode(
+std::shared_ptr<AudioBus> OscillatorNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
@@ -57,7 +60,7 @@ void OscillatorNode::processNode(
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   auto time = context_->getCurrentTime() +
@@ -89,6 +92,8 @@ void OscillatorNode::processNode(
   }
 
   handleStopScheduled();
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -24,7 +24,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;

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

@@ -23,7 +23,7 @@ void RecorderAdapterNode::init(size_t bufferSize) {
   buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
 }
 
-void RecorderAdapterNode::processNode(
+std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   float *outputChannel = processingBus->getChannel(0)->getData();
@@ -33,6 +33,8 @@ void RecorderAdapterNode::processNode(
     processingBus->getChannel(i)->copy(
         processingBus->getChannel(0), 0, framesToProcess);
   }
+
+  return processingBus;
 }
 
 void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {

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

@@ -27,7 +27,7 @@ class RecorderAdapterNode : public AudioNode {
     void init(size_t bufferSize);
 
  protected:
-    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
     std::shared_ptr<CircularOverflowableAudioArray> buff_;
 
  private:

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

@@ -147,12 +147,18 @@ void StreamerNode::streamAudio() {
   }
 }
 
-void StreamerNode::processNode(
+std::shared_ptr<AudioBus> StreamerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
   // If we have enough buffered data, copy to output bus
   if (bufferedBusIndex_ >= framesToProcess) {
     Locker locker(mutex_);
@@ -169,6 +175,8 @@ void StreamerNode::processNode(
     }
     bufferedBusIndex_ -= offsetLength;
   }
+
+  return processingBus;
 }
 
 bool StreamerNode::processFrameWithResampler(AVFrame *frame) {

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

@@ -43,16 +43,8 @@ class StreamerNode : public AudioScheduledSourceNode {
   bool initialize(const std::string& inputUrl);
   void stop(double when) override;
 
- private:
-  static constexpr int SIZE = 4'000'000; // 4MB
-
- public:
-  static constexpr int getEstimatedSize() {
-    return StreamerNode::SIZE;
-  } // in bytes
-
  protected:
-  void 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:
   #ifndef AUDIO_API_TEST_SUITE