react-native-audio-api 0.8.3-nightly-e918179-20251003 → 0.8.3-nightly-ea268f4-20251005

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

@@ -0,0 +1,89 @@
+#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));
+  }
+}
+
+void 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));
+    }
+  }
+}
+
+} // 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:
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override {}
+};
+#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:
+  void 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/sources/AudioBufferBaseSourceNode.cpp

@@ -28,12 +28,7 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
 }
 
 AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->unregisterHandler(
-        "positionChanged", onPositionChangedCallbackId_);
-    onPositionChangedCallbackId_ = 0;
-  }
+  clearOnPositionChangedCallback();
 }
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {

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

@@ -29,6 +29,8 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
+
+  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {
@@ -123,6 +125,21 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
+void AudioBufferSourceNode::clearOnLoopEndedCallback() {
+  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "loopEnded", onLoopEndedCallbackId_);
+  onLoopEndedCallbackId_ = 0;
+}
+
+void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
+  onLoopEndedCallbackId_ = callbackId;
+}
+
 void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -150,6 +167,15 @@ double AudioBufferSourceNode::getCurrentPosition() const {
       static_cast<int>(vReadIndex_), buffer_->getSampleRate());
 }
 
+void AudioBufferSourceNode::sendOnLoopEndedEvent() {
+  auto onLoopEndedCallbackId =
+      onLoopEndedCallbackId_.load(std::memory_order_acquire);
+  if (onLoopEndedCallbackId != 0) {
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId_, {});
+  }
+}
+
 /**
  * Helper functions
  */
@@ -217,6 +243,8 @@ void AudioBufferSourceNode::processWithoutInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 
@@ -278,6 +306,8 @@ void AudioBufferSourceNode::processWithInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 }

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

@@ -34,6 +34,9 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
+  void clearOnLoopEndedCallback();
+  void setOnLoopEndedCallbackId(uint64_t callbackId);
+
  protected:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
   double getCurrentPosition() const override;
@@ -49,6 +52,9 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   std::shared_ptr<AudioBuffer> buffer_;
   std::shared_ptr<AudioBus> alignedBus_;
 
+  std::atomic<uint64_t> onLoopEndedCallbackId_ = 0; // 0 means no callback
+  void sendOnLoopEndedEvent();
+
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,

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

@@ -17,12 +17,7 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
 }
 
 AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  if (onEndedCallbackId_ != 0 &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->unregisterHandler(
-        "ended", onEndedCallbackId_);
-    onEndedCallbackId_ = 0;
-  }
+  clearOnEndedCallback();
 }
 
 void AudioScheduledSourceNode::start(double when) {

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

@@ -0,0 +1,51 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context) {
+  offsetParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
+  return offsetParam_;
+}
+
+void ConstantSourceNode::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;
+  }
+
+  auto offsetBus = offsetParam_->processARateParam(
+      framesToProcess, context_->getCurrentTime());
+
+  auto offsetChannelData = offsetBus->getChannel(0)->getData();
+
+  for (int channel = 0; channel < processingBus->getNumberOfChannels();
+       ++channel) {
+    auto outputChannelData = processingBus->getChannel(channel)->getData();
+
+    std::copy(
+        offsetChannelData + startOffset,
+        offsetChannelData + startOffset + offsetLength,
+        outputChannelData + startOffset);
+  }
+
+  if (isStopScheduled()) {
+    handleStopScheduled();
+  }
+}
+} // namespace audioapi

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+
+#include <cmath>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class ConstantSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit ConstantSourceNode(BaseAudioContext *context);
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
+
+ protected:
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioParam> offsetParam_;
+};
+} // namespace audioapi

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

@@ -0,0 +1,82 @@
+#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));
+  }
+}
+
+void WorkletSourceNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (isUnscheduled() || isFinished() || !isEnabled()) {
+    processingBus->zero();
+    return;
+  }
+
+  size_t startOffset = 0;
+  size_t nonSilentFramesToProcess = framesToProcess;
+
+  updatePlaybackInfo(
+      processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+
+  if (nonSilentFramesToProcess == 0) {
+    processingBus->zero();
+    return;
+  }
+
+  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;
+  }
+
+  // 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();
+}
+
+} // 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:
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override {}
+};
+#else
+
+class WorkletSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit WorkletSourceNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime
+  );
+
+ protected:
+  void 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/utils/AudioParamEventQueue.cpp

@@ -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/Constants.h

@@ -16,4 +16,9 @@ static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 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

@@ -43,3 +43,10 @@ class SerializableWorklet {
 };
 } // 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/{UiWorkletsRunner.cpp → WorkletsRunner.cpp}

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

package/common/cpp/audioapi/core/utils/worklets/{UiWorkletsRunner.h → WorkletsRunner.h}

@@ -24,9 +24,9 @@ using namespace facebook;
 * This will return a shared pointer to the extracted worklet, or throw an error if the argument is invalid.
 */
 
