react-native-audio-api 0.8.3-nightly-ea268f4-20251006 → 0.8.3

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

@@ -1,6 +1,6 @@
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
-#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 

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

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>

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

@@ -1,11 +1,11 @@
 #pragma once
 
+
 #include <memory>
-#include <atomic>
 #include <mutex>
+#include <atomic>
 
 namespace audioapi {
-
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;

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

@@ -1,18 +1,14 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
-#include <audioapi/core/utils/Constants.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
-AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
-    BaseAudioContext *context,
-    bool pitchCorrection)
-    : AudioScheduledSourceNode(context),
-      pitchCorrection_(pitchCorrection),
-      vReadIndex_(0.0) {
+AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context), vReadIndex_(0.0) {
   onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
 
   detuneParam_ = std::make_shared<AudioParam>(
@@ -28,7 +24,12 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
 }
 
 AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  clearOnPositionChangedCallback();
+  if (onPositionChangedCallbackId_ != 0 &&
+      context_->audioEventHandlerRegistry_ != nullptr) {
+    context_->audioEventHandlerRegistry_->unregisterHandler(
+        "positionChanged", onPositionChangedCallbackId_);
+    onPositionChangedCallbackId_ = 0;
+  }
 }
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
@@ -61,7 +62,7 @@ void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
       context_->getSampleRate() * static_cast<float>(interval) / 1000);
 }
 
-int AudioBufferBaseSourceNode::getOnPositionChangedInterval() const {
+int AudioBufferBaseSourceNode::getOnPositionChangedInterval() {
   return onPositionChangedInterval_;
 }
 
@@ -124,45 +125,7 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
   if (detune != 0.0f) {
     stretch_->setTransposeSemitones(detune);
   }
-
   sendOnPositionChangedEvent();
 }
 
-void AudioBufferBaseSourceNode::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();
-}
-
-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);
-
-  return playbackRate * detune;
-}
-
 } // namespace audioapi

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

@@ -14,8 +14,8 @@ class AudioParam;
 
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferBaseSourceNode() override;
+  explicit AudioBufferBaseSourceNode(BaseAudioContext *context);
+  virtual ~AudioBufferBaseSourceNode();
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
@@ -23,12 +23,9 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
-  [[nodiscard]] int getOnPositionChangedInterval() const;
+  [[nodiscard]] int getOnPositionChangedInterval();
 
  protected:
-    // pitch correction
-    bool pitchCorrection_;
-
     std::mutex bufferLock_;
 
     // pitch correction
@@ -50,25 +47,13 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
     virtual double getCurrentPosition() const = 0;
 
     void sendOnPositionChangedEvent();
-
     void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
                                     int framesToProcess);
-    void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                       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 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

@@ -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,9 +11,8 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    BaseAudioContext *context,
-    bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection) {
+    BaseAudioContext *context)
+    : AudioBufferBaseSourceNode(context) {
   buffers_ = {};
   stretch_->presetDefault(channelCount_, context_->getSampleRate());
 
@@ -91,17 +90,13 @@ void 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;
     }
 
-    if (!pitchCorrection_) {
-      processWithoutPitchCorrection(processingBus, framesToProcess);
-    } else {
-      processWithPitchCorrection(processingBus, framesToProcess);
-    }
+    processWithPitchCorrection(processingBus, framesToProcess);
 
     handleStopScheduled();
   } else {
@@ -140,7 +135,6 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
 
     assert(readIndex >= 0);
     assert(writeIndex >= 0);
-    assert(readIndex + framesToCopy <= buffer->getLength());
     assert(writeIndex + framesToCopy <= processingBus->getSize());
 
     processingBus->copy(
@@ -155,7 +149,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
       buffers_.pop();
 
       std::unordered_map<std::string, EventValue> body = {
-          {"bufferId", std::to_string(bufferId)}, {"isLast", buffers_.empty()}};
+          {"bufferId", std::to_string(bufferId)}};
       context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
           "ended", onEndedCallbackId_, body);
 
@@ -164,12 +158,13 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
         readIndex = 0;
 
         break;
-      }
+      } else {
+        data = buffers_.front();
+        bufferId = data.first;
+        buffer = data.second;
 
-      data = buffers_.front();
-      bufferId = data.first;
-      buffer = data.second;
-      readIndex = 0;
+        readIndex = 0;
+      }
     }
   }
 
