feat: integrated new memory disposer

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -67,17 +67,17 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
   }
 
   auto threadPool = std::make_shared<ThreadPool>(4);
-  std::vector<Convolver> convolvers;
+  std::vector<std::unique_ptr<Convolver>> convolvers;
   for (size_t i = 0; i < copiedBuffer->getNumberOfChannels(); ++i) {
     AudioArray channelData(*copiedBuffer->getChannel(i));
     convolvers.emplace_back();
-    convolvers.back().init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
+    convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
   if (copiedBuffer->getNumberOfChannels() == 1) {
     // add one more convolver, because right now input is always stereo
     AudioArray channelData(*copiedBuffer->getChannel(0));
     convolvers.emplace_back();
-    convolvers.back().init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
+    convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
 
   auto internalBuffer = std::make_shared<DSPAudioBuffer>(
@@ -87,7 +87,7 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
 
   struct SetupData {
     std::shared_ptr<AudioBuffer> buffer;
-    std::vector<Convolver> convolvers;
+    std::vector<std::unique_ptr<Convolver>> convolvers;
     std::shared_ptr<ThreadPool> threadPool;
     std::shared_ptr<DSPAudioBuffer> internalBuffer;
     std::shared_ptr<DSPAudioBuffer> intermediateBuffer;

packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -38,10 +38,11 @@ BaseAudioContext::BaseAudioContext(
     const RuntimeRegistry &runtimeRegistry)
     : state_(ContextState::SUSPENDED),
       sampleRate_(sampleRate),
-      graphManager_(std::make_shared<AudioGraphManager>()),
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
-      audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY) {}
+      audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
+      disposer_(std::make_shared<utils::DisposerImpl<16>>(AUDIO_SCHEDULER_CAPACITY)),
+      graphManager_(std::make_shared<AudioGraphManager>(disposer_)) {}
 
 void BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
@@ -256,4 +257,8 @@ const RuntimeRegistry &BaseAudioContext::getRuntimeRegistry() const {
   return runtimeRegistry_;
 }
 
+std::shared_ptr<utils::DisposerImpl<16>> BaseAudioContext::getDisposer() const {
+  return disposer_;
+}
+
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h

@@ -2,6 +2,7 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
@@ -107,6 +108,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<AudioGraphManager> getGraphManager() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
+  std::shared_ptr<utils::DisposerImpl<16>> getDisposer() const;
 
   virtual void initialize();
 
@@ -131,7 +133,6 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  private:
   std::atomic<ContextState> state_;
   std::atomic<float> sampleRate_;
-  std::shared_ptr<AudioGraphManager> graphManager_;
   std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
   RuntimeRegistry runtimeRegistry_;
 
@@ -142,6 +143,8 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
+  std::shared_ptr<utils::DisposerImpl<16>> disposer_;
+  std::shared_ptr<AudioGraphManager> graphManager_;
 
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 };

packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp

@@ -27,7 +27,7 @@ ConvolverNode::ConvolverNode(
 
 void ConvolverNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer,
-    std::vector<Convolver> convolvers,
+    std::vector<std::unique_ptr<Convolver>> convolvers,
     const std::shared_ptr<ThreadPool> &threadPool,
     const std::shared_ptr<DSPAudioBuffer> &internalBuffer,
     const std::shared_ptr<DSPAudioBuffer> &intermediateBuffer,
@@ -39,11 +39,25 @@ void ConvolverNode::setBuffer(
 
   auto graphManager = context->getGraphManager();
 
-  if (buffer_) {
-    graphManager->addAudioBufferForDestruction(std::move(buffer_));
+  if (buffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(buffer_));
   }
 
-  // TODO move convolvers, thread pool and DSPAudioBuffers destruction to graph manager as well
+  if (threadPool_ != nullptr) {
+    context->getDisposer()->dispose(std::move(threadPool_));
+  }
+
+  for (auto it = convolvers_.begin(); it != convolvers_.end(); ++it) {
+    context->getDisposer()->dispose(std::move(*it));
+  }
+
+  if (internalBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(internalBuffer_));
+  }
+
+  if (intermediateBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(intermediateBuffer_));
+  }
 
   buffer_ = buffer;
   convolvers_ = std::move(convolvers);
@@ -86,7 +100,7 @@ void ConvolverNode::onInputDisabled() {
   numberOfEnabledInputNodes_ -= 1;
   if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
     signalledToStop_ = true;
-    remainingSegments_ = convolvers_.at(0).getSegCount();
+    remainingSegments_ = convolvers_.at(0)->getSegCount();
   }
 }
 
@@ -144,7 +158,7 @@ void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &pr
   if (processingBuffer->getNumberOfChannels() == 1) {
     for (int i = 0; i < convolvers_.size(); ++i) {
       threadPool_->schedule([&, i] {
-        convolvers_[i].process(
+        convolvers_[i]->process(
             *processingBuffer->getChannel(0), *intermediateBuffer_->getChannel(i));
       });
     }
@@ -160,7 +174,7 @@ void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &pr
     }
     for (int i = 0; i < convolvers_.size(); ++i) {
       threadPool_->schedule([this, i, inputChannelMap, outputChannelMap, &processingBuffer] {
-        convolvers_[i].process(
+        convolvers_[i]->process(
             *processingBuffer->getChannel(inputChannelMap[i]),
             *intermediateBuffer_->getChannel(outputChannelMap[i]));
       });

packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h

@@ -27,7 +27,7 @@ class ConvolverNode : public AudioNode {
   /// @note Audio Thread only
   void setBuffer(
       const std::shared_ptr<AudioBuffer> &buffer,
-      std::vector<Convolver> convolvers,
+      std::vector<std::unique_ptr<Convolver>> convolvers,
       const std::shared_ptr<ThreadPool> &threadPool,
       const std::shared_ptr<DSPAudioBuffer> &internalBuffer,
       const std::shared_ptr<DSPAudioBuffer> &intermediateBuffer,
@@ -58,7 +58,7 @@ class ConvolverNode : public AudioNode {
   // buffer to hold internal processed data
   std::shared_ptr<DSPAudioBuffer> internalBuffer_;
   // vectors of convolvers, one per channel
-  std::vector<Convolver> convolvers_;
+  std::vector<std::unique_ptr<Convolver>> convolvers_;
   std::shared_ptr<ThreadPool> threadPool_;
 
   void performConvolution(const std::shared_ptr<DSPAudioBuffer> &processingBuffer);

packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp

@@ -81,7 +81,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
     auto graphManager = context->getGraphManager();
 
     if (buffers_.front().first == bufferId) {
-      graphManager->addAudioBufferForDestruction(std::move(buffers_.front().second));
+      context->getDisposer()->dispose(std::move(buffers_.front().second));
       buffers_.pop_front();
       vReadIndex_ = 0.0;
       return;
@@ -91,7 +91,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
     // And keep vReadIndex_ at the same position.
     for (auto it = std::next(buffers_.begin()); it != buffers_.end(); ++it) {
       if (it->first == bufferId) {
-        graphManager->addAudioBufferForDestruction(std::move(it->second));
+        context->getDisposer()->dispose(std::move(it->second));
         buffers_.erase(it);
         return;
       }
@@ -102,7 +102,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
 void AudioBufferQueueSourceNode::clearBuffers() {
   if (auto context = context_.lock()) {
     for (auto it = buffers_.begin(); it != buffers_.end(); ++it) {
-      context->getGraphManager()->addAudioBufferForDestruction(std::move(it->second));
+      context->getDisposer()->dispose(std::move(it->second));
     }
 
     buffers_.clear();
@@ -215,15 +215,15 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
             buffers_.emplace_back(bufferId, tailBuffer_);
             addExtraTailFrames_ = false;
           } else {
-            context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+            context->getDisposer()->dispose(std::move(buffer));
             processingBuffer->zero(writeIndex, framesLeft);
             readIndex = 0;
 
             break;
           }
         }
 
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+        context->getDisposer()->dispose(std::move(buffer));
         data = buffers_.front();
         bufferId = data.first;
         buffer = data.second;
@@ -296,14 +296,14 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
         sendOnBufferEndedEvent(bufferId, buffers_.empty());
 
         if (buffers_.empty()) {
-          context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+          context->getDisposer()->dispose(std::move(buffer));
           processingBuffer->zero(writeIndex, framesLeft);
           vReadIndex_ = 0.0;
           break;
         }
 
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
         vReadIndex_ = vReadIndex_ - buffer->getSize();
+        context->getDisposer()->dispose(std::move(buffer));
         data = buffers_.front();
         bufferId = data.first;
         buffer = data.second;

packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -58,10 +58,16 @@ void AudioBufferSourceNode::setBuffer(
   auto graphManager = context->getGraphManager();
 
   if (buffer_ != nullptr) {
-    graphManager->addAudioBufferForDestruction(std::move(buffer_));
+    context->getDisposer()->dispose(std::move(buffer_));
   }
 
-  // TODO move DSPAudioBuffers destruction to graph manager as well
+  if (playbackRateBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(playbackRateBuffer_));
+  }
+
+  if (audioBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(audioBuffer_));
+  }
 
   if (buffer == nullptr) {
     loopEnd_ = 0;

packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp

@@ -72,11 +72,11 @@ AudioGraphManager::Event::~Event() {
   }
 }
 
-AudioGraphManager::AudioGraphManager() {
+AudioGraphManager::AudioGraphManager(const std::shared_ptr<utils::DisposerImpl<16>> &disposer)
+    : disposer_(disposer) {
   sourceNodes_.reserve(kInitialCapacity);
   processingNodes_.reserve(kInitialCapacity);
   audioParams_.reserve(kInitialCapacity);
-  audioBuffers_.reserve(kInitialCapacity);
 
   auto channel_pair = channels::spsc::channel<
       std::unique_ptr<Event>,
@@ -119,9 +119,8 @@ void AudioGraphManager::addPendingParamConnection(
 
 void AudioGraphManager::preProcessGraph() {
   settlePendingConnections();
-  AudioGraphManager::prepareForDestruction(sourceNodes_, nodeDestructor_);
-  AudioGraphManager::prepareForDestruction(processingNodes_, nodeDestructor_);
-  AudioGraphManager::prepareForDestruction(audioBuffers_, bufferDestructor_);
+  prepareForDestruction(sourceNodes_);
+  prepareForDestruction(processingNodes_);
 }
 
 void AudioGraphManager::addProcessingNode(const std::shared_ptr<AudioNode> &node) {
@@ -151,11 +150,6 @@ void AudioGraphManager::addAudioParam(const std::shared_ptr<AudioParam> &param)
   sender_.send(std::move(event));
 }
 
-void AudioGraphManager::addAudioBufferForDestruction(std::shared_ptr<AudioBuffer> buffer) {
-  // direct access because this is called from the Audio thread
-  audioBuffers_.emplace_back(std::move(buffer));
-}
-
 void AudioGraphManager::settlePendingConnections() {
   std::unique_ptr<Event> value;
   while (receiver_.try_receive(value) != channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
@@ -234,7 +228,6 @@ void AudioGraphManager::cleanup() {
   sourceNodes_.clear();
   processingNodes_.clear();
   audioParams_.clear();
-  audioBuffers_.clear();
 }
 
 } // namespace audioapi