react-native-audio-api 0.9.0 → 0.9.2

package/RNAudioAPI.podspec

@@ -1,4 +1,5 @@
 require "json"
+require_relative './scripts/rnaa_utils'
 
 package_json = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
@@ -8,6 +9,8 @@ folly_flags = "-DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-
 fabric_flags = $new_arch_enabled ? '-DRCT_NEW_ARCH_ENABLED' : ''
 version_flag = "-DAUDIOAPI_VERSION=#{package_json['version']}"
 
+worklets_preprocessor_flag = check_if_worklets_enabled() ? '-DRN_AUDIO_API_ENABLE_WORKLETS=1' : ''
+
 Pod::Spec.new do |s|
   s.name         = "RNAudioAPI"
   s.version      = package_json["version"]
@@ -68,8 +71,8 @@ s.pod_target_xcconfig = {
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include/vorbis
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/ffmpeg_include
   ].join(" "),
-  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}",
-  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}"
+  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag}",
+  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag}",
 }
 
 s.user_target_xcconfig = {

package/android/build.gradle

@@ -74,6 +74,30 @@ def resolveReactNativeWorkletsDirectory() {
   return null;
 }
 
+def validateWorkletsVersion() {
+  def validationScript = file("${projectDir}/../scripts/validate-worklets-version.js")
+  if (!validationScript.exists()) {
+    logger.error("[AudioAPI] Worklets validation script not found at ${validationScript.absolutePath}")
+    return false
+  }
+
+  try {
+    def process = ["node", validationScript.absolutePath].execute()
+    process.waitForProcessOutput(System.out, System.err)
+    def exitCode = process.exitValue()
+
+    if (exitCode == 0) {
+      return true
+    } else {
+      logger.warn("[AudioAPI] Worklets version validation failed")
+      return false
+    }
+  } catch (Exception e) {
+    logger.error("[AudioAPI] Failed to validate worklets version: ${e.message}")
+    return false
+  }
+}
+
 def toPlatformFileString(String path) {
   if (Os.isFamily(Os.FAMILY_WINDOWS)) {
       path = path.replace(File.separatorChar, '/' as char)
@@ -92,7 +116,7 @@ static def supportsNamespace() {
 
 def reactNativeRootDir = resolveReactNativeDirectory()
 def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
-def isWorkletsAvailable = reactNativeWorkletsRootDir != null
+def isWorkletsAvailable = reactNativeWorkletsRootDir != null && validateWorkletsVersion()
 
 def reactProperties = new Properties()
 file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
@@ -123,7 +147,7 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    
+
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     buildConfigField "boolean", "RN_AUDIO_API_ENABLE_WORKLETS", "${isWorkletsAvailable}"
 

package/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp

@@ -51,6 +51,7 @@ void AudioAPIModule::registerNatives() {
       makeNativeMethod(
           "invokeHandlerWithEventNameAndEventBody",
           AudioAPIModule::invokeHandlerWithEventNameAndEventBody),
+      makeNativeMethod("closeAllContexts", AudioAPIModule::closeAllContexts),
   });
 }
 
@@ -101,4 +102,8 @@ void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
         eventName->toStdString(), body);
   }
 }
+
+void AudioAPIModule::closeAllContexts() {
+  AudioAPIModuleInstaller::closeAllContexts();
+}
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/AudioAPIModule.h

@@ -34,6 +34,7 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
 
   void injectJSIBindings();
   void invokeHandlerWithEventNameAndEventBody(jni::alias_ref<jni::JString> eventName, jni::alias_ref<jni::JMap<jstring, jobject>> eventBody);
+  void closeAllContexts();
 
  private:
   friend HybridBase;

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

