react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-9548557-20251223

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

@@ -7,14 +7,16 @@
 
 namespace audioapi {
 
-DelayNode::DelayNode(BaseAudioContext *context, float maxDelayTime) : AudioNode(context) {
-  delayTimeParam_ = std::make_shared<AudioParam>(0, 0, maxDelayTime, context);
-  delayBuffer_ = std::make_shared<AudioBus>(
-      static_cast<size_t>(
-          maxDelayTime * context->getSampleRate() +
-          1), // +1 to enable delayTime equal to maxDelayTime
-      channelCount_,
-      context->getSampleRate());
+DelayNode::DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime)
+    : AudioNode(context),
+      delayTimeParam_(std::make_shared<AudioParam>(0, 0, maxDelayTime, context)),
+      delayBuffer_(
+          std::make_shared<AudioBus>(
+              static_cast<size_t>(
+                  maxDelayTime * context->getSampleRate() +
+                  1), // +1 to enable delayTime equal to maxDelayTime
+              channelCount_,
+              context->getSampleRate())) {
   requiresTailProcessing_ = true;
   isInitialized_ = true;
 }
@@ -27,7 +29,11 @@ void DelayNode::onInputDisabled() {
   numberOfEnabledInputNodes_ -= 1;
   if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
     signalledToStop_ = true;
-    remainingFrames_ = delayTimeParam_->getValue() * context_->getSampleRate();
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      remainingFrames_ = delayTimeParam_->getValue() * context->getSampleRate();
+    } else {
+      remainingFrames_ = 0;
+    }
   }
 }
 
@@ -89,8 +95,11 @@ std::shared_ptr<AudioBus> DelayNode::processNode(
   }
 
   // normal processing
-  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context_->getCurrentTime());
-  size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context_->getSampleRate()) %
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context->getCurrentTime());
+  size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context->getSampleRate()) %
       delayBuffer_->getSize();
   delayBufferOperation(processingBus, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
   delayBufferOperation(processingBus, framesToProcess, readIndex_, DelayNode::BufferAction::READ);

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

@@ -12,7 +12,7 @@ class AudioBus;
 
 class DelayNode : public AudioNode {
  public:
-  explicit DelayNode(BaseAudioContext *context, float maxDelayTime);
+  explicit DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 

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

@@ -7,9 +7,14 @@
 
 namespace audioapi {
 
-GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+GainNode::GainNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioNode(context),
+      gainParam_(
+          std::make_shared<AudioParam>(
+              1.0,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)) {
   isInitialized_ = true;
 }
 
@@ -20,7 +25,10 @@ std::shared_ptr<AudioParam> GainNode::getGainParam() const {
 std::shared_ptr<AudioBus> GainNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  double time = context_->getCurrentTime();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  double time = context->getCurrentTime();
   auto gainParamValues = gainParam_->processARateParam(framesToProcess, time);
   for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
     dsp::multiply(

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

@@ -11,7 +11,7 @@ class AudioBus;
 
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(BaseAudioContext *context);
+  explicit GainNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 

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

@@ -35,11 +35,10 @@
 namespace audioapi {
 
 IIRFilterNode::IIRFilterNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     const std::vector<float> &feedforward,
     const std::vector<float> &feedback)
     : AudioNode(context), feedforward_(feedforward), feedback_(feedback) {
-  isInitialized_ = true;
   channelCountMode_ = ChannelCountMode::MAX;
 
   int maxChannels = MAX_CHANNEL_COUNT;
@@ -65,6 +64,7 @@ IIRFilterNode::IIRFilterNode(
 
     feedback_[0] = 1.0f;
   }
+  isInitialized_ = true;
 }
 
 // Compute Z-transform of the filter
@@ -89,7 +89,10 @@ void IIRFilterNode::getFrequencyResponse(
     float *magResponseOutput,
     float *phaseResponseOutput,
     size_t length) {
-  float nyquist = context_->getNyquistFrequency();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return;
+  float nyquist = context->getNyquistFrequency();
 
   for (size_t k = 0; k < length; ++k) {
     float normalizedFreq = frequencyArray[k] / nyquist;

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

@@ -37,7 +37,7 @@ class IIRFilterNode : public AudioNode {
 
  public:
   explicit IIRFilterNode(
-      BaseAudioContext *context,
+      std::shared_ptr<BaseAudioContext> context,
       const std::vector<float> &feedforward,
       const std::vector<float> &feedback);
 

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

@@ -9,9 +9,9 @@
 
 namespace audioapi {
 
-StereoPannerNode::StereoPannerNode(BaseAudioContext *context) : AudioNode(context) {
+StereoPannerNode::StereoPannerNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioNode(context), panParam_(std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context)) {
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context);
   isInitialized_ = true;
 }
 
@@ -22,8 +22,11 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
 std::shared_ptr<AudioBus> StereoPannerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  double time = context_->getCurrentTime();
-  double deltaTime = 1.0 / context_->getSampleRate();
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr)
+    return processingBus;
+  double time = context->getCurrentTime();
+  double deltaTime = 1.0 / context->getSampleRate();
 
   auto *inputLeft = processingBus->getChannelByType(AudioBus::ChannelLeft);
   auto panParamValues =

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

@@ -13,7 +13,7 @@ class AudioBus;
 
 class StereoPannerNode : public AudioNode {
  public:
-  explicit StereoPannerNode(BaseAudioContext *context);
+  explicit StereoPannerNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 

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

@@ -7,7 +7,7 @@
 namespace audioapi {
 
 WorkletNode::WorkletNode(
-    BaseAudioContext *context,
+    std::shared_ptr<BaseAudioContext> context,
     size_t bufferLength,
     size_t inputChannelCount,
     WorkletsRunner &&runtime)
@@ -15,8 +15,8 @@ WorkletNode::WorkletNode(
       workletRunner_(std::move(runtime)),
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
-      curBuffIndex_(0) {
-  bus_ = std::make_shared<AudioBus>(bufferLength, inputChannelCount, context->getSampleRate());
+      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),
+      vReadIndex_(0.0),
+      onPositionChangedInterval_(static_cast<int>(context->getSampleRate() * 0.1f)),
+      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>>()) {}
 
 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;