react-native-audio-api 0.13.1 → 1.0.0-nightly-a9a9810-20260702

package/RNAudioAPI.podspec

@@ -32,7 +32,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/software-mansion/react-native-audio-api.git", :tag => "#{s.version}" }
 
   s.subspec "audioapi" do |ss|
-    ss.source_files = "common/cpp/audioapi/**/*.{cpp,c,h,hpp}"
+    ss.source_files = "common/cpp/audioapi/**/*.{cpp,c,h,hpp}", "common/cpp/test/src/graph/AudioThreadGuard.cpp"
     ss.exclude_files = $RN_AUDIO_API_FFMPEG_DISABLED ? ["common/cpp/audioapi/libs/ffmpeg/**"] : []
     ss.header_dir = "audioapi"
     ss.header_mappings_dir = "common/cpp/audioapi"
@@ -107,6 +107,7 @@ Pod::Spec.new do |s|
     .join(' '),
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
     "GCC_PREPROCESSOR_DEFINITIONS" => '$(inherited) HAVE_ACCELERATE=1',
+    "GCC_PREPROCESSOR_DEFINITIONS[config=Debug]" => '$(inherited) HAVE_ACCELERATE=1 DEBUG=1',
     'OTHER_CFLAGS' => "$(inherited) #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag} #{ffmpeg_flag} #{static_external_libs_flag}",
   }
 

package/android/src/main/cpp/audioapi/CMakeLists.txt

@@ -44,6 +44,11 @@ set(JNI_LIBS_DIR ${CMAKE_SOURCE_DIR}/src/main/jniLibs)
 
 add_library(react-native-audio-api SHARED ${ANDROID_CPP_SOURCES} ${COMMON_CPP_SOURCES})
 
+# Debug-only allocation auditor used by BaseAudioContext::processGraph (mirrors iOS podspec).
+target_sources(react-native-audio-api PRIVATE
+  $<$<CONFIG:Debug>:${COMMON_CPP_DIR}/test/src/graph/AudioThreadGuard.cpp>
+)
+
 if (NOT RN_AUDIO_API_STATIC_EXTERNAL_LIBS_DISABLED)
   foreach(lib IN ITEMS opus opusfile ogg vorbis vorbisenc vorbisfile crypto ssl)
     add_library(${lib} STATIC IMPORTED)
@@ -165,6 +170,11 @@ if (RN_AUDIO_API_FFMPEG_DISABLED)
   )
 endif()
 