@@ -177,81 +172,4 @@ 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,14 +17,14 @@ class AudioParam;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
-    explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
+    explicit AudioBufferQueueSourceNode(BaseAudioContext *context);
     ~AudioBufferQueueSourceNode() override;
 
     void stop(double when) override;
     void pause();
 
     std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-    void dequeueBuffer(size_t bufferId);
+    void dequeueBuffer(const size_t bufferId);
     void clearBuffers();
     void disable() override;
 
@@ -46,12 +46,6 @@ 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,11 +13,12 @@ namespace audioapi {
 AudioBufferSourceNode::AudioBufferSourceNode(
     BaseAudioContext *context,
     bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection),
+    : AudioBufferBaseSourceNode(context),
       loop_(false),
       loopSkip_(false),
       loopStart_(0),
-      loopEnd_(0) {
+      loopEnd_(0),
+      pitchCorrection_(pitchCorrection) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
   alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
@@ -29,8 +30,6 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
-
-  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {
@@ -125,21 +124,6 @@ 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;
-}
-
 void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -167,19 +151,35 @@ 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,8 +243,6 @@ void AudioBufferSourceNode::processWithoutInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
-
-      sendOnLoopEndedEvent();
     }
   }
 
@@ -306,12 +304,23 @@ 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,9 +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:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
   double getCurrentPosition() const override;
@@ -48,12 +45,15 @@ 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_;
 
-  std::atomic<uint64_t> onLoopEndedCallbackId_ = 0; // 0 means no callback
-  void sendOnLoopEndedEvent();
+  void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                     int framesToProcess);
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
@@ -65,7 +65,9 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
       const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate) override;
+      float playbackRate);
+
+  float getComputedPlaybackRateValue(int framesToProcess);
 
   double getVirtualStartFrame();
   double getVirtualEndFrame();

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

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

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

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

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/Constants.h>
 #include <audioapi/dsp/Windows.h>
 
 namespace audioapi::dsp {

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 
 namespace audioapi {

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -53,9 +53,8 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
         "volumeChange",
     };
 
-    static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES = {
+    static constexpr std::array<std::string_view, 5> AUDIO_API_EVENT_NAMES = {
       "ended",
-      "loopEnded",
       "audioReady",
       "positionChanged",
       "audioError",

package/common/cpp/audioapi/events/AudioEventHandlerRegistryHostObject.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioEventHandlerRegistryHostObject : public JsiHostObject {
+ public:
+    explicit AudioEventHandlerRegistryHostObject(const std::shared_ptr<AudioEventHandlerRegistry>& eventHandlerRegistry) {
+        eventHandlerRegistry_ = eventHandlerRegistry;
+
+        addFunctions(
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, addAudioEventListener),
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, removeAudioEventListener));
+    }
+
+    JSI_HOST_FUNCTION(addAudioEventListener) {
+      auto eventName = args[0].getString(runtime).utf8(runtime);
+      auto callback = std::make_shared<jsi::Function>(args[1].getObject(runtime).getFunction(runtime));
+
+      auto listenerId = eventHandlerRegistry_->registerHandler(eventName, callback);
+
+      return jsi::String::createFromUtf8(runtime, std::to_string(listenerId));
+    }
+
+    JSI_HOST_FUNCTION(removeAudioEventListener) {
+        auto eventName = args[0].getString(runtime).utf8(runtime);
+        uint64_t listenerId = std::stoull(args[1].getString(runtime).utf8(runtime));
+
+        eventHandlerRegistry_->unregisterHandler(eventName, listenerId);
+
+        return jsi::Value::undefined();
+    }
+
+ private:
+    std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
+};
+} // namespace audioapi
+

package/common/cpp/audioapi/jsi/AudioArrayBuffer.h

@@ -9,20 +9,7 @@ using namespace facebook;
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
   AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
-  ~AudioArrayBuffer() override {
-    if (data_ == nullptr) {
-      return;
-    }
-    delete[] data_;
-  }
-  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
-      : data_(other.data_), size_(other.size_) {
-    other.data_ = nullptr;
-  }
-
-  AudioArrayBuffer(const AudioArrayBuffer &) = delete;
-  AudioArrayBuffer &operator=(const AudioArrayBuffer &) = delete;
-  AudioArrayBuffer &operator=(AudioArrayBuffer &&other) = delete;
+  ~AudioArrayBuffer() override = default;
 
   [[nodiscard]] size_t size() const override;
   uint8_t *data() override;