react-native-audio-api 0.8.3 → 0.9.0-nightly-7ecb495-20251008

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

@@ -2,16 +2,15 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
-
-
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <cassert>
+#include <complex>
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
-#include <complex>
-#include <cstddef>
-#include <cassert>
 
 namespace audioapi {
 
@@ -20,22 +19,25 @@ class GainNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
+class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
-class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
+class WorkletSourceNode;
+class WorkletNode;
+class WorkletProcessingNode;
 class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -45,13 +47,17 @@ 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<OscillatorNode> createOscillator();
+  std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
-  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource();
+  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
   static std::shared_ptr<AudioBuffer>
   createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
@@ -60,10 +66,6 @@ class BaseAudioContext {
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
 
-  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
-  std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
-  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
-
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
@@ -77,9 +79,7 @@ class BaseAudioContext {
 
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
-  std::shared_ptr<AudioDecoder> audioDecoder_ {};
-  // init in AudioContext or OfflineContext constructor
-  float sampleRate_ {};
+  float sampleRate_{};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 
@@ -89,10 +89,11 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
-  virtual bool isDriverRunning() const = 0;
+  [[nodiscard]] virtual bool isDriverRunning() const = 0;
 
  public:
     std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
+    RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -1,11 +1,10 @@
 #include "OfflineAudioContext.h"
 
 #include <audioapi/core/AudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -23,13 +22,13 @@ OfflineAudioContext::OfflineAudioContext(
     size_t length,
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry),
+        &audioEventHandlerRegistry,
+    const RuntimeRegistry &runtimeRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "BaseAudioContext.h"
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <mutex>
 #include <map>
@@ -14,7 +15,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   ~OfflineAudioContext() override;
 
   void resume();

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -143,7 +143,7 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   }
 }
 
-void AnalyserNode::processNode(
+std::shared_ptr<AudioBus> AnalyserNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // Analyser should behave like a sniffer node, it should not modify the
@@ -156,6 +156,8 @@ void AnalyserNode::processNode(
       downMixBus_->getChannel(0)->getData(), framesToProcess, true);
 
   shouldDoFFTAnalysis_ = true;
+
+  return processingBus;
 }
 
 void AnalyserNode::doFFTAnalysis() {

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -39,7 +39,7 @@ class AnalyserNode : public AudioNode {
   void getByteTimeDomainData(uint8_t *data, int length);
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   int fftSize_;

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.h

@@ -24,7 +24,7 @@ class AudioDestinationNode : public AudioNode {
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int) final {};
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int) final { return processingBus; };
 
  private:
   std::size_t currentSampleFrame_;

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

@@ -353,7 +353,7 @@ void BiquadFilterNode::applyFilter() {
   }
 }
 