-class UiWorkletsRunner {
+class WorkletsRunner {
  public:
-    explicit UiWorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+    explicit WorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
 
     /// @brief Execute a job on the UI runtime safely.
     /// @param job

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -53,8 +53,9 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
         "volumeChange",
     };
 
-    static constexpr std::array<std::string_view, 5> AUDIO_API_EVENT_NAMES = {
+    static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES = {
       "ended",
+      "loopEnded",
       "audioReady",
       "positionChanged",
       "audioError",

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -66,8 +66,10 @@ jsi::Value PromiseVendor::createAsyncPromise(
         &&function) {
   auto &runtime = *runtime_;
   auto callInvoker = callInvoker_;
+  auto threadPool = threadPool_;
   auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-  auto promiseLambda = [callInvoker = std::move(callInvoker),
+  auto promiseLambda = [threadPool = std::move(threadPool),
+                        callInvoker = std::move(callInvoker),
                         function = std::move(function)](
                            jsi::Runtime &runtime,
                            const jsi::Value &thisValue,
@@ -78,32 +80,26 @@ jsi::Value PromiseVendor::createAsyncPromise(
     auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
     auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
 
-    /// Here we can swap later for thread pool instead of creating a new thread
-    /// each time
-    std::thread(
-        [callInvoker = std::move(callInvoker),
-         function = std::move(function),
-         resolve = std::move(resolve),
-         reject = std::move(reject)](jsi::Runtime &runtime) {
-          auto result = function(runtime);
-          if (std::holds_alternative<jsi::Value>(result)) {
-            auto valueShared = std::make_shared<jsi::Value>(
-                std::move(std::get<jsi::Value>(result)));
-            callInvoker->invokeAsync(
-                [resolve, &runtime, valueShared]() -> void {
-                  resolve->call(runtime, *valueShared);
-                });
-          } else {
-            auto errorMessage = std::get<std::string>(result);
-            callInvoker->invokeAsync(
-                [reject, &runtime, errorMessage]() -> void {
-                  auto error = jsi::JSError(runtime, errorMessage);
-                  reject->call(runtime, error.value());
-                });
-          }
-        },
-        std::ref(runtime))
-        .detach();
+    threadPool->schedule([callInvoker = std::move(callInvoker),
+                          function = std::move(function),
+                          resolve = std::move(resolve),
+                          reject = std::move(reject),
+                          &runtime]() {
+      auto result = function(runtime);
+      if (std::holds_alternative<jsi::Value>(result)) {
+        auto valueShared = std::make_shared<jsi::Value>(
+            std::move(std::get<jsi::Value>(result)));
+        callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+          resolve->call(runtime, *valueShared);
+        });
+      } else {
+        auto errorMessage = std::get<std::string>(result);
+        callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
+          auto error = jsi::JSError(runtime, errorMessage);
+          reject->call(runtime, error.value());
+        });
+      }
+    });
     return jsi::Value::undefined();
   };
   auto promiseFunction = jsi::Function::createFromHostFunction(

package/common/cpp/audioapi/jsi/JsiPromise.h

@@ -1,5 +1,7 @@
 #pragma once
 
+
+#include <audioapi/core/utils/Constants.h>
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <variant>
@@ -8,6 +10,7 @@
 #include <string>
 #include <utility>
 #include <functional>
+#include <audioapi/utils/ThreadPool.hpp>
 
 namespace audioapi {
 
@@ -32,7 +35,11 @@ class Promise {
 
 class PromiseVendor {
  public:
-  PromiseVendor(jsi::Runtime *runtime, const std::shared_ptr<react::CallInvoker> &callInvoker): runtime_(runtime), callInvoker_(callInvoker) {}
+  PromiseVendor(jsi::Runtime *runtime, const std::shared_ptr<react::CallInvoker> &callInvoker):
+    runtime_(runtime), callInvoker_(callInvoker), threadPool_(std::make_shared<ThreadPool>(
+      audioapi::PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT,
+      audioapi::PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE,
+      audioapi::PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE)) {}
 
   jsi::Value createPromise(const std::function<void(std::shared_ptr<Promise>)> &function);
 
@@ -40,6 +47,7 @@ class PromiseVendor {
   /// @param function The function to execute asynchronously. It should return either a jsi::Value on success or a std::string error message on failure.
   /// @return The created promise.
   /// @note The function is executed on a different thread, and the promise is resolved or rejected based on the function's outcome.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only. (comes from underlying ThreadPool implementation)
   /// @example
   /// ```cpp
   /// auto promise = promiseVendor_->createAsyncPromise(
@@ -56,6 +64,7 @@ class PromiseVendor {
  private:
   jsi::Runtime *runtime_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
+  std::shared_ptr<ThreadPool> threadPool_;
 };
 
 } // namespace audioapi