react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

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

@@ -0,0 +1,210 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/FFT.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
+#include <thread>
+
+namespace audioapi {
+ConvolverNode::ConvolverNode(
+    BaseAudioContext *context,
+    const std::shared_ptr<AudioBuffer> &buffer,
+    bool disableNormalization)
+    : AudioNode(context),
+      remainingSegments_(0),
+      internalBufferIndex_(0),
+      signalledToStop_(false),
+      scaleFactor_(1.0f),
+      intermediateBus_(nullptr),
+      buffer_(nullptr),
+      internalBuffer_(nullptr) {
+  channelCount_ = 2;
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  normalize_ = !disableNormalization;
+  gainCalibrationSampleRate_ = context->getSampleRate();
+  setBuffer(buffer);
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  isInitialized_ = true;
+}
+
+bool ConvolverNode::getNormalize_() const {
+  return normalize_;
+}
+
+const std::shared_ptr<AudioBuffer> &ConvolverNode::getBuffer() const {
+  return buffer_;
+}
+
+void ConvolverNode::setNormalize(bool normalize) {
+  if (normalize_ != normalize) {
+    normalize_ = normalize;
+    if (normalize_ && buffer_)
+      calculateNormalizationScale();
+  }
+  if (!normalize_) {
+    scaleFactor_ = 1.0f;
+  }
+}
+
+void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
+  if (buffer_ != buffer && buffer != nullptr) {
+    buffer_ = buffer;
+    if (normalize_)
+      calculateNormalizationScale();
+    threadPool_ = std::make_shared<ThreadPool>(4);
+    convolvers_.clear();
+    for (int i = 0; i < buffer->getNumberOfChannels(); ++i) {
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(
+          channelData.getData(),
+          buffer->getChannelData(i),
+          buffer->getLength() * sizeof(float));
+      convolvers_.back().init(
+          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    if (buffer->getNumberOfChannels() == 1) {
+      // add one more convolver, because right now input is always stereo
+      convolvers_.emplace_back();
+      AudioArray channelData(buffer->getLength());
+      memcpy(
+          channelData.getData(),
+          buffer->getChannelData(0),
+          buffer->getLength() * sizeof(float));
+      convolvers_.back().init(
+          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
+    }
+    internalBuffer_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE * 2, channelCount_, buffer->getSampleRate());
+    intermediateBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, convolvers_.size(), buffer->getSampleRate());
+    internalBufferIndex_ = 0;
+  }
+}
+
+void ConvolverNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
+  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+    signalledToStop_ = true;
+    remainingSegments_ = convolvers_.at(0).getSegCount();
+  }
+}
+
+std::shared_ptr<AudioBus> ConvolverNode::processInputs(
+    const std::shared_ptr<AudioBus> &outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (internalBufferIndex_ < framesToProcess) {
+    return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
+  }
+  return AudioNode::processInputs(outputBus, 0, false);
+}
+
+// processing pipeline: processingBus -> intermediateBus_ -> audioBus_ (mixing
+// with intermediateBus_)
+std::shared_ptr<AudioBus> ConvolverNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (signalledToStop_) {
+    if (remainingSegments_ > 0) {
+      remainingSegments_--;
+    } else {
+      disable();
+      signalledToStop_ = false;
+      internalBufferIndex_ = 0;
+      return processingBus;
+    }
+  }
+  if (internalBufferIndex_ < framesToProcess) {
+    performConvolution(processingBus); // result returned to intermediateBus_
+    audioBus_->sum(intermediateBus_.get());
+
+    internalBuffer_->copy(
+        audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
+    internalBufferIndex_ += RENDER_QUANTUM_SIZE;
+  }
+  audioBus_->zero();
+  audioBus_->copy(internalBuffer_.get(), 0, 0, framesToProcess);
+  int remainingFrames = internalBufferIndex_ - framesToProcess;
+  if (remainingFrames > 0) {
+    for (int i = 0; i < internalBuffer_->getNumberOfChannels(); ++i) {
+      memmove(
+          internalBuffer_->getChannel(i)->getData(),
+          internalBuffer_->getChannel(i)->getData() + framesToProcess,
+          remainingFrames * sizeof(float));
+    }
+  }
+  internalBufferIndex_ -= framesToProcess;
+
+  for (int i = 0; i < audioBus_->getNumberOfChannels(); ++i) {
+    dsp::multiplyByScalar(
+        audioBus_->getChannel(i)->getData(),
+        scaleFactor_,
+        audioBus_->getChannel(i)->getData(),
+        framesToProcess);
+  }
+
+  return audioBus_;
+}
+
+void ConvolverNode::calculateNormalizationScale() {
+  int numberOfChannels = buffer_->getNumberOfChannels();
+  int length = buffer_->getLength();
+
+  float power = 0;
+
+  for (int channel = 0; channel < numberOfChannels; ++channel) {
+    float channelPower = 0;
+    auto channelData = buffer_->getChannelData(channel);
+    for (int i = 0; i < length; ++i) {
+      float sample = channelData[i];
+      channelPower += sample * sample;
+    }
+    power += channelPower;
+  }
+
+  power = std::sqrt(power / (numberOfChannels * length));
+  if (power < MIN_IR_POWER) {
+    power = MIN_IR_POWER;
+  }
+  scaleFactor_ = 1 / power;
+  scaleFactor_ *= std::pow(10, GAIN_CALIBRATION * 0.05f);
+  scaleFactor_ *= gainCalibrationSampleRate_ / buffer_->getSampleRate();
+}
+
+void ConvolverNode::performConvolution(
+    const std::shared_ptr<AudioBus> &processingBus) {
+  if (processingBus->getNumberOfChannels() == 1) {
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule([&, i] {
+        convolvers_[i].process(
+            processingBus->getChannel(0)->getData(),
+            intermediateBus_->getChannel(i)->getData());
+      });
+    }
+  } else if (processingBus->getNumberOfChannels() == 2) {
+    std::vector<int> inputChannelMap;
+    std::vector<int> outputChannelMap;
+    if (convolvers_.size() == 2) {
+      inputChannelMap = {0, 1};
+      outputChannelMap = {0, 1};
+    } else { // 4 channel IR
+      inputChannelMap = {0, 0, 1, 1};
+      outputChannelMap = {0, 3, 2, 1};
+    }
+    for (int i = 0; i < convolvers_.size(); ++i) {
+      threadPool_->schedule(
+          [this, i, inputChannelMap, outputChannelMap, &processingBus] {
+            convolvers_[i].process(
+                processingBus->getChannel(inputChannelMap[i])->getData(),
+                intermediateBus_->getChannel(outputChannelMap[i])->getData());
+          });
+    }
+  }
+  threadPool_->wait();
+}
+} // namespace audioapi

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/dsp/Convolver.h>
+
+#include <memory>
+#include <vector>
+
+#include <audioapi/utils/ThreadPool.hpp>
+
+static constexpr int GAIN_CALIBRATION = -58; // magic number so that processed signal and dry signal have roughly the same volume
+static constexpr double MIN_IR_POWER = 0.000125;
+
+namespace audioapi {
+
+class AudioBus;
+class AudioBuffer;
+
+class ConvolverNode : public AudioNode {
+ public:
+    explicit ConvolverNode(BaseAudioContext *context, const std::shared_ptr<AudioBuffer>& buffer, bool disableNormalization);
+
+    [[nodiscard]] bool getNormalize_() const;
+    [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;
+    void setNormalize(bool normalize);
+    void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+  void onInputDisabled() override;
+  float gainCalibrationSampleRate_;
+  size_t remainingSegments_;
+  size_t internalBufferIndex_;
+  bool normalize_;
+  bool signalledToStop_;
+  float scaleFactor_;
+  std::shared_ptr<AudioBus>intermediateBus_;
+
+  // impulse response buffer
+  std::shared_ptr<AudioBuffer> buffer_;
+  // buffer to hold internal processed data
+  std::shared_ptr<AudioBus> internalBuffer_;
+  // vectors of convolvers, one per channel
+  std::vector<Convolver> convolvers_;
+  std::shared_ptr<ThreadPool> threadPool_;
+
+  void calculateNormalizationScale();
+  void performConvolution(const std::shared_ptr<AudioBus>& processingBus);
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,36 +1,82 @@
-// void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
-// { node->init(); adapterNodeLock_.lock(); adapterNode_ = node;
-// adapterNodeLock_.unlock();
-// isConnected_.store(true);
-//   node->init(ringBufferSize_);
-//   adapterNodeLock_.lock();
-//   adapterNode_ = node;
-//   adapterNodeLock_.unlock();
-// }
-
-// void AudioRecorder::disconnect() {
-// adapterNodeLock_.lock();
-// adapterNode_ = nullptr;
-// adapterNodeLock_.unlock();
-// isConnected_.store(false);
-// }
-
-// AudioRecorder::AudioRecorder(
-//     const std::shared_ptr<AudioEventHandlerRegistry>
-//     &audioEventHandlerRegistry)
-//       audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-//   constexpr int minRingBufferSize = 8192;
-//   ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-
-//   circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-//   state_.store(RecorderState::Idle);
-// }
-
-// void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-//   if (adapterNodeLock_.try_lock()) {
-//     if (adapterNode_ != nullptr) {
-//       adapterNode_->buff_->write(data, numFrames);
-//     }
-//     adapterNodeLock_.unlock();
-//   }
-// }
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
+
+namespace audioapi {
+
+AudioRecorder::AudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  constexpr int minRingBufferSize = 8192;
+  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
+  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
+  isRunning_.store(false);
+}
+
+void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
+  onAudioReadyCallbackId_ = callbackId;
+}
+
+void AudioRecorder::invokeOnAudioReadyCallback(
+    const std::shared_ptr<AudioBus> &bus,
+    int numFrames) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject =
+      std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> body = {};
+  body.insert({"buffer", audioBufferHostObject});
+  body.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_ != nullptr) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "audioReady", onAudioReadyCallbackId_, body);
+  }
+}
+
+void AudioRecorder::sendRemainingData() {
+  auto bus = std::make_shared<AudioBus>(
+      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
+  auto *outputChannel = bus->getChannel(0)->getData();
+  auto availableFrames =
+      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+
+  circularBuffer_->pop_front(
+      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+
+  invokeOnAudioReadyCallback(bus, availableFrames);
+}
+
+void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+  node->init(ringBufferSize_);
+  adapterNodeLock_.lock();
+  adapterNode_ = node;
+  adapterNodeLock_.unlock();
+}
+
+void AudioRecorder::disconnect() {
+  adapterNodeLock_.lock();
+  adapterNode_ = nullptr;
+  adapterNodeLock_.unlock();
+}
+
+void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
+  if (adapterNodeLock_.try_lock()) {
+    if (adapterNode_ != nullptr) {
+      adapterNode_->buff_->write(data, numFrames);
+    }
+    adapterNodeLock_.unlock();
+  }
+  circularBuffer_->push_back(data, numFrames);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -3,82 +3,61 @@
 #include <memory>
 #include <atomic>
 #include <mutex>
-#include <string>
-#include <tuple>
 
 namespace audioapi {
 
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;
+class CircularOverflowableAudioArray;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  enum RecorderState { Idle, Recording, Paused };
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry):
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
-  virtual ~AudioRecorder() = default;
-
-  virtual std::string start() = 0;
-  virtual std::tuple<std::string, double, double> stop() = 0;
-
-  virtual void enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) = 0;
-  virtual void disableFileOutput() = 0;
-
-  virtual void pause() = 0;
-  virtual void resume() = 0;
-
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node) {}
-  void disconnect() {}
-
-  virtual void setOnAudioReadyCallback(
+  explicit AudioRecorder(
     float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId) = 0;
-  virtual void clearOnAudioReadyCallback() = 0;
-
-  virtual double getCurrentDuration() const = 0;
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
+  );
 