@@ -4,6 +4,7 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <jni.h>
 
 namespace audioapi {
 
@@ -49,7 +50,8 @@ bool AudioPlayer::openAudioStream() {
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    nativeAudioPlayer_->start();
+    jni::ThreadScope::WithClassLoader(
+        [this]() { nativeAudioPlayer_->start(); });
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -59,7 +61,7 @@ bool AudioPlayer::start() {
 
 void AudioPlayer::stop() {
   if (mStream_) {
-    nativeAudioPlayer_->stop();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->stop(); });
     mStream_->requestStop();
   }
 }

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -1,6 +1,8 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -16,7 +18,8 @@ import java.lang.ref.WeakReference
 @ReactModule(name = AudioAPIModule.NAME)
 class AudioAPIModule(
   reactContext: ReactApplicationContext,
-) : NativeAudioAPIModuleSpec(reactContext) {
+) : NativeAudioAPIModuleSpec(reactContext),
+  LifecycleEventListener {
   companion object {
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
@@ -24,6 +27,7 @@ class AudioAPIModule(
   val reactContext: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
 
   private val mHybridData: HybridData
+  private var reanimatedModule: NativeModule? = null
 
   external fun initHybrid(
     workletsModule: Any?,
@@ -38,6 +42,8 @@ class AudioAPIModule(
     eventBody: Map<String, Any>,
   )
 
+  private external fun closeAllContexts()
+
   init {
     try {
       System.loadLibrary("react-native-audio-api")
@@ -47,6 +53,8 @@ class AudioAPIModule(
       if (BuildConfig.RN_AUDIO_API_ENABLE_WORKLETS) {
         try {
           workletsModule = reactContext.getNativeModule("WorkletsModule")
+          reanimatedModule = reactContext.getNativeModule("ReanimatedModule")
+          reanimatedModule
         } catch (ex: Exception) {
           throw RuntimeException("WorkletsModule not found - make sure react-native-worklets is properly installed")
         }
@@ -64,6 +72,26 @@ class AudioAPIModule(
     return true
   }
 
+  override fun onHostResume() {
+    // do nothing
+  }
+
+  override fun onHostPause() {
+    closeAllContexts()
+  }
+
+  override fun onHostDestroy() {
+    // do nothing
+  }
+
+  override fun initialize() {
+    reactContext.get()?.addLifecycleEventListener(this)
+  }
+
+  override fun invalidate() {
+    // think about cleaning up resources, singletons etc.
+  }
+
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
   override fun setAudioSessionActivity(

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -14,12 +14,16 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
 using namespace facebook;
 
 class AudioAPIModuleInstaller {
+ private:
+  inline static std::vector<std::weak_ptr<AudioContext>> contexts_ = {};
+
  public:
   static void injectJSIBindings(
     jsi::Runtime *jsiRuntime,
@@ -39,6 +43,19 @@ class AudioAPIModuleInstaller {
     jsiRuntime->global().setProperty(*jsiRuntime, "AudioEventEmitter", jsi::Object::createFromHostObject(*jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
+  static void closeAllContexts() {
+    for (auto it = contexts_.begin(); it != contexts_.end(); ++it) {
+      auto weakContext = *it;
+
+      if (auto context = weakContext.lock()) {
+        context->close();
+      }
+
+      it = contexts_.erase(it);
+    --it;
+    }
+  }
+
  private:
   static jsi::Function getCreateAudioContextFunction(
     jsi::Runtime *jsiRuntime,
@@ -67,9 +84,16 @@ class AudioAPIModuleInstaller {
               auto runtimeRegistry = RuntimeRegistry{};
           #endif
 
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, runtimeRegistry);
-          auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
-              audioContext, &runtime, jsCallInvoker);
+          audioContext = std::make_shared<AudioContext>(
+              sampleRate,
+              initSuspended,
+              audioEventHandlerRegistry,
+              runtimeRegistry);
+          AudioAPIModuleInstaller::contexts_.push_back(audioContext);
+
+          auto audioContextHostObject =
+              std::make_shared<AudioContextHostObject>(
+                  audioContext, &runtime, jsCallInvoker);
 
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
@@ -103,9 +127,16 @@ class AudioAPIModuleInstaller {
             auto runtimeRegistry = RuntimeRegistry{};
             #endif
 
-            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
-            auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-                offlineAudioContext, &runtime, jsCallInvoker);
+            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
+              numberOfChannels,
+              length,
+              sampleRate,
+              audioEventHandlerRegistry,
+              runtimeRegistry);
+
+            auto audioContextHostObject =
+              std::make_shared<OfflineAudioContextHostObject>(
+                    offlineAudioContext, &runtime, jsCallInvoker);
 
             return jsi::Object::createFromHostObject(
                 runtime, audioContextHostObject);

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -81,14 +81,15 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
           runtime, args[0]);
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletSourceNode =
-      context_->createWorkletSourceNode(shareableWorklet, workletRuntime);
+  auto workletSourceNode = context_->createWorkletSourceNode(
+      shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletSourceNodeHostObject =
       std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
   return jsi::Object::createFromHostObject(
@@ -105,6 +106,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
@@ -114,7 +116,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
   auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
   auto workletNode = context_->createWorkletNode(
-      shareableWorklet, workletRuntime, bufferLength, inputChannelCount);
+      shareableWorklet,
+      workletRuntime,
+      bufferLength,
+      inputChannelCount,
+      shouldLockRuntime);
   auto workletNodeHostObject =
       std::make_shared<WorkletNodeHostObject>(workletNode);
   return jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
@@ -132,14 +138,15 @@ JSI_HOST_FUNCTION_IMPL(
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletProcessingNode =
-      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime);
+  auto workletProcessingNode = context_->createWorkletProcessingNode(
+      shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletProcessingNodeHostObject =
       std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
   return jsi::Object::createFromHostObject(

package/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -42,14 +43,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, numberOfChannels) {
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) {
   auto channel = static_cast<int>(args[0].getNumber());
-  auto channelData =
-      reinterpret_cast<uint8_t *>(audioBuffer_->getChannelData(channel));
-  auto length = static_cast<int>(audioBuffer_->getLength());
-  auto size = static_cast<int>(length * sizeof(float));
-
-  // reading or writing from this ArrayBuffer could cause a crash
-  // if underlying channelData is deallocated
-  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(channelData, size);
+  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(
+      audioBuffer_->bus_->getSharedChannel(channel));
   auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
 
   auto float32ArrayCtor =

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -67,9 +67,11 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
 
 std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletSourceNode =
-      std::make_shared<WorkletSourceNode>(this, shareableWorklet, runtime);
+      std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
   nodeManager_->addSourceNode(workletSourceNode);
   return workletSourceNode;
 }
@@ -78,9 +80,11 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
-    size_t inputChannelCount) {
+    size_t inputChannelCount,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletNode = std::make_shared<WorkletNode>(
-      this, shareableWorklet, runtime, bufferLength, inputChannelCount);
+      this, bufferLength, inputChannelCount, std::move(workletRunner));
   nodeManager_->addProcessingNode(workletNode);
   return workletNode;
 }
@@ -88,9 +92,11 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
 std::shared_ptr<WorkletProcessingNode>
 BaseAudioContext::createWorkletProcessingNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletProcessingNode =
-      std::make_shared<WorkletProcessingNode>(this, shareableWorklet, runtime);
+      std::make_shared<WorkletProcessingNode>(this, std::move(workletRunner));
   nodeManager_->addProcessingNode(workletProcessingNode);
   return workletProcessingNode;
 }

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -49,9 +49,20 @@ class BaseAudioContext {
   std::shared_ptr<AudioDestinationNode> getDestination();
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
-  std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
-  std::shared_ptr<WorkletNode> createWorkletNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime, size_t bufferLength, size_t inputChannelCount);
-  std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
+  std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime = true);
+  std::shared_ptr<WorkletNode> createWorkletNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    size_t bufferLength,
+    size_t inputChannelCount,
+    bool shouldLockRuntime = true);
+  std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime = true);
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();

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

@@ -4,30 +4,19 @@ namespace audioapi {
 
 WorkletNode::WorkletNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
-    size_t inputChannelCount)
+    size_t inputChannelCount,
+    WorkletsRunner &&runtime)
     : AudioNode(context),
-      buffRealLength_(bufferLength * sizeof(float)),
+      workletRunner_(std::move(runtime)),
       bufferLength_(bufferLength),
-      workletRunner_(runtime),
-      shareableWorklet_(worklet),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  buffs_.reserve(inputChannelCount_);
-  for (size_t i = 0; i < inputChannelCount_; ++i) {
-    buffs_.emplace_back(new uint8_t[buffRealLength_]);
-  }
+  bus_ = std::make_shared<AudioBus>(
+      bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 
-WorkletNode::~WorkletNode() {
-  for (auto &buff : buffs_) {
-    delete[] buff;
-  }
-}
-
 std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -40,47 +29,45 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     size_t needsToProcess = framesToProcess - processed;
     size_t shouldProcess = std::min(framesToWorkletInvoke, needsToProcess);
 
-    for (size_t ch = 0; ch < channelCount_; ch++) {
-      /// here we copy
-      /// to   uint8_t* [curBuffIndex_, curBuffIndex_ + shouldProcess]
-      /// from float* [processed, processed + shouldProcess]
-      /// so as the we need to copy shouldProcess * sizeof(float) bytes
-      auto channelData = processingBus->getChannel(ch)->getData();
-      std::memcpy(
-          /* dest */ buffs_[ch] + curBuffIndex_ * sizeof(float),
-          /* src */ reinterpret_cast<const uint8_t *>(channelData + processed),
-          /* size */ shouldProcess * sizeof(float));
-    }
+    /// here we copy
+    /// to [curBuffIndex_, curBuffIndex_ + shouldProcess]
+    /// from [processed, processed + shouldProcess]
+    bus_->copy(processingBus.get(), processed, curBuffIndex_, shouldProcess);
+
     processed += shouldProcess;
     curBuffIndex_ += shouldProcess;
 
     /// If we filled the entire buffer, we need to execute the worklet
-    if (curBuffIndex_ == bufferLength_) {
-      // Reset buffer index, channel buffers and execute worklet
-      curBuffIndex_ = 0;
-      workletRunner_.executeOnRuntimeGuardedSync(
-          [this, channelCount_](jsi::Runtime &uiRuntimeRaw) {
-            /// Arguments preparation
-            auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
-            for (size_t ch = 0; ch < channelCount_; ch++) {
-              uint8_t *buffPtr = buffs_[ch];
-              buffs_[ch] = new uint8_t[buffRealLength_];
-              auto sharedAudioArray =
-                  std::make_shared<AudioArrayBuffer>(buffPtr, buffRealLength_);
-              auto arrayBuffer =
-                  jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
-              jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
-            }
-            jsArray.setExternalMemoryPressure(
-                uiRuntimeRaw, channelCount_ * buffRealLength_);
-
-            workletRunner_.executeWorklet(
-                shareableWorklet_,
-                std::move(jsArray),
-                jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
-            return jsi::Value::undefined();
-          });
+    if (curBuffIndex_ != bufferLength_) {
+      continue;
     }
+    // Reset buffer index, channel buffers and execute worklet
+    curBuffIndex_ = 0;
+    workletRunner_.executeOnRuntimeSync([this, channelCount_](
+                                            jsi::Runtime &uiRuntimeRaw) {
+      /// Arguments preparation
+      auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
+      for (size_t ch = 0; ch < channelCount_; ch++) {
+        auto audioArray = std::make_shared<AudioArray>(bufferLength_);
+        audioArray->copy(bus_->getChannel(ch));
+        auto sharedAudioArray = std::make_shared<AudioArrayBuffer>(audioArray);
+        auto sharedAudioArraySize = sharedAudioArray->size();
+        auto arrayBuffer =
+            jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+        arrayBuffer.setExternalMemoryPressure(
+            uiRuntimeRaw, sharedAudioArraySize);
+        jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
+      }
+
+      bus_->zero();
+
+      /// Call the worklet
+      workletRunner_.callUnsafe(
+          std::move(jsArray),
+          jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
+
+      return jsi::Value::undefined();
+    });
   }
 
   return processingBus;

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

@@ -19,10 +19,9 @@ class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
-      size_t inputChannelCount
+      size_t inputChannelCount,
+      WorkletsRunner &&workletRunner
   ) : AudioNode(context) {}
 
  protected:
@@ -36,13 +35,12 @@ class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
-      size_t inputChannelCount
+      size_t inputChannelCount,
+      WorkletsRunner &&workletRunner
   );
 
-  ~WorkletNode() override;
+  ~WorkletNode() override = default;
 
  protected:
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
@@ -50,11 +48,9 @@ class WorkletNode : public AudioNode {
 
  private:
   WorkletsRunner workletRunner_;
-  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
-  std::vector<uint8_t*> buffs_;
+  std::shared_ptr<AudioBus> bus_;
 
   /// @brief Length of the byte buffer that will be passed to the AudioArrayBuffer
-  size_t buffRealLength_;
   size_t bufferLength_;
   size_t inputChannelCount_;
   size_t curBuffIndex_;