react-native-audio-api 0.9.0 → 0.9.2

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

@@ -5,9 +5,8 @@ namespace audioapi {
 
 WorkletProcessingNode::WorkletProcessingNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime)
-    : AudioNode(context), workletRunner_(runtime), shareableWorklet_(worklet) {
+    WorkletsRunner &&workletRunner)
+    : AudioNode(context), workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Pre-allocate buffers for max 128 frames and 2 channels (stereo)
@@ -16,13 +15,12 @@ WorkletProcessingNode::WorkletProcessingNode(
   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 inputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(inputAudioArray);
 
-    auto outputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        outputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] =
+        std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
 }
 
@@ -43,8 +41,8 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
   }
 
   // Execute the worklet
-  auto result = workletRunner_.executeOnRuntimeGuardedSync(
-      [this, channelCount, framesToProcess](jsi::Runtime &rt) {
+  auto result = workletRunner_.executeOnRuntimeSync(
+      [this, channelCount, framesToProcess](jsi::Runtime &rt) -> jsi::Value {
         auto inputJsArray = jsi::Array(rt, channelCount);
         auto outputJsArray = jsi::Array(rt, channelCount);
 
@@ -59,14 +57,14 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
           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());
+        // 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(
+            inputJsArray,
+            outputJsArray,
+            jsi::Value(rt, static_cast<int>(framesToProcess)),
+            jsi::Value(rt, this->context_->getCurrentTime()));
       });
 
   // Copy processed output data back to the processing bus or zero on failure

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

@@ -18,8 +18,7 @@ class WorkletProcessingNode : public AudioNode {
  public:
   explicit WorkletProcessingNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime
+      WorkletsRunner &&workletRunner
   ) : AudioNode(context) {}
 
  protected:
@@ -33,8 +32,7 @@ class WorkletProcessingNode : public AudioNode {
  public:
   explicit WorkletProcessingNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime
+      WorkletsRunner &&workletRunner
   );
 
  protected:
@@ -42,7 +40,6 @@ class WorkletProcessingNode : public AudioNode {
 
  private:
   WorkletsRunner workletRunner_;
-  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> inputBuffsHandles_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;
 };

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

@@ -37,6 +37,7 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  private:
   friend class AudioBufferSourceNode;
   friend class AudioBufferQueueSourceNode;
+  friend class AudioBufferHostObject;
 
   std::shared_ptr<AudioBus> bus_;
 };

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

@@ -27,10 +27,6 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
       std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
-AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  clearOnPositionChangedCallback();
-}
-
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }

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

@@ -15,7 +15,6 @@ class AudioParam;
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferBaseSourceNode() override;
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;

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

@@ -29,8 +29,6 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
-
-  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {

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

@@ -16,10 +16,6 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
   numberOfInputs_ = 0;
 }
 
-AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  clearOnEndedCallback();
-}
-
 void AudioScheduledSourceNode::start(double when) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;

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

@@ -27,7 +27,6 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

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

@@ -44,10 +44,14 @@ bool StreamerNode::initialize(const std::string &input_url) {
   }
 
   if (!openInput(input_url)) {
+    if (VERBOSE)
+      printf("Failed to open input\n");
     return false;
   }
 
   if (!findAudioStream() || !setupDecoder() || !setupResampler()) {
+    if (VERBOSE)
+      printf("Failed to find/setup audio stream\n");
     cleanup();
     return false;
   }
@@ -56,6 +60,8 @@ bool StreamerNode::initialize(const std::string &input_url) {
   frame_ = av_frame_alloc();
 
   if (pkt_ == nullptr || frame_ == nullptr) {
+    if (VERBOSE)
+      printf("Failed to allocate packet or frame\n");
     cleanup();
     return false;
   }
@@ -119,29 +125,24 @@ void StreamerNode::streamAudio() {
   while (streamFlag.load()) {
     if (pendingFrame_ != nullptr) {
       if (!processFrameWithResampler(pendingFrame_)) {
-        cleanup();
         return;
       }
     } else {
       if (av_read_frame(fmtCtx_, pkt_) < 0) {
-        cleanup();
         return;
       }
       if (pkt_->stream_index == audio_stream_index_) {
         if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
-          cleanup();
           return;
         }
         if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
-          cleanup();
           return;
         }
         if (!processFrameWithResampler(frame_)) {
-          cleanup();
           return;
         }
-        av_packet_unref(pkt_);
       }
+      av_packet_unref(pkt_);
     }
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
@@ -174,6 +175,13 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
           (maxBufferSize_ - offsetLength) * sizeof(float));
     }
     bufferedBusIndex_ -= offsetLength;
+  } else {
+    if (VERBOSE)
+      printf(
+          "Buffer underrun: have %zu, need %zu\n",
+          bufferedBusIndex_,
+          (size_t)framesToProcess);
+    processingBus->zero();
   }
 
   return processingBus;
@@ -273,6 +281,8 @@ bool StreamerNode::setupDecoder() {
 
 void StreamerNode::cleanup() {
   streamFlag.store(false);
+  // cleanup cannot be called from the streaming thread so there is no need to
+  // check if we are in the same thread
   streamingThread_.join();
   if (swrCtx_ != nullptr) {
     swr_free(&swrCtx_);

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

@@ -28,6 +28,8 @@ extern "C" {
 #include <string>
 #include <atomic>
 
+static bool constexpr VERBOSE = false;
+
 namespace audioapi {
 
 class AudioBus;
@@ -94,7 +96,7 @@ class StreamerNode : public AudioScheduledSourceNode {
 
   /**
    * @brief Open the input stream
-   * @param input_url The URL of the input stream
+   * @param inputUrl The URL of the input stream
    * @return true if successful, false otherwise
    * @note This function initializes the FFmpeg libraries and opens the input stream
    */

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

@@ -5,20 +5,17 @@ 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
   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));
+    auto audioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(audioArray);
   }
 }
 
@@ -43,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/worklets/SafeIncludes.h

@@ -5,16 +5,6 @@
 #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
@@ -27,6 +17,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 +31,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/events/AudioEventHandlerRegistry.cpp

@@ -156,8 +156,12 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
 
     // In case of debugging this, please increment the hours spent counter
 
-    // Hours spent on this: 5
+    // Hours spent on this: 8
     try {
+      if (!handlerIt->second || !handlerIt->second->isFunction(*runtime_)) {
+        // If the handler is not valid, we can skip it
+        return;
+      }
       jsi::Object eventObject(*runtime_);
       // handle special logic for microphone, because we pass audio buffer which
       // has significant size

package/common/cpp/audioapi/external/libavformat.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libavformat.framework/libavformat</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libavformat.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libavformat.framework/libavformat</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libavformat.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>