-  bool usesCallback() const {
-    return callbackOutputEnabled_.load();
-  }
+  virtual ~AudioRecorder() = default;
 
-  bool usesFileOutput() const {
-    return fileOutputEnabled_.load();
-  }
+  void setOnAudioReadyCallbackId(uint64_t callbackId);
+  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
 
-  bool isConnected() const {
-    return isConnected_.load();
-  }
+  /// @brief
+  /// # Connects the recorder to the adapter node.
+  ///
+  /// The adapter node will be used to read audio data from the recorder.
+  /// @note Few frames of audio might not yet be written to the buffer when connecting.
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
 
-  bool isRecording() const {
-    return state_.load() == RecorderState::Recording;
-  }
+  /// @brief
+  /// # Disconnects the recorder from the adapter node.
+  ///
+  /// The adapter node will no longer be used to read audio data from the recorder.
+  /// @note Last few frames of audio might be written to the buffer after disconnecting.
+  void disconnect();
 
-  bool isPaused() const {
-    return state_.load() == RecorderState::Paused;
-  }
+  virtual void start() = 0;
+  virtual void stop() = 0;
 
  protected:
-  // size_t ringBufferSize_;
+  float sampleRate_;
+  int bufferLength_;
+  size_t ringBufferSize_;
 
-  std::atomic<RecorderState> state_{ RecorderState::Idle };
-  std::atomic<bool> fileOutputEnabled_{false};
-  std::atomic<bool> callbackOutputEnabled_{false};
-  std::atomic<bool> isConnected_{false};
-  // std::shared_ptr<CircularAudioArray> circularBuffer_;
+  std::atomic<bool> isRunning_;
+  std::shared_ptr<CircularAudioArray> circularBuffer_;
 
   mutable std::mutex adapterNodeLock_;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
 
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  uint64_t onAudioReadyCallbackId_ = 0;
+
+  void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi

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

