react-native-audio-api 0.10.0-nightly-034f768-20251020 → 0.10.0-nightly-75aa9d0-20251022

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

@@ -5,11 +5,9 @@ namespace audioapi {
 
 WorkletSourceNode::WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime)
+    WorkletsRunner &&workletRunner)
     : AudioScheduledSourceNode(context),
-      workletRunner_(runtime),
-      shareableWorklet_(worklet) {
+      workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Prepare buffers for audio processing
@@ -42,21 +40,22 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
 
   size_t outputChannelCount = processingBus->getNumberOfChannels();
 
-  auto result = workletRunner_.executeOnRuntimeGuardedSync(
+  auto result = workletRunner_.executeOnRuntimeSync(
       [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());
+
+        // We call unsafely here because we are already on the runtime thread
+        // and the runtime is locked by executeOnRuntimeSync (if
+        // shouldLockRuntime is true)
+        return workletRunner_.callUnsafe(
+            jsiArray,
+            jsi::Value(rt, static_cast<int>(nonSilentFramesToProcess)),
+            jsi::Value(rt, this->context_->getCurrentTime()),
+            jsi::Value(rt, static_cast<int>(startOffset)));
       });
 
   // If the worklet execution failed, zero the output

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

@@ -18,8 +18,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
   explicit WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime
+    WorkletsRunner &&workletRunner
   ) : AudioScheduledSourceNode(context) {}
 
  protected:
@@ -31,15 +30,13 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
   explicit WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime
+    WorkletsRunner &&workletRunner
   );
 
  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

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <numbers>
 #include <cmath>
 #include <limits>
 
@@ -19,7 +20,7 @@ static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 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);
+static constexpr float PI = std::numbers::pi_v<float>;
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

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

@@ -27,6 +27,11 @@
     #include <worklets/android/WorkletsModule.h>
   #endif
 #else
+
+#define RN_AUDIO_API_WORKLETS_DISABLED_ERROR \
+  std::runtime_error(               \
+      "Worklets are disabled. Please install react-native-worklets or check if you have supported version to enable these features.");
+
 /// @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`
@@ -36,17 +41,41 @@ using namespace facebook;
 class MessageQueueThread {};
 class WorkletsModuleProxy {};
 class WorkletRuntime {
-  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool);
+ public:
+  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Runtime &getJSIRuntime() const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
 };
 class SerializableWorklet {
-  SerializableWorklet(jsi::Runtime*, const jsi::Object &);
+ public:
+  SerializableWorklet(jsi::Runtime*, const jsi::Object &) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
 };
 } // namespace worklets
+
+#undef RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+
 #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;
+  std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
 };

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

@@ -3,7 +3,80 @@
 namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
-    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept
-    : weakUiRuntime_(std::move(weakUiRuntime)) {}
+    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    bool shouldLockRuntime)
+    : weakRuntime_(std::move(weakRuntime)),
+      shouldLockRuntime(shouldLockRuntime) {
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    return;
+  }
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  unsafeRuntimePtr = &strongRuntime->getJSIRuntime();
+  strongRuntime->executeSync(
+      [this, shareableWorklet](jsi::Runtime &rt) -> jsi::Value {
+        /// Placement new to avoid dynamic memory allocation
+        new (reinterpret_cast<jsi::Function *>(&unsafeWorklet))
+            jsi::Function(shareableWorklet->toJSValue(*unsafeRuntimePtr)
+                              .asObject(*unsafeRuntimePtr)
+                              .asFunction(*unsafeRuntimePtr));
+        return jsi::Value::undefined();
+      });
+  workletInitialized = true;
+#else
+  unsafeRuntimePtr = nullptr;
+  workletInitialized = false;
+#endif
+}
+
+WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
+    : weakRuntime_(std::move(other.weakRuntime_)),
+      unsafeRuntimePtr(other.unsafeRuntimePtr),
+      shouldLockRuntime(other.shouldLockRuntime),
+      workletInitialized(other.workletInitialized) {
+  if (workletInitialized) {
+    std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
+    other.workletInitialized = false;
+    other.unsafeRuntimePtr = nullptr;
+  }
+}
+
+WorkletsRunner::~WorkletsRunner() {
+  if (!workletInitialized) {
+    return;
+  }
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    // We cannot safely destroy the worklet without a valid runtime
+    return;
+  }
+  reinterpret_cast<jsi::Function *>(&unsafeWorklet)->~Function();
+  workletInitialized = false;
+}
+
+std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
+    noexcept(noexcept(job)) {
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    return std::nullopt;
+  }
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  return strongRuntime->executeSync(std::move(job));
+#else
+  return std::nullopt;
+#endif
+}
+
+std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeUnsafe(
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
+    noexcept(noexcept(job)) {
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  return job(*unsafeRuntimePtr);
+#else
+  return std::nullopt;
+#endif
+};
 
 }; // namespace audioapi

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