-void BiquadFilterNode::processNode(
+std::shared_ptr<AudioBus> BiquadFilterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   int numChannels = processingBus->getNumberOfChannels();
@@ -393,6 +393,8 @@ void BiquadFilterNode::processNode(
   x2_ = x2;
   y1_ = y1;
   y2_ = y2;
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -33,7 +33,7 @@ class BiquadFilterNode : public AudioNode {
       int length);
 
  protected:
-  void processNode(
+  std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override;
 

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

@@ -16,7 +16,7 @@ std::shared_ptr<AudioParam> GainNode::getGainParam() const {
   return gainParam_;
 }
 
-void GainNode::processNode(
+std::shared_ptr<AudioBus> GainNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   double time = context_->getCurrentTime();
@@ -28,6 +28,8 @@ void GainNode::processNode(
         processingBus->getChannel(i)->getData(),
         framesToProcess);
   }
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -16,7 +16,7 @@ class GainNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> gainParam_;

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

@@ -26,8 +26,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 
 constexpr unsigned NumberOfOctaveBands = 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>
 
@@ -19,18 +19,20 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
 }
 
-void StereoPannerNode::processNode(
+std::shared_ptr<AudioBus> StereoPannerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
 
-  AudioArray *left = processingBus->getChannelByType(AudioBus::ChannelLeft);
-  AudioArray *right = processingBus->getChannelByType(AudioBus::ChannelRight);
+  auto *inputLeft = processingBus->getChannelByType(AudioBus::ChannelLeft);
   auto panParamValues = panParam_->processARateParam(framesToProcess, time)
                             ->getChannel(0)
                             ->getData();
 
+  auto *outputLeft = audioBus_->getChannelByType(AudioBus::ChannelLeft);
+  auto *outputRight = audioBus_->getChannelByType(AudioBus::ChannelRight);
+
   // Input is mono
   if (processingBus->getNumberOfChannels() == 1) {
     for (int i = 0; i < framesToProcess; i++) {
@@ -40,13 +42,14 @@ void StereoPannerNode::processNode(
       auto gainL = static_cast<float>(cos(x * PI / 2));
       auto gainR = static_cast<float>(sin(x * PI / 2));
 
-      float input = (*left)[i];
+      float input = (*inputLeft)[i];
 
-      (*left)[i] = input * gainL;
-      (*right)[i] = input * gainR;
+      (*outputLeft)[i] = input * gainL;
+      (*outputRight)[i] = input * gainR;
       time += deltaTime;
     }
   } else { // Input is stereo
+    auto *inputRight = processingBus->getChannelByType(AudioBus::ChannelRight);
     for (int i = 0; i < framesToProcess; i++) {
       auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
       auto x = (pan <= 0 ? pan + 1 : pan);
@@ -54,20 +57,22 @@ void StereoPannerNode::processNode(
       auto gainL = static_cast<float>(cos(x * PI / 2));
       auto gainR = static_cast<float>(sin(x * PI / 2));
 
-      float inputL = (*left)[i];
-      float inputR = (*right)[i];
+      float inputL = (*inputLeft)[i];
+      float inputR = (*inputRight)[i];
 
       if (pan <= 0) {
-        (*left)[i] = inputL + inputR * gainL;
-        (*right)[i] = inputR * gainR;
+        (*outputLeft)[i] = inputL + inputR * gainL;
+        (*outputRight)[i] = inputR * gainR;
       } else {
-        (*left)[i] = inputL * gainL;
-        (*right)[i] = inputR + inputL * gainR;
+        (*outputLeft)[i] = inputL * gainL;
+        (*outputRight)[i] = inputR + inputL * gainR;
       }
 
       time += deltaTime;
     }
   }
+
+  return audioBus_;
 }
 
 } // namespace audioapi

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

@@ -18,7 +18,7 @@ class StereoPannerNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> panParam_;

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

@@ -0,0 +1,89 @@
+#include <audioapi/core/effects/WorkletNode.h>
+
+namespace audioapi {
+
+WorkletNode::WorkletNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    size_t bufferLength,
+    size_t inputChannelCount)
+    : AudioNode(context),
+      buffRealLength_(bufferLength * sizeof(float)),
+      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_]);
+  }
+  isInitialized_ = true;
+}
+
+WorkletNode::~WorkletNode() {
+  for (auto &buff : buffs_) {
+    delete[] buff;
+  }
+}
+
+std::shared_ptr<AudioBus> WorkletNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t processed = 0;
+  size_t channelCount_ = std::min(
+      inputChannelCount_,
+      static_cast<size_t>(processingBus->getNumberOfChannels()));
+  while (processed < framesToProcess) {
+    size_t framesToWorkletInvoke = bufferLength_ - curBuffIndex_;
+    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));
+    }
+    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();
+          });
+    }
+  }
+
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,65 @@
+#pragma once
+
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+#if RN_AUDIO_API_TEST
+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
+  ) : AudioNode(context) {}
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+};
+#else
+
+using namespace facebook;
+
+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
+  );
+
+  ~WorkletNode() override;
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+
+ private:
+  WorkletsRunner workletRunner_;
+  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
+  std::vector<uint8_t*> buffs_;
+
+  /// @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_;
+};
+
+#endif // RN_AUDIO_API_TEST
+
+} // namespace audioapi

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