@@ -36,20 +36,15 @@ std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
   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) {
-  onPositionChangedCallbackId_ = callbackId;
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(
+      callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler(
+        "positionChanged", oldCallbackId);
+  }
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
@@ -66,14 +61,16 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_ &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
+  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;
   }

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

@@ -19,7 +19,6 @@ 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;

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

@@ -31,6 +31,12 @@ void AudioBufferQueueSourceNode::stop(double when) {
   isPaused_ = false;
 }
 
+void AudioBufferQueueSourceNode::start(double when) {
+  isPaused_ = false;
+  stopTime_ = -1.0;
+  AudioScheduledSourceNode::start(when);
+}
+
 void AudioBufferQueueSourceNode::pause() {
   AudioScheduledSourceNode::stop(0.0);
   isPaused_ = true;
@@ -79,6 +85,7 @@ void AudioBufferQueueSourceNode::disable() {
     playbackState_ = PlaybackState::UNSCHEDULED;
     startTime_ = -1.0;
     stopTime_ = -1.0;
+    isPaused_ = false;
 
     return;
   }

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

@@ -21,6 +21,7 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
     ~AudioBufferQueueSourceNode() override;
 
     void stop(double when) override;
+    void start(double when) override;
     void pause();
 
     std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);

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

@@ -123,19 +123,13 @@ 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(
@@ -171,8 +165,8 @@ void AudioBufferSourceNode::sendOnLoopEndedEvent() {
   auto onLoopEndedCallbackId =
       onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId, {});
   }
 }
 

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

@@ -34,7 +34,6 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
-  void clearOnLoopEndedCallback();
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
  protected: