react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-94b7f30-20251224

package/common/cpp/audioapi/core/effects/WaveShaperNode.cpp

@@ -0,0 +1,79 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+WaveShaperNode::WaveShaperNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioNode(context), oversample_(OverSampleType::OVERSAMPLE_NONE) {
+
+  waveShapers_.reserve(6);
+  for (int i = 0; i < channelCount_; i++) {
+    waveShapers_.emplace_back(std::make_unique<WaveShaper>(nullptr));
+  }
+
+  // to change after graph processing improvement - should be max
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  isInitialized_ = true;
+}
+
+std::string WaveShaperNode::getOversample() const {
+  return overSampleTypeToString(oversample_.load(std::memory_order_acquire));
+}
+
+void WaveShaperNode::setOversample(const std::string &type) {
+  std::scoped_lock<std::mutex> lock(mutex_);
+  oversample_.store(overSampleTypeFromString(type), std::memory_order_release);
+
+  for (int i = 0; i < waveShapers_.size(); i++) {
+    waveShapers_[i]->setOversample(overSampleTypeFromString(type));
+  }
+}
+
+std::shared_ptr<AudioArray> WaveShaperNode::getCurve() const {
+  std::scoped_lock<std::mutex> lock(mutex_);
+  return curve_;
+}
+
+void WaveShaperNode::setCurve(const std::shared_ptr<AudioArray> &curve) {
+  std::scoped_lock<std::mutex> lock(mutex_);
+  curve_ = curve;
+
+  for (int i = 0; i < waveShapers_.size(); i++) {
+    waveShapers_[i]->setCurve(curve);
+  }
+}
+
+std::shared_ptr<AudioBus> WaveShaperNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (!isInitialized_) {
+    return processingBus;
+  }
+
+  std::unique_lock<std::mutex> lock(mutex_, std::try_to_lock);
+
+  if (!lock.owns_lock()) {
+    return processingBus;
+  }
+
+  if (curve_ == nullptr) {
+    return processingBus;
+  }
+
+  for (int channel = 0; channel < processingBus->getNumberOfChannels(); channel++) {
+    auto channelData = processingBus->getSharedChannel(channel);
+
+    waveShapers_[channel]->process(channelData, framesToProcess);
+  }
+
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/dsp/Resampler.h>
+#include <audioapi/dsp/WaveShaper.h>
+
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+
+class WaveShaperNode : public AudioNode {
+ public:
+  explicit WaveShaperNode(std::shared_ptr<BaseAudioContext> context);
+
+  [[nodiscard]] std::string getOversample() const;
+  [[nodiscard]] std::shared_ptr<AudioArray> getCurve() const;
+
+  void setOversample(const std::string &type);
+  void setCurve(const std::shared_ptr<AudioArray> &curve);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  std::atomic<OverSampleType> oversample_;
+  std::shared_ptr<AudioArray> curve_{};
+  mutable std::mutex mutex_;
+
+  std::vector<std::unique_ptr<WaveShaper>> waveShapers_{};
+
+  static OverSampleType overSampleTypeFromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "2x")
+      return OverSampleType::OVERSAMPLE_2X;
+    if (lowerType == "4x")
+      return OverSampleType::OVERSAMPLE_4X;
+
+    return OverSampleType::OVERSAMPLE_NONE;
+  }
+
+  static std::string overSampleTypeToString(OverSampleType type) {
+    switch (type) {
+      case OverSampleType::OVERSAMPLE_2X:
+        return "2x";
+      case OverSampleType::OVERSAMPLE_4X:
+        return "4x";
+      default:
+        return "none";
+    }
+  }
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/effects/WorkletNode.cpp

@@ -7,16 +7,16 @@
 namespace audioapi {
 
 WorkletNode::WorkletNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     size_t bufferLength,
     size_t inputChannelCount,
     WorkletsRunner &&runtime)
     : AudioNode(context),
       workletRunner_(std::move(runtime)),
+      bus_(std::make_shared<AudioBus>(bufferLength, inputChannelCount, context->getSampleRate())),
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  bus_ = std::make_shared<AudioBus>(bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 

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

@@ -17,7 +17,7 @@ namespace audioapi {
 class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
-      BaseAudioContext *context,
+      std::shared_ptr<BaseAudioContext> context,
       size_t bufferLength,
       size_t inputChannelCount,
       WorkletsRunner &&workletRunner)
@@ -37,7 +37,7 @@ using namespace facebook;
 class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
-      BaseAudioContext *context,
+      std::shared_ptr<BaseAudioContext> context,
       size_t bufferLength,
       size_t inputChannelCount,
       WorkletsRunner &&workletRunner);

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp

@@ -6,11 +6,9 @@
 namespace audioapi {
 
 WorkletProcessingNode::WorkletProcessingNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     WorkletsRunner &&workletRunner)
     : AudioNode(context), workletRunner_(std::move(workletRunner)) {
-  isInitialized_ = true;
-
   // Pre-allocate buffers for max 128 frames and 2 channels (stereo)
   size_t maxChannelCount = 2;
   inputBuffsHandles_.resize(maxChannelCount);
@@ -23,6 +21,7 @@ WorkletProcessingNode::WorkletProcessingNode(
     auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
     outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
+  isInitialized_ = true;
 }
 
 std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
@@ -60,11 +59,15 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
         // We call unsafely here because we are already on the runtime thread
         // and the runtime is locked by executeOnRuntimeSync (if
         // shouldLockRuntime is true)
+        float time = 0.0f;
+        if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+          time = context->getCurrentTime();
+        }
         return workletRunner_.callUnsafe(
             inputJsArray,
             outputJsArray,
             jsi::Value(rt, static_cast<int>(framesToProcess)),
-            jsi::Value(rt, this->context_->getCurrentTime()));
+            jsi::Value(rt, time));
       });
 
   // Copy processed output data back to the processing bus or zero on failure

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

@@ -16,7 +16,9 @@ namespace audioapi {
 #if RN_AUDIO_API_TEST
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+  explicit WorkletProcessingNode(
+      std::shared_ptr<BaseAudioContext> context,
+      WorkletsRunner &&workletRunner)
       : AudioNode(context) {}
 
  protected:
@@ -32,7 +34,9 @@ using namespace facebook;
 
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
+  explicit WorkletProcessingNode(
+      std::shared_ptr<BaseAudioContext> context,
+      WorkletsRunner &&workletRunner);
 
  protected:
   std::shared_ptr<AudioBus> processNode(

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

@@ -8,9 +8,8 @@
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(int numberOfChannels, size_t length, float sampleRate) {
-  bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
-}
+AudioBuffer::AudioBuffer(int numberOfChannels, size_t length, float sampleRate)
+    : bus_(std::make_shared<AudioBus>(length, numberOfChannels, sampleRate)) {}
 
 AudioBuffer::AudioBuffer(std::shared_ptr<AudioBus> bus) {
   bus_ = std::move(bus);

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

@@ -11,7 +11,7 @@ namespace audioapi {
 
 class AudioBus;
 
-class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
+class AudioBuffer {
  public:
   explicit AudioBuffer(int numberOfChannels, size_t length, float sampleRate);
   explicit AudioBuffer(std::shared_ptr<AudioBus> bus);

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

@@ -11,21 +11,30 @@
 
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     bool pitchCorrection)
-    : AudioScheduledSourceNode(context), pitchCorrection_(pitchCorrection), vReadIndex_(0.0) {
-  onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
-
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
-  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());
-
-  stretch_ = std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
-}
+    : AudioScheduledSourceNode(context),
+      pitchCorrection_(pitchCorrection),
+      stretch_(std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>()),
+      playbackRateBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE * 3,
+              channelCount_,
+              context->getSampleRate())),
+      detuneParam_(
+          std::make_shared<AudioParam>(
+              0.0,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      playbackRateParam_(
+          std::make_shared<AudioParam>(
+              1.0,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      vReadIndex_(0.0),
+      onPositionChangedInterval_(static_cast<int>(context->getSampleRate() * 0.1f)) {}
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
@@ -44,8 +53,10 @@ void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(uint64_t callback
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
-  onPositionChangedInterval_ =
-      static_cast<int>(context_->getSampleRate() * static_cast<float>(interval) / 1000);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    onPositionChangedInterval_ =
+        static_cast<int>(context->getSampleRate() * static_cast<float>(interval) / 1000);
+  }
 }
 
 int AudioBufferBaseSourceNode::getOnPositionChangedInterval() const {
@@ -58,14 +69,22 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
 
 double AudioBufferBaseSourceNode::getInputLatency() const {
   if (pitchCorrection_) {
-    return static_cast<double>(stretch_->inputLatency()) / context_->getSampleRate();
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      return static_cast<double>(stretch_->inputLatency()) / context->getSampleRate();
+    } else {
+      return 0;
+    }
   }
   return 0;
 }
 
 double AudioBufferBaseSourceNode::getOutputLatency() const {
   if (pitchCorrection_) {
-    return static_cast<double>(stretch_->outputLatency()) / context_->getSampleRate();
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      return static_cast<double>(stretch_->outputLatency()) / context->getSampleRate();
+    } else {
+      return 0;
+    }
   }
   return 0;
 }
@@ -91,7 +110,12 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  auto time = context_->getCurrentTime();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBus->zero();
+    return;
+  }
+  auto time = context->getCurrentTime();
   auto playbackRate =
       std::clamp(playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
   auto detune =
@@ -101,7 +125,13 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
 
   auto framesNeededToStretch = static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
 
-  updatePlaybackInfo(playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+  updatePlaybackInfo(
+      playbackRateBus_,
+      framesNeededToStretch,
+      startOffset,
+      offsetLength,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
 
   if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
@@ -126,8 +156,14 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBus->zero();
+    return;
+  }
+  auto computedPlaybackRate =
+      getComputedPlaybackRateValue(framesToProcess, context->getCurrentTime());
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
 
   if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
@@ -143,9 +179,7 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   sendOnPositionChangedEvent();
 }
 
-float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
-  auto time = context_->getCurrentTime();
-
+float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(int framesToProcess, double time) {
   auto playbackRate = playbackRateParam_->processKRateParam(framesToProcess, time);
   auto detune = std::pow(2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
 

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

@@ -14,7 +14,9 @@ class AudioParam;
 
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  explicit AudioBufferBaseSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      bool pitchCorrection);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
@@ -58,7 +60,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess);
 
-  float getComputedPlaybackRateValue(int framesToProcess);
+  float getComputedPlaybackRateValue(int framesToProcess, double time);
 
   virtual void processWithoutInterpolation(
       const std::shared_ptr<AudioBus> &processingBus,

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

@@ -18,11 +18,10 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection) {
-  buffers_ = {};
-  stretch_->presetDefault(channelCount_, context_->getSampleRate());
+    : AudioBufferBaseSourceNode(context, pitchCorrection), buffers_() {
+  stretch_->presetDefault(channelCount_, context->getSampleRate());
 
   if (pitchCorrection) {
     // If pitch correction is enabled, add extra frames at the end
@@ -31,7 +30,7 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
 
     int extraTailFrames = static_cast<int>(stretch_->inputLatency() + stretch_->outputLatency());
     tailBuffer_ =
-        std::make_shared<AudioBuffer>(channelCount_, extraTailFrames, context_->getSampleRate());
+        std::make_shared<AudioBuffer>(channelCount_, extraTailFrames, context->getSampleRate());
 
     tailBuffer_->bus_->zero();
   }
@@ -148,8 +147,12 @@ std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
 }
 
 double AudioBufferQueueSourceNode::getCurrentPosition() const {
-  return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), context_->getSampleRate()) +
-      playedBuffersDuration_;
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    return dsp::sampleFrameToTime(static_cast<int>(vReadIndex_), context->getSampleRate()) +
+        playedBuffersDuration_;
+  } else {
+    return 0.0;
+  }
 }
 
 /**
@@ -192,8 +195,10 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
 
       std::unordered_map<std::string, EventValue> body = {
           {"bufferId", std::to_string(bufferId)}, {"isLast", buffers_.empty()}};
-      context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-          "ended", onEndedCallbackId_, body);
+      if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+        context->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+            "ended", onEndedCallbackId_, body);
+      }
 
       if (buffers_.empty()) {
         if (addExtraTailFrames_) {
@@ -277,8 +282,10 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
       buffers_.pop();
 
       std::unordered_map<std::string, EventValue> body = {{"bufferId", std::to_string(bufferId)}};
-      context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-          "ended", onEndedCallbackId_, body);
+      if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+        context->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+            "ended", onEndedCallbackId_, body);
+      }
 
       if (buffers_.empty()) {
         processingBus->zero(writeIndex, framesLeft);

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

@@ -17,7 +17,9 @@ class AudioParam;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
-  explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  explicit AudioBufferQueueSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      bool pitchCorrection);
   ~AudioBufferQueueSourceNode() override;
 
   void stop(double when) override;

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

@@ -12,15 +12,16 @@
 
 namespace audioapi {
 
-AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection)
+AudioBufferSourceNode::AudioBufferSourceNode(
+    std::shared_ptr<BaseAudioContext> context,
+    bool pitchCorrection)
     : AudioBufferBaseSourceNode(context, pitchCorrection),
       loop_(false),
       loopSkip_(false),
       loopStart_(0),
-      loopEnd_(0) {
-  buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-  alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
-
+      loopEnd_(0),
+      buffer_(nullptr),
+      alignedBus_(nullptr) {
   isInitialized_ = true;
 }
 
@@ -61,7 +62,9 @@ void AudioBufferSourceNode::setLoopSkip(bool loopSkip) {
 
 void AudioBufferSourceNode::setLoopStart(double loopStart) {
   if (loopSkip_) {
-    vReadIndex_ = loopStart * context_->getSampleRate();
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      vReadIndex_ = loopStart * context->getSampleRate();
+    }
   }
   loopStart_ = loopStart;
 }
@@ -72,8 +75,9 @@ void AudioBufferSourceNode::setLoopEnd(double loopEnd) {
 
 void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
   Locker locker(getBufferLock());
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
 
-  if (!buffer) {
+  if (buffer == nullptr || context == nullptr) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
     alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
     loopEnd_ = 0;
@@ -87,7 +91,7 @@ void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer
 
   if (pitchCorrection_) {
     int extraTailFrames =
-        static_cast<int>((getInputLatency() + getOutputLatency()) * context_->getSampleRate());
+        static_cast<int>((getInputLatency() + getOutputLatency()) * context->getSampleRate());
     size_t totalSize = buffer_->getLength() + extraTailFrames;
 
     alignedBus_ = std::make_shared<AudioBus>(totalSize, channelCount_, buffer_->getSampleRate());
@@ -97,11 +101,10 @@ void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer
   } 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());
+      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();
 }
@@ -189,8 +192,15 @@ void AudioBufferSourceNode::processWithoutInterpolation(
   auto readIndex = static_cast<size_t>(vReadIndex_);
   size_t writeIndex = startOffset;
 
-  auto frameStart = static_cast<size_t>(getVirtualStartFrame());
-  auto frameEnd = static_cast<size_t>(getVirtualEndFrame());
+  size_t frameStart;
+  size_t frameEnd;
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    frameStart = static_cast<size_t>(getVirtualStartFrame(context->getSampleRate()));
+    frameEnd = static_cast<size_t>(getVirtualEndFrame(context->getSampleRate()));
+  } else {
+    processingBus->zero();
+    return;
+  }
   size_t frameDelta = frameEnd - frameStart;
 
   size_t framesLeft = offsetLength;
@@ -257,8 +267,15 @@ void AudioBufferSourceNode::processWithInterpolation(
 
   size_t writeIndex = startOffset;
 
-  auto vFrameStart = getVirtualStartFrame();
-  auto vFrameEnd = getVirtualEndFrame();
+  double vFrameStart;
+  double vFrameEnd;
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    vFrameStart = getVirtualStartFrame(context->getSampleRate());
+    vFrameEnd = getVirtualEndFrame(context->getSampleRate());
+  } else {
+    processingBus->zero();
+    return;
+  }
   auto vFrameDelta = vFrameEnd - vFrameStart;
 
   auto frameStart = static_cast<size_t>(vFrameStart);
@@ -305,15 +322,14 @@ void AudioBufferSourceNode::processWithInterpolation(
   }
 }
 
-double AudioBufferSourceNode::getVirtualStartFrame() {
-  auto loopStartFrame = loopStart_ * context_->getSampleRate();
-
+double AudioBufferSourceNode::getVirtualStartFrame(float sampleRate) {
+  auto loopStartFrame = loopStart_ * sampleRate;
   return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame : 0.0;
 }
 
-double AudioBufferSourceNode::getVirtualEndFrame() {
+double AudioBufferSourceNode::getVirtualEndFrame(float sampleRate) {
   auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
-  auto loopEndFrame = loopEnd_ * context_->getSampleRate();
+  auto loopEndFrame = loopEnd_ * sampleRate;
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_
       ? std::min(loopEndFrame, inputBufferLength)

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

@@ -16,7 +16,7 @@ class AudioParam;
 
 class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
  public:
-  explicit AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  explicit AudioBufferSourceNode(std::shared_ptr<BaseAudioContext> context, bool pitchCorrection);
   ~AudioBufferSourceNode() override;
 
   [[nodiscard]] bool getLoop() const;
@@ -69,8 +69,8 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
       size_t offsetLength,
       float playbackRate) override;
 
-  double getVirtualStartFrame();
-  double getVirtualEndFrame();
+  double getVirtualStartFrame(float sampleRate);
+  double getVirtualEndFrame(float sampleRate);
 };
 
 } // namespace audioapi