+target_compile_definitions(
+  react-native-audio-api
+  PRIVATE $<$<CONFIG:Debug>:DEBUG>
+)
+
 if (RN_AUDIO_API_STATIC_EXTERNAL_LIBS_DISABLED)
   target_compile_definitions(
     react-native-audio-api

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -47,8 +47,8 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   if (dataCallback_ != nullptr) {
     dataCallback_->cleanup();
   }
-  if (adapterNode_ != nullptr) {
-    adapterNode_->adapterCleanup();
+  if (adapterNodeHandle_ != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
   }
   // oboe could be handling stopping and closing the stream, sanity check just in case
   if (mStream_ != nullptr) {
@@ -73,7 +73,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
       ->setDirection(oboe::Direction::Input)
       ->setFormat(oboe::AudioFormat::Float)
       ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+      ->setPerformanceMode(oboe::PerformanceMode::None)
       ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::Medium)
       ->setDataCallback(shared_from_this())
       ->setErrorCallback(shared_from_this());
@@ -95,8 +95,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
 /// @brief prepares and starts the audio recording process.
 /// If audio stream is opened correctly, it will set up any output configured
 /// (file writing, callback, adapter node) and start the stream.
-/// Invoked asynchronously from the PromiseVendor thread pool (not the JS thread);
-/// all shared state is guarded by the recorder locks and atomics.
+/// This method should be called from the JS thread only.
 /// NOTE: I've noticed some possibly invalid file paths being returned on Android,
 /// RN side requires their "file://" prefix, but sometimes it returned raw path.
 /// Most likely this was due to alpha version mistakes, but in case of problems leaving this here. (ㆆ _ ㆆ)
@@ -133,25 +132,20 @@ Result<NoneType, std::string> AndroidAudioRecorder::start(const std::string &fil
 
   if (wantsCallback()) {
     if (dataCallback_ == nullptr) {
-      dataCallback_ = std::make_shared<AndroidRecorderCallback>(
-          audioEventHandlerRegistry_,
-          dataCallbackMetadata_.sampleRate,
-          dataCallbackMetadata_.bufferLength,
-          dataCallbackMetadata_.channelCount,
-          dataCallbackMetadata_.callbackId);
-
-      dataCallback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
+      return Result<NoneType, std::string>::Err("Callback output is unavailable.");
     }
 
+    dataCallback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
     std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
         ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
     callbackOutputConfigured_.store(true, std::memory_order_release);
   }
 
-  if (wantsConnection() && adapterNode_ != nullptr) {
+  if (wantsConnection() && adapterNodeHandle_ != nullptr) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
     connectedConfigured_.store(true, std::memory_order_release);
   }
 
@@ -167,41 +161,41 @@ Result<NoneType, std::string> AndroidAudioRecorder::start(const std::string &fil
 }
 
 /// @brief Stops the audio stream and finalizes any output (file writing, callback, adapter node).
-/// Invoked asynchronously from the PromiseVendor thread pool (not the JS thread);
-/// all shared state is guarded by the recorder locks and atomics.
+/// This method should be called from the JS thread only.
 /// @returns On success, returns the file URI, size in MB and duration in seconds of the recorded file (if file output is enabled).
 /// NOTE: due to the file access nature on Android, the size might sometimes be zeroed (really long files).
-AudioRecorder::StopResult AndroidAudioRecorder::stop() {
+Result<std::tuple<std::vector<std::string>, double, double>, std::string>
+AndroidAudioRecorder::stop() {
   std::shared_ptr<AudioFileWriter> fileWriter;
   std::shared_ptr<AudioRecorderCallback> dataCallback;
-  std::shared_ptr<RecorderAdapterNode> adapterNode;
+  std::shared_ptr<utils::graph::NodeHandle> adapterNodeHandle;
   std::vector<std::string> outputPaths;
 
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+  bool hadFileOutput = false;
+
   {
     std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
 
     if (isIdle()) {
-      return StopResult::Err("Recorder is not in recording state.");
+      return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
+          "Recorder is not in recording state.");
+    }
+
+    if (mStream_ == nullptr) {
+      return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
+          "Audio stream is not initialized.");
     }
 
     state_.store(RecorderState::Idle, std::memory_order_release);
+    mStream_->requestStop();
 
-    // Fully close the stream rather than just stopping it. A stopped-but-open
-    // stream keeps the data/error callbacks registered, so a later device
-    // disconnect fires onErrorAfterClose and resurrects the stream (the mic
-    // stays hot after stop()), and the stream's shared_ptr to this recorder
-    // keeps the recorder alive forever once JS drops it (reference cycle).
-    // start() reopens the stream when mStream_ is null.
-    if (mStream_ != nullptr) {
-      mStream_->requestStop();
-      mStream_->close();
-      mStream_.reset();
-    }
+    hadFileOutput = usesFileOutput();
 
-    if (usesFileOutput()) {
+    if (hadFileOutput) {
       fileOutputConfigured_.store(false, std::memory_order_release);
       fileWriter = std::move(fileWriter_);
-      outputPaths = buildOutputPaths(recordingSegmentPaths_, filePath_);
     }
 
     if (usesCallback()) {
@@ -211,16 +205,44 @@ AudioRecorder::StopResult AndroidAudioRecorder::stop() {
 
     if (isConnected()) {
       connectedConfigured_.store(false, std::memory_order_release);
-      isConnected_.store(false, std::memory_order_release);
-      deinterleavingBuffer_ = nullptr;
-      adapterNode = std::move(adapterNode_);
+      adapterNodeHandle = std::move(adapterNodeHandle_);
     }
+  }
 
-    recordingSegmentPaths_.clear();
-    filePath_ = "";
+  for (const auto &raw : recordingSegmentPaths_) {
+    if (!raw.empty()) {
+      outputPaths.push_back(std::format("file://{}", raw));
+    }
+  }
+  if (hadFileOutput && outputPaths.empty() && !filePath_.empty()) {
+    outputPaths.push_back(std::format("file://{}", filePath_));
+  }
+
+  recordingSegmentPaths_.clear();
+  filePath_ = "";
+
+  if (fileWriter != nullptr) {
+    auto fileResult = fileWriter->closeFile();
+
+    if (!fileResult.is_ok()) {
+      return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
+          "Failed to close file: " + fileResult.unwrap_err());
+    }
+
+    outputFileSize = std::get<0>(fileResult.unwrap());
+    outputDuration = std::get<1>(fileResult.unwrap());
+  }
+
+  if (dataCallback != nullptr) {
+    dataCallback->cleanup();
   }
 
-  return finalizeStoppedOutputs(fileWriter, dataCallback, adapterNode, std::move(outputPaths));
+  if (adapterNodeHandle != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle->audioNode.get())->adapterCleanup();
+  }
+
+  return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Ok(
+      std::make_tuple(std::move(outputPaths), outputFileSize, outputDuration));
 }
 
 /// @brief Enables file output for the recorder with the specified properties.
@@ -295,7 +317,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::setupFileWriter(
     fileWriter_ = createFileWriter(properties);
   }
 
-  fileWriter_->assignOnErrorCallbackId(errorEvent().getCallbackId());
+  fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
 
   auto backend = std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_);
   auto fileResult = backend->openFile(
@@ -316,12 +338,27 @@ Result<NoneType, std::string> AndroidAudioRecorder::setupFileWriter(
   return Result<NoneType, std::string>::Ok(None);
 }
 
+/// @brief Disables file output for the recorder.
+/// If the recorder is currently active, it will finalize and close the file immediately.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::disableFileOutput() {
+  std::shared_ptr<AudioFileWriter> fileWriter;
+  {
+    std::scoped_lock fileWriterLock(fileWriterMutex_);
+    fileOutputConfigured_.store(false, std::memory_order_release);
+    fileOutputEnabled_.store(false, std::memory_order_release);
+    fileWriter = std::move(fileWriter_);
+  }
+
+  if (fileWriter != nullptr) {
+    fileWriter->closeFile();
+  }
+}
+
 /// @brief Pauses the audio recording stream.
 /// For session without active file output, this method acts same as stop().
 /// This method should be called from the JS thread only.
 void AndroidAudioRecorder::pause() {
-  std::scoped_lock pauseLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
-
   if (!isRecording()) {
     return;
   }
@@ -333,9 +370,7 @@ void AndroidAudioRecorder::pause() {
 /// @brief Resumes the audio recording stream if it was previously paused.
 /// This method should be called from the JS thread only.
 void AndroidAudioRecorder::resume() {
-  std::scoped_lock resumeLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
-
-  if (!isPaused() || mStream_ == nullptr) {
+  if (!isPaused()) {
     return;
   }
 
@@ -357,16 +392,9 @@ Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
     int channelCount,
     uint64_t callbackId) {
   std::scoped_lock callbackLock(callbackMutex_, errorCallbackMutex_);
-
-  dataCallbackMetadata_ = {
-      .sampleRate = sampleRate,
-      .bufferLength = bufferLength,
-      .channelCount = channelCount,
-      .callbackId = callbackId};
-
   dataCallback_ = std::make_shared<AndroidRecorderCallback>(
       audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
-  dataCallback_->setOnErrorCallback(errorEvent().getCallbackId());
+  dataCallback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
   callbackOutputEnabled_.store(true, std::memory_order_release);
   callbackOutputConfigured_.store(false, std::memory_order_release);
 
@@ -379,29 +407,53 @@ Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
   return Result<NoneType, std::string>::Ok(None);
 }
 
+/// @brief Clears the audio data callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  std::scoped_lock callbackLock(callbackMutex_);
+  callbackOutputConfigured_.store(false, std::memory_order_release);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
+}
+
 /// @brief Connects a RecorderAdapterNode to the recorder for audio data routing.
 /// If the recorder is already active, it will initialize the adapter node immediately.
 /// This method should be called from the JS thread only.
 /// @param node Shared pointer to the RecorderAdapterNode to connect.
-void AndroidAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+void AndroidAudioRecorder::connect(const std::shared_ptr<utils::graph::NodeHandle> &node) {
   std::scoped_lock adapterLock(adapterNodeMutex_);
-  adapterNode_ = node;
+  adapterNodeHandle_ = node;
   isConnected_.store(true, std::memory_order_release);
   connectedConfigured_.store(false, std::memory_order_release);
 
   if (!isIdle()) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
     connectedConfigured_.store(true, std::memory_order_release);
   }
 }
 
-/// @brief Releases the Android-specific deinterleaving scratch buffer when the
-/// adapter node is disconnected. Invoked from the shared AudioRecorder::disconnect()
-/// while holding adapterNodeMutex_.
-void AndroidAudioRecorder::clearAdapterScratchState() {
-  deinterleavingBuffer_ = nullptr;
+/// @brief Disconnects the currently connected RecorderAdapterNode from the recorder.
+/// If the recorder is currently active, it will stop routing audio data immediately.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::disconnect() {
+  std::shared_ptr<utils::graph::NodeHandle> adapterNodeHandle;
+  bool hadConnection = false;
+  {
+    std::scoped_lock adapterLock(adapterNodeMutex_);
+    hadConnection = isConnected();
+    connectedConfigured_.store(false, std::memory_order_release);
+    isConnected_.store(false, std::memory_order_release);
+    deinterleavingBuffer_ = nullptr;
+    adapterNodeHandle = std::move(adapterNodeHandle_);
+  }
+
+  if (hadConnection && adapterNodeHandle != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle->audioNode.get())->adapterCleanup();
+  }
 }
 
 /// @brief onAudioReady callback that is invoked by the Oboe stream when new audio data is available.
@@ -441,12 +493,14 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
 
   if (isConnected()) {
     if (auto adapterLock = Locker::tryLock(adapterNodeMutex_)) {
-      auto adapterNode = adapterNode_;
+      auto adapterNodeHandle = adapterNodeHandle_;
       auto deinterleavingBuffer = deinterleavingBuffer_;
-      if (!isConnected() || adapterNode == nullptr || deinterleavingBuffer == nullptr) {
+      if (!isConnected() || adapterNodeHandle == nullptr || deinterleavingBuffer == nullptr) {
         return oboe::DataCallbackResult::Continue;
       }
 
+      auto *adapterNode = static_cast<RecorderAdapterNode *>(adapterNodeHandle->audioNode.get());
+
       auto const data = static_cast<float *>(audioData);
       deinterleavingBuffer->deinterleaveFrom(data, numFrames);
 
@@ -461,13 +515,17 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
 
 bool AndroidAudioRecorder::isRecording() const {
   return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
-      mStream_ != nullptr && mStream_->getState() == oboe::StreamState::Started;
+      mStream_->getState() == oboe::StreamState::Started;
 }
 
 bool AndroidAudioRecorder::isPaused() const {
   return state_.load(std::memory_order_acquire) == RecorderState::Paused;
 }
 
+bool AndroidAudioRecorder::isIdle() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
+
 void AndroidAudioRecorder::cleanup() {
   state_.store(RecorderState::Idle, std::memory_order_release);
 
@@ -483,43 +541,29 @@ void AndroidAudioRecorder::cleanup() {
 /// @param oboeStream Pointer to the Oboe audio stream.
 /// @param error The oboe::Result error code.
 void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
-  if (error != oboe::Result::ErrorDisconnected) {
-    std::string message = "Android recorder error: " + std::string(oboe::convertToText(error));
-    errorEvent().dispatch(StringPayload{.name = "message", .reason = std::move(message)});
-    return;
-  }
-
-  // Only restart if the recorder is still supposed to be running. Restarting
-  // unconditionally resurrected stopped recorders, so any audio route change
-  // (e.g. a Bluetooth headset connecting or disconnecting) turned the mic
-  // back on after stop().
-  if (isIdle() || isPaused()) {
-    return;
-  }
+  if (error == oboe::Result::ErrorDisconnected) {
+    cleanup();
 
-  // Serialize with start()/stop(): they mutate mStream_ under these locks on
-  // the JS thread while this runs on oboe's (detached) error thread.
-  std::scoped_lock restartLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+    auto streamResult = openAudioStream();
 
-  // The error thread is detached and can arrive late: if stop()/start() have
-  // already replaced the stream this error belongs to, don't tear down the
-  // healthy new stream.
-  if (stream != mStream_.get()) {
-    return;
-  }
+    if (!streamResult.is_ok()) {
+      uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
 
-  cleanup();
+      if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+        return;
+      }
 
-  auto streamResult = openAudioStream();
+      std::string message = "Android recorder error: " + streamResult.unwrap_err();
+      audioEventHandlerRegistry_->dispatchEvent(
+          AudioEvent::RECORDER_ERROR,
+          callbackId,
+          StringPayload{.name = "message", .reason = std::move(message)});
+      return;
+    }
 
-  if (!streamResult.is_ok()) {
-    std::string message = "Android recorder error: " + streamResult.unwrap_err();
-    errorEvent().dispatch(StringPayload{.name = "message", .reason = std::move(message)});
-    return;
+    mStream_->requestStart();
+    state_.store(RecorderState::Recording, std::memory_order_release);
   }
-
-  mStream_->requestStart();
-  state_.store(RecorderState::Recording, std::memory_order_release);
 }
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -27,31 +27,32 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback,
   void cleanup();
 
   Result<NoneType, std::string> start(const std::string &fileNameOverride) override;
-  StopResult stop() override;
+  Result<std::tuple<std::vector<std::string>, double, double>, std::string> stop() override;
 
   Result<NoneType, std::string> enableFileOutput(
       std::shared_ptr<AudioFileProperties> properties) override;
+  void disableFileOutput() override;
 
   void pause() override;
   void resume() override;
   bool isRecording() const override;
   bool isPaused() const override;
+  bool isIdle() const override;
 
   Result<NoneType, std::string> setOnAudioReadyCallback(
       float sampleRate,
       size_t bufferLength,
       int channelCount,
       uint64_t callbackId) override;
+  void clearOnAudioReadyCallback() override;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void connect(const std::shared_ptr<utils::graph::NodeHandle> &node) override;
+  void disconnect() override;
 
   oboe::DataCallbackResult
   onAudioReady(oboe::AudioStream *oboeStream, void *audioData, int32_t numFrames) override;
   void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
 
- protected:
-  void clearAdapterScratchState() override;
-
  private:
   std::shared_ptr<AudioBuffer> deinterleavingBuffer_;
 

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -14,7 +14,7 @@
 namespace audioapi {
 
 AudioPlayer::AudioPlayer(
-    const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+    const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
     float sampleRate,
     int channelCount,
     std::mutex *driverMutex,
@@ -121,7 +121,7 @@ AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numF
     auto framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
 
     if (isRunning_.load(std::memory_order_acquire)) {
-      renderAudio_(buffer_, framesToProcess);
+      renderAudio_(buffer_.get(), framesToProcess);
     } else {
       buffer_->zero();
     }

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.h

@@ -21,7 +21,7 @@ class AudioPlayer : public AudioStreamDataCallback,
  public:
   friend class AudioContext;
   AudioPlayer(
-      const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+      const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
       float sampleRate,
       int channelCount,
       std::mutex *driverMutex,
@@ -47,7 +47,7 @@ class AudioPlayer : public AudioStreamDataCallback,
   void onErrorAfterClose(AudioStream *audioStream, Result error) override;
 
  private:
-  std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> renderAudio_;
+  std::function<void(DSPAudioBuffer *, int)> renderAudio_;
   std::atomic<uint32_t> &currentRenders_;
   std::shared_ptr<AudioStream> mStream_;
   std::shared_ptr<DSPAudioBuffer> buffer_;

package/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp

@@ -27,6 +27,7 @@ AudioContextHostObject::AudioContextHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     return [audioContext](jsi::Runtime &runtime) {
@@ -39,6 +40,7 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     const auto result = audioContext->resume();
@@ -53,6 +55,7 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     const auto result = audioContext->suspend();
@@ -70,17 +73,12 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, createMediaElementSource) {
   auto sourceObject = args[0].asObject(runtime);
   auto fileSourceHostObject = sourceObject.getHostObject<AudioFileSourceNodeHostObject>(runtime);
-  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto mediaElementSourceNode =
-      audioContext->createMediaElementSource(fileSourceHostObject->getAudioFileSourceNode());
-
-  if (mediaElementSourceNode == nullptr) {
-    throw jsi::JSError(runtime, "This media element is already connected to this AudioContext.");
-  }
-
-  auto mediaElementSourceHostObject =
-      std::make_shared<MediaElementAudioSourceNodeHostObject>(mediaElementSourceNode);
-  return jsi::Object::createFromHostObject(runtime, mediaElementSourceHostObject);
+  auto *fileSourceRaw = fileSourceHostObject->audioFileSourceNode();
+  auto mediaElementHostObject = std::make_shared<MediaElementAudioSourceNodeHostObject>(
+      std::static_pointer_cast<AudioContext>(context_), fileSourceRaw);
+  auto object = jsi::Object::createFromHostObject(runtime, mediaElementHostObject);
+  object.setExternalMemoryPressure(runtime, mediaElementHostObject->getMemoryPressure());
+  return object;
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -1,16 +1,22 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
+#include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h>
 
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 
 AudioNodeHostObject::AudioNodeHostObject(
-    const std::shared_ptr<AudioNode> &node,
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<AudioNode> node,
     const AudioNodeOptions &options)
-    : node_(node),
+    : utils::graph::HostNode(graph, std::move(node)),
       numberOfInputs_(options.numberOfInputs),
       numberOfOutputs_(options.numberOfOutputs),
       channelCount_(options.channelCount),
@@ -58,13 +64,27 @@ JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   auto obj = args[0].getObject(runtime);
+
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
-    auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
-  }
-  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+    auto toNodeHost = obj.getHostObject<AudioNodeHostObject>(runtime);
+
+    // source is a delay node: route through its reader
+    if (auto *fromDelay = dynamic_cast<DelayNodeHostObject *>(this); fromDelay != nullptr) {
+      fromDelay->delayReaderHostNode_->connect(*toNodeHost);
+      return jsi::Value::undefined();
+    }
+
+    // destination is a delay node: route through its writer
+    if (auto *toDelay = dynamic_cast<DelayNodeHostObject *>(toNodeHost.get()); toDelay != nullptr) {
+      connect(*toDelay->delayWriterHostNode_);
+      return jsi::Value::undefined();
+    }
+
+    connect(*toNodeHost);
+  } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    param->connectToGraph();
+    graph_->addEdge(node_, param->bridgeNode());
   }
   return jsi::Value::undefined();
 }
@@ -72,19 +92,20 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
   // protect direct usage of raw jsi classes
   if (args == nullptr || args[0].isUndefined()) {
-    node_->disconnect();
+    disconnect();
     return jsi::Value::undefined();
   }
+
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
-  }
-
-  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+    disconnect(*node);
+  } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    // Disconnect source → bridge
+    graph_->removeEdge(node_, param->bridgeNode());
   }
+
   return jsi::Value::undefined();
 }
 } // namespace audioapi