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

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

@@ -23,7 +23,7 @@ void RecorderAdapterNode::init(size_t bufferSize) {
   buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
 }
 
-void RecorderAdapterNode::processNode(
+std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   float *outputChannel = processingBus->getChannel(0)->getData();
@@ -33,6 +33,8 @@ void RecorderAdapterNode::processNode(
     processingBus->getChannel(i)->copy(
         processingBus->getChannel(0), 0, framesToProcess);
   }
+
+  return processingBus;
 }
 
 void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {

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

@@ -27,7 +27,7 @@ class RecorderAdapterNode : public AudioNode {
     void init(size_t bufferSize);
 
  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;
     std::shared_ptr<CircularOverflowableAudioArray> buff_;
 
  private:

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

@@ -147,12 +147,18 @@ void StreamerNode::streamAudio() {
   }
 }
 
-void StreamerNode::processNode(
+std::shared_ptr<AudioBus> StreamerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
   // If we have enough buffered data, copy to output bus
   if (bufferedBusIndex_ >= framesToProcess) {
     Locker locker(mutex_);
@@ -169,6 +175,8 @@ void StreamerNode::processNode(
     }
     bufferedBusIndex_ -= offsetLength;
   }
+
+  return processingBus;
 }
 
 bool StreamerNode::processFrameWithResampler(AVFrame *frame) {

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

@@ -43,16 +43,8 @@ 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;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   #ifndef AUDIO_API_TEST_SUITE

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

@@ -0,0 +1,84 @@
+#include <audioapi/core/sources/WorkletSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
+
+namespace audioapi {
+
+WorkletSourceNode::WorkletSourceNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime)
+    : AudioScheduledSourceNode(context),
+      workletRunner_(runtime),
+      shareableWorklet_(worklet) {
+  isInitialized_ = true;
+
+  // Prepare buffers for audio processing
+  size_t outputChannelCount = this->getChannelCount();
+  outputBuffsHandles_.resize(outputChannelCount);
+  for (size_t i = 0; i < outputChannelCount; ++i) {
+    auto buff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
+        buff, RENDER_QUANTUM_SIZE * sizeof(float));
+  }
+}
+
+std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (isUnscheduled() || isFinished() || !isEnabled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  size_t startOffset = 0;
+  size_t nonSilentFramesToProcess = framesToProcess;
+
+  updatePlaybackInfo(
+      processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+
+  if (nonSilentFramesToProcess == 0) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  size_t outputChannelCount = processingBus->getNumberOfChannels();
+
+  auto result = workletRunner_.executeOnRuntimeGuardedSync(
+      [this, nonSilentFramesToProcess, startOffset](jsi::Runtime &rt) {
+        auto jsiArray = jsi::Array(rt, this->outputBuffsHandles_.size());
+        for (size_t i = 0; i < this->outputBuffsHandles_.size(); ++i) {
+          auto arrayBuffer = jsi::ArrayBuffer(rt, this->outputBuffsHandles_[i]);
+          jsiArray.setValueAtIndex(rt, i, arrayBuffer);
+        }
+        return workletRunner_
+            .executeWorklet(
+                shareableWorklet_,
+                jsiArray,
+                jsi::Value(rt, static_cast<int>(nonSilentFramesToProcess)),
+                jsi::Value(rt, this->context_->getCurrentTime()),
+                jsi::Value(rt, static_cast<int>(startOffset)))
+            .value_or(jsi::Value::undefined());
+      });
+
+  // If the worklet execution failed, zero the output
+  // It might happen if the runtime is not available
+  if (!result.has_value()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  // Copy the processed data back to the AudioBus
+  for (size_t i = 0; i < outputChannelCount; ++i) {
+    float *channelData = processingBus->getChannel(i)->getData();
+    memcpy(
+        channelData + startOffset,
+        outputBuffsHandles_[i]->data(),
+        nonSilentFramesToProcess * sizeof(float));
+  }
+
+  handleStopScheduled();
+
+  return processingBus;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,47 @@
+#pragma once
+#include <jsi/jsi.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioArray.h>
+
+#include <vector>
+#include <memory>
+
+namespace audioapi {
+
+#if RN_AUDIO_API_TEST
+class WorkletSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit WorkletSourceNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime
+  ) : AudioScheduledSourceNode(context) {}
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+};
+#else
+
+class WorkletSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit WorkletSourceNode(
+    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>> outputBuffsHandles_;
+};
+#endif // RN_AUDIO_API_TEST
+
+} // namespace audioapi

package/common/cpp/audioapi/core/types/AudioFormat.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace audioapi {
+
+enum class AudioFormat {
+  UNKNOWN,
+  WAV,
+  OGG,
+  FLAC,
+  AAC,
+  MP3,
+  M4A,
+  MP4,
+  MOV
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioDecoder.h

@@ -1,124 +1,67 @@
 #pragma once
 
-#include <audioapi/libs/audio-stretch/stretch.h>
+#include <audioapi/core/types/AudioFormat.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
+#include <algorithm>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
-#include <cstring>
-#include <algorithm>
 
 namespace audioapi {
 
-enum class AudioFormat {
-  UNKNOWN,
-  WAV,
-  OGG,
-  FLAC,
-  AAC,
-  MP3,
-  M4A,
-  MP4,
-  MOV
-};
-
-class AudioBus;
+class AudioBuffer;
 
 static constexpr int CHUNK_SIZE = 4096;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
+  AudioDecoder() = delete;
 
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithFilePath(
-      const std::string &path) const;
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithMemoryBlock(
-      const void *data,
-      size_t size) const;
-  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(
-      const std::string &data,
-      float playbackSpeed) const;
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer>
+  decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer>
+  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
 
  private:
-  float sampleRate_;
-  int numChannels_ = 2;
-
-  static std::vector<int16_t> readAllPcmFrames(
-      ma_decoder &decoder,
-      int numChannels,
-      ma_uint64 &outFramesRead);
-  static std::shared_ptr<AudioBus> makeAudioBusFromInt16Buffer(
-      const std::vector<int16_t> &buffer,
-      int numChannels,
-      float sampleRate);
-
-  void changePlaybackSpeedIfNeeded(
-      std::vector<int16_t> &buffer,
-      size_t framesDecoded,
-      int numChannels,
-      float playbackSpeed) const {
-    if (playbackSpeed == 1.0f) {
-      return;
-    }
-
-    auto stretcher = stretch_init(
-        static_cast<int>(sampleRate_ / 333.0f),
-        static_cast<int>(sampleRate_ / 55.0f),
-        numChannels,
-        0x1);
+  static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
+  static std::shared_ptr<AudioBuffer>
+  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
 
-    int maxOutputFrames = stretch_output_capacity(
-        stretcher, static_cast<int>(framesDecoded), 1 / playbackSpeed);
-    std::vector<int16_t> stretchedBuffer(maxOutputFrames);
-
-    int outputFrames = stretch_samples(
-        stretcher,
-        buffer.data(),
-        static_cast<int>(framesDecoded),
-        stretchedBuffer.data(),
-        1 / playbackSpeed);
-
-    outputFrames +=
-        stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
-    stretchedBuffer.resize(outputFrames);
-
-    buffer = stretchedBuffer;
-
-    stretch_deinit(stretcher);
-  }
-
-  static AudioFormat detectAudioFormat(const void* data, size_t size) {
-    if (size < 12) return AudioFormat::UNKNOWN;
-    const auto* bytes = static_cast<const unsigned char*>(data);
+  static AudioFormat detectAudioFormat(const void *data, size_t size) {
+    if (size < 12)
+      return AudioFormat::UNKNOWN;
+    const auto *bytes = static_cast<const unsigned char *>(data);
 
     // WAV/RIFF
     if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0)
-        return AudioFormat::WAV;
+      return AudioFormat::WAV;
 
     // OGG
     if (std::memcmp(bytes, "OggS", 4) == 0)
-        return AudioFormat::OGG;
+      return AudioFormat::OGG;
 
     // FLAC
     if (std::memcmp(bytes, "fLaC", 4) == 0)
-        return AudioFormat::FLAC;
+      return AudioFormat::FLAC;
 
     // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
     if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0)
-        return AudioFormat::AAC;
+      return AudioFormat::AAC;
 
     // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
     if (std::memcmp(bytes, "ID3", 3) == 0)
-        return AudioFormat::MP3;
+      return AudioFormat::MP3;
     if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0)
-        return AudioFormat::MP3;
+      return AudioFormat::MP3;
 
     if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
-        if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
-            return AudioFormat::M4A;
-        else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
-            return AudioFormat::MOV;
-        return AudioFormat::MP4;
+      if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
+        return AudioFormat::M4A;
+      else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
+        return AudioFormat::MOV;
+      return AudioFormat::MP4;
     }
     return AudioFormat::UNKNOWN;
   }
@@ -126,19 +69,21 @@ class AudioDecoder {
   static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
-    for (const auto& ext : extensions) {
-        if (pathLower.ends_with(ext))
-            return true;
+    for (const auto &ext : extensions) {
+      if (pathLower.ends_with(ext))
+        return true;
     }
     return false;
   }
 
-
   [[nodiscard]] static inline int16_t floatToInt16(float sample) {
-    return static_cast<int16_t>(sample * 32768.0f);
+    return static_cast<int16_t>(sample * INT16_MAX);
   }
   [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / 32768.0f;
+    return static_cast<float>(sample) / INT16_MAX;
+  }
+  [[nodiscard]] static inline float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
+    return static_cast<float>(static_cast<int16_t>((byte2 << 8) | byte1)) / INT16_MAX;
   }
 };
 

package/common/cpp/audioapi/core/{AudioParamEventQueue.cpp → utils/AudioParamEventQueue.cpp}

@@ -1,4 +1,4 @@
-#include <audioapi/core/AudioParamEventQueue.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
 
 namespace audioapi {
 
@@ -31,12 +31,12 @@ bool AudioParamEventQueue::popFront(ParamChangeEvent &event) {
 
 void AudioParamEventQueue::cancelScheduledValues(double cancelTime) {
   while (!eventQueue_.isEmpty()) {
-    auto &front = eventQueue_.peekBack();
-    if (front.getEndTime() < cancelTime) {
+    auto &back = eventQueue_.peekBack();
+    if (back.getEndTime() < cancelTime) {
       break;
     }
-    if (front.getStartTime() >= cancelTime ||
-        front.getType() == ParamChangeEventType::SET_VALUE_CURVE) {
+    if (back.getStartTime() >= cancelTime ||
+        back.getType() == ParamChangeEventType::SET_VALUE_CURVE) {
       eventQueue_.popBack();
     }
   }
@@ -46,8 +46,8 @@ void AudioParamEventQueue::cancelAndHoldAtTime(
     double cancelTime,
     double &endTimeCache) {
   while (!eventQueue_.isEmpty()) {
-    auto &front = eventQueue_.peekBack();
-    if (front.getEndTime() < cancelTime || front.getStartTime() <= cancelTime) {
+    auto &back = eventQueue_.peekBack();
+    if (back.getEndTime() < cancelTime || back.getStartTime() <= cancelTime) {
       break;
     }
     eventQueue_.popBack();
@@ -59,6 +59,12 @@ void AudioParamEventQueue::cancelAndHoldAtTime(
   }
 
   auto &back = eventQueue_.peekBackMut();
+  back.setEndValue(back.getCalculateValue()(
+      back.getStartTime(),
+      back.getEndTime(),
+      back.getStartValue(),
+      back.getEndValue(),
+      cancelTime));
   back.setEndTime(std::min(cancelTime, back.getEndTime()));
 }
 

package/common/cpp/audioapi/core/utils/AudioStretcher.cpp

@@ -0,0 +1,75 @@
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/AudioStretcher.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/libs/audio-stretch/stretch.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <cstdint>
+
+namespace audioapi {
+
+std::vector<int16_t> AudioStretcher::castToInt16Buffer(AudioBuffer &buffer) {
+  const size_t numChannels = buffer.getNumberOfChannels();
+  const size_t numFrames = buffer.getLength();
+
+  std::vector<int16_t> int16Buffer(numFrames * numChannels);
+
+  for (size_t ch = 0; ch < numChannels; ++ch) {
+    const float *channelData = buffer.getChannelData(ch);
+    for (size_t i = 0; i < numFrames; ++i) {
+      int16Buffer[i * numChannels + ch] = floatToInt16(channelData[i]);
+    }
+  }
+
+  return int16Buffer;
+}
+
+std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
+    AudioBuffer buffer,
+    float playbackSpeed) {
+  const float sampleRate = buffer.getSampleRate();
+  const size_t outputChannels = buffer.getNumberOfChannels();
+  const size_t numFrames = buffer.getLength();
+
+  if (playbackSpeed == 1.0f) {
+    return std::make_shared<AudioBuffer>(buffer);
+  }
+
+  std::vector<int16_t> int16Buffer = castToInt16Buffer(buffer);
+
+  auto stretcher = stretch_init(
+      static_cast<int>(sampleRate / UPPER_FREQUENCY_LIMIT_DETECTION),
+      static_cast<int>(sampleRate / LOWER_FREQUENCY_LIMIT_DETECTION),
+      outputChannels,
+      0x1);
+
+  int maxOutputFrames = stretch_output_capacity(
+      stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
+  std::vector<int16_t> stretchedBuffer(maxOutputFrames * outputChannels);
+
+  int outputFrames = stretch_samples(
+      stretcher,
+      int16Buffer.data(),
+      static_cast<int>(numFrames),
+      stretchedBuffer.data(),
+      1 / playbackSpeed);
+
+  outputFrames +=
+      stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+  stretchedBuffer.resize(outputFrames * outputChannels);
+  stretch_deinit(stretcher);
+
+  auto audioBus =
+      std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
+
+  for (int ch = 0; ch < outputChannels; ++ch) {
+    auto channelData = audioBus->getChannel(ch)->getData();
+    for (int i = 0; i < outputFrames; ++i) {
+      channelData[i] = int16ToFloat(stretchedBuffer[i * outputChannels + ch]);
+    }
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioStretcher.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioBuffer;
+
+class AudioStretcher {
+ public:
+  AudioStretcher() = delete;
+
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> changePlaybackSpeed(
+      AudioBuffer buffer,
+      float playbackSpeed);
+
+ private:
+  static std::vector<int16_t> castToInt16Buffer(AudioBuffer &buffer);
+
+  [[nodiscard]] static inline int16_t floatToInt16(float sample) {
+    return static_cast<int16_t>(sample * INT16_MAX);
+  }
+  [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
+    return static_cast<float>(sample) / INT16_MAX;
+  }
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/{Constants.h → utils/Constants.h}

@@ -10,10 +10,19 @@ namespace audioapi {
 static constexpr int RENDER_QUANTUM_SIZE = 128;
 static constexpr size_t MAX_FFT_SIZE = 32768;
 
+// stretcher
+static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;
+static constexpr float LOWER_FREQUENCY_LIMIT_DETECTION = 55.0f;
+
 // general
 static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
 static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 static constexpr float PI = static_cast<float>(M_PI);
+
+// buffer sizes
+static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
+static constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;
+static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE = 32;
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/worklets/SafeIncludes.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <string>
+#include <memory>
+
+#ifdef __APPLE__
+  /// We cannot make any conditional logic inside podspec but it should automatically compile those files
+  /// they should be accessible if someone has react-native-worklets in node_modules
+  #if __has_include(<worklets/WorkletRuntime/WorkletRuntime.h>)
+    #define RN_AUDIO_API_ENABLE_WORKLETS 1
+  #else
+    #define RN_AUDIO_API_ENABLE_WORKLETS 0
+  #endif
+#endif
+
+#ifndef RN_AUDIO_API_TEST
+  #define RN_AUDIO_API_TEST 0
+#endif
+
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  #include <worklets/WorkletRuntime/WorkletRuntime.h>
+  #include <worklets/SharedItems/Serializable.h>
+  #include <worklets/NativeModules/WorkletsModuleProxy.h>
+  #if ANDROID
+    #include <worklets/android/WorkletsModule.h>
+  #endif
+#else
+/// @brief Dummy implementation of worklets for non-worklet builds they should do nothing and mock necessary methods
+/// @note It helps to reduce compile time branching across codebase
+/// @note If you need to base some c++ implementation on if the worklets are enabled use `#if RN_AUDIO_API_ENABLE_WORKLETS`
+namespace worklets {
+
+using namespace facebook;
+class MessageQueueThread {};
+class WorkletsModuleProxy {};
+class WorkletRuntime {
+  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool);
+};
+class SerializableWorklet {
+  SerializableWorklet(jsi::Runtime*, const jsi::Object &);
+};
+} // namespace worklets
+#endif
+
+/// @brief Struct to hold references to different runtimes used in the AudioAPI
+/// @note it is used to pass them around and avoid creating multiple instances of the same runtime
+struct RuntimeRegistry {
+  std::weak_ptr<worklets::WorkletRuntime> uiRuntime;
+  std::weak_ptr<worklets::WorkletRuntime> audioRuntime;
+};

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.cpp

@@ -0,0 +1,9 @@
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
+
+namespace audioapi {
+
+WorkletsRunner::WorkletsRunner(
+    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept
+    : weakUiRuntime_(std::move(weakUiRuntime)) {}
+
+}; // namespace audioapi