@@ -0,0 +1,91 @@
+#include <audioapi/core/effects/WorkletProcessingNode.h>
+#include <audioapi/core/utils/Constants.h>
+
+namespace audioapi {
+
+WorkletProcessingNode::WorkletProcessingNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime)
+    : AudioNode(context), workletRunner_(runtime), shareableWorklet_(worklet) {
+  isInitialized_ = true;
+
+  // Pre-allocate buffers for max 128 frames and 2 channels (stereo)
+  size_t maxChannelCount = 2;
+  inputBuffsHandles_.resize(maxChannelCount);
+  outputBuffsHandles_.resize(maxChannelCount);
+
+  for (size_t i = 0; i < maxChannelCount; ++i) {
+    auto inputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
+    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
+        inputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+
+    auto outputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
+        outputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+  }
+}
+
+std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t channelCount = std::min(
+      static_cast<size_t>(2), // Fixed to stereo for now
+      static_cast<size_t>(processingBus->getNumberOfChannels()));
+
+  // Copy input data to pre-allocated input buffers
+  for (size_t ch = 0; ch < channelCount; ch++) {
+    auto channelData = processingBus->getChannel(ch)->getData();
+    std::memcpy(
+        /* dest */ inputBuffsHandles_[ch]->data(),
+        /* src */ reinterpret_cast<const uint8_t *>(channelData),
+        /* size */ framesToProcess * sizeof(float));
+  }
+
+  // Execute the worklet
+  auto result = workletRunner_.executeOnRuntimeGuardedSync(
+      [this, channelCount, framesToProcess](jsi::Runtime &rt) {
+        auto inputJsArray = jsi::Array(rt, channelCount);
+        auto outputJsArray = jsi::Array(rt, channelCount);
+
+        for (size_t ch = 0; ch < channelCount; ch++) {
+          // Create input array buffer
+          auto inputArrayBuffer = jsi::ArrayBuffer(rt, inputBuffsHandles_[ch]);
+          inputJsArray.setValueAtIndex(rt, ch, inputArrayBuffer);
+
+          // Create output array buffer
+          auto outputArrayBuffer =
+              jsi::ArrayBuffer(rt, outputBuffsHandles_[ch]);
+          outputJsArray.setValueAtIndex(rt, ch, outputArrayBuffer);
+        }
+
+        return workletRunner_
+            .executeWorklet(
+                shareableWorklet_,
+                inputJsArray,
+                outputJsArray,
+                jsi::Value(rt, static_cast<int>(framesToProcess)),
+                jsi::Value(rt, this->context_->getCurrentTime()))
+            .value_or(jsi::Value::undefined());
+      });
+
+  // Copy processed output data back to the processing bus or zero on failure
+  for (size_t ch = 0; ch < channelCount; ch++) {
+    auto channelData = processingBus->getChannel(ch)->getData();
+
+    if (result.has_value()) {
+      // Copy processed output data
+      std::memcpy(
+          /* dest */ reinterpret_cast<uint8_t *>(channelData),
+          /* src */ outputBuffsHandles_[ch]->data(),
+          /* size */ framesToProcess * sizeof(float));
+    } else {
+      // Zero the output on worklet execution failure
+      std::memset(channelData, 0, framesToProcess * sizeof(float));
+    }
+  }
+
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+#if RN_AUDIO_API_TEST
+class WorkletProcessingNode : public AudioNode {
+ public:
+  explicit WorkletProcessingNode(
+      BaseAudioContext *context,
+      std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime
+  ) : AudioNode(context) {}
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+};
+#else
+
+using namespace facebook;
+
+class WorkletProcessingNode : public AudioNode {
+ public:
+  explicit WorkletProcessingNode(
+      BaseAudioContext *context,
+      std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime
+  );
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  WorkletsRunner workletRunner_;
+  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
+  std::vector<std::shared_ptr<AudioArrayBuffer>> inputBuffsHandles_;
+  std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;
+};
+
+#endif // RN_AUDIO_API_TEST
+
+} // namespace audioapi

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

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/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 <mutex>
 #include <atomic>
+#include <mutex>
 
 namespace audioapi {
+
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;