@@ -26,48 +26,62 @@ using namespace facebook;
 
 class WorkletsRunner {
  public:
-    explicit WorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+  explicit WorkletsRunner(
+    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    bool shouldLockRuntime = true);
+  WorkletsRunner(WorkletsRunner&&);
+  ~WorkletsRunner();
 
-    /// @brief Execute a job on the UI runtime safely.
-    /// @param job
-    /// @return nullopt if the runtime is not available or the result of the job execution
-    /// @note Execution is synchronous
-    std::optional<jsi::Value> executeOnRuntimeGuardedSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
-      auto strongRuntime = weakUiRuntime_.lock();
-      if (strongRuntime == nullptr) {
-         return std::nullopt;
-      }
-      #if RN_AUDIO_API_ENABLE_WORKLETS
-      return strongRuntime->executeSync(std::move(job));
-      #else
-      return std::nullopt;
-      #endif
-    }
+  /// @brief Call the worklet function with the given arguments.
+  /// @tparam ...Args
+  /// @param ...args
+  /// @return The result of the worklet function call.
+  /// @note This method is unsafe and should be used with caution. It assumes that the runtime and worklet are valid and runtime is locked.
+  template<typename... Args>
+  inline jsi::Value callUnsafe(Args&&... args) {
+    return getUnsafeWorklet().call(*unsafeRuntimePtr, std::forward<Args>(args)...);
+  }
 
-    /// @brief Execute a worklet with the given arguments.
-    /// @tparam ...Args
-    /// @param shareableWorklet
-    /// @param ...args
-    /// @note Execution is synchronous, this method can be used in `executeOnRuntimeGuardedSync` and `...Async` methods arguments
-    /// @return nullopt if the runtime is not available or the result of the worklet execution
-    template<typename... Args>
-    std::optional<jsi::Value> executeWorklet(const std::shared_ptr<worklets::SerializableWorklet>& shareableWorklet, Args&&... args) {
-      auto strongRuntime = weakUiRuntime_.lock();
-      if (strongRuntime == nullptr) {
-         return std::nullopt;
-      }
 
-      #if RN_AUDIO_API_ENABLE_WORKLETS
+  /// @brief Call the worklet function with the given arguments.
+  /// @tparam ...Args
+  /// @param ...args
+  /// @return The result of the worklet function call.
+  /// @note This method is safe and will check if the runtime is available before calling the worklet. If the runtime is not available, it will return nullopt.
+  template<typename... Args>
+  inline std::optional<jsi::Value> call(Args&&... args) {
+    return executeOnRuntimeGuarded([this, args...](jsi::Runtime &rt) -> jsi::Value {
+      return callUnsafe(std::forward<Args>(args)...);
+    });
+  }
 
-      return strongRuntime->runGuarded(shareableWorklet, std::forward<Args>(args)...);
-
-      #else
-      return std::nullopt;
-      #endif
-    }
+  /// @brief Execute a job on the UI runtime safely.
+  /// @param job
+  /// @return nullopt if the runtime is not available or the result of the job execution
+  /// @note Execution is synchronous and will be guarded if shouldLockRuntime is true.
+  inline std::optional<jsi::Value> executeOnRuntimeSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
+    if (shouldLockRuntime) return executeOnRuntimeGuarded(std::move(job));
+    else return executeOnRuntimeUnsafe(std::move(job));
+  }
 
  private:
-    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime_;
+  std::weak_ptr<worklets::WorkletRuntime> weakRuntime_;
+  jsi::Runtime* unsafeRuntimePtr = nullptr;
+
+  /// @note We want to avoid automatic destruction as
+  /// when runtime is destroyed, underlying pointer will be invalid
+  char unsafeWorklet[sizeof(jsi::Function)];
+  bool workletInitialized = false;
+  bool shouldLockRuntime = true;
+
+  inline jsi::Function &getUnsafeWorklet() {
+    return *reinterpret_cast<jsi::Function*>(&unsafeWorklet);
+  }
+
+  std::optional<jsi::Value> executeOnRuntimeGuarded(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
+
+  std::optional<jsi::Value> executeOnRuntimeUnsafe(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -277,8 +277,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
 
   constexpr size_t buffer_size = 4096;
-  auto io_buffer = std::unique_ptr<uint8_t, decltype(&av_free)>(
-      static_cast<uint8_t *>(av_malloc(buffer_size)), &av_free);
+  uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
   if (io_buffer == nullptr) {
     return nullptr;
   }
@@ -286,7 +285,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   auto avio_ctx =
       std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
           avio_alloc_context(
-              io_buffer.get(),
+              io_buffer,
               buffer_size,
               0,
               &io_ctx,

package/common/cpp/test/CMakeLists.txt

@@ -12,6 +12,7 @@ FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/3983f67e32fb3e9294487b9d4f9586efa6e5d088.zip
 )
+
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
@@ -57,6 +58,8 @@ target_include_directories(rnaudioapi PUBLIC
   ${JSI_DIR}
   "${REACT_NATIVE_DIR}/ReactCommon"
   "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  ${gtest_SOURCE_DIR}/include
+  ${gmock_SOURCE_DIR}/include
 )
 
 target_include_directories(rnaudioapi_libs PUBLIC