react-native-audio-api 0.8.3 → 0.9.0

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

@@ -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

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

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+
+#include <functional>
+#include <atomic>
+#include <memory>
+#include <utility>
+#include <optional>
+
+namespace audioapi {
+using namespace facebook;
+
+/*
+* # How to extract worklet from JavaScript argument
+*
+* To extract a shareable worklet from a JavaScript argument, use the following code:
+*
+* ```cpp
+* auto worklet = worklets::extractSerializableWorkletFromArg(runtime, args[0]);
+* ```
+*
+* This will return a shared pointer to the extracted worklet, or throw an error if the argument is invalid.
+*/
+
+class WorkletsRunner {
+ public:
+    explicit WorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+
+    /// @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 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
+
+      return strongRuntime->runGuarded(shareableWorklet, std::forward<Args>(args)...);
+
+      #else
+      return std::nullopt;
+      #endif
+    }
+
+ private:
+    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
 
 namespace audioapi::dsp {

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

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 
 namespace audioapi {

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/AudioArrayBuffer.h

@@ -9,7 +9,20 @@ using namespace facebook;
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
   AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
-  ~AudioArrayBuffer() override = default;
+  ~AudioArrayBuffer() override {
+    if (data_ == nullptr) {
+      return;
+    }
+    delete[] data_;
+  }
+  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
+      : data_(other.data_), size_(other.size_) {
+    other.data_ = nullptr;
+  }
+
+  AudioArrayBuffer(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(AudioArrayBuffer &&other) = delete;
 
   [[nodiscard]] size_t size() const override;
   uint8_t *data() override;

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

@@ -10,13 +10,8 @@
 #include <utility>
 #include <vector>
 
-#define JSI_HOST_FUNCTION(NAME)    \
-  jsi::Value NAME(                 \
-      jsi::Runtime &runtime,       \
-      const jsi::Value &thisValue, \
-      const jsi::Value *args,      \
-      size_t count)
-
+#define JSI_HOST_FUNCTION_DECL(name) jsi::Value name(jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
+#define JSI_HOST_FUNCTION_IMPL(CLASS, name) jsi::Value CLASS::name(jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
 #define JSI_EXPORT_FUNCTION(CLASS, FUNCTION)                                \
   std::make_pair(                                                           \
       std::string(#FUNCTION),                                               \
@@ -24,17 +19,16 @@
           jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
           &CLASS::FUNCTION))
 
-#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
-
+#define JSI_PROPERTY_GETTER_DECL(name) jsi::Value name(jsi::Runtime &runtime)
+#define JSI_PROPERTY_GETTER_IMPL(CLASS, name) jsi::Value CLASS::name(jsi::Runtime &runtime)
 #define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)               \
   std::make_pair(                                                 \
       std::string(#FUNCTION),                                     \
       static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>( \
           &CLASS::FUNCTION))
 
-#define JSI_PROPERTY_SETTER(name) \
-  void name(jsi::Runtime &runtime, const jsi::Value &value)
-
+#define JSI_PROPERTY_SETTER_DECL(name) void name(jsi::Runtime &runtime, const jsi::Value &value)
+#define JSI_PROPERTY_SETTER_IMPL(CLASS, name) void CLASS::name(jsi::Runtime &runtime, const jsi::Value &value)
 #define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION) \
   std::make_pair(                                   \
       std::string(#FUNCTION),                       \

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

@@ -61,4 +61,53 @@ jsi::Value PromiseVendor::createPromise(
   return promiseCtor.callAsConstructor(runtime, runPromise);
 }
 
+jsi::Value PromiseVendor::createAsyncPromise(
+    std::function<std::variant<jsi::Value, std::string>(jsi::Runtime &)>
+        &&function) {
+  auto &runtime = *runtime_;
+  auto callInvoker = callInvoker_;
+  auto threadPool = threadPool_;
+  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+  auto promiseLambda = [threadPool = std::move(threadPool),
+                        callInvoker = std::move(callInvoker),
+                        function = std::move(function)](
+                           jsi::Runtime &runtime,
+                           const jsi::Value &thisValue,
+                           const jsi::Value *arguments,
+                           size_t count) -> jsi::Value {
+    auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+    auto resolve = std::make_shared<jsi::Function>(std::move(resolveLocal));
+    auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+    auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
+
+    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(
+      runtime,
+      jsi::PropNameID::forUtf8(runtime, "asyncPromise"),
+      2,
+      std::move(promiseLambda));
+  return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
+}
+
 } // namespace audioapi

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

@@ -1,11 +1,16 @@
 #pragma once
 
+
+#include <audioapi/core/utils/Constants.h>
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
+#include <variant>
+#include <thread>
 #include <memory>
 #include <string>
 #include <utility>
 #include <functional>
+#include <audioapi/utils/ThreadPool.hpp>
 
 namespace audioapi {
 
@@ -30,13 +35,36 @@ 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);
 
+  /// @brief Creates an asynchronous promise.
+  /// @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(
+  ///     [](jsi::Runtime& rt) -> std::variant<jsi::Value, std::string> {
+  ///    // Simulate some heavy work
+  ///    std::this_thread::sleep_for(std::chrono::seconds(2));
+  ///    return jsi::String::createFromUtf8(rt, "Promise resolved successfully!");
+  ///  }
+  /// );
+  ///
+  /// return promise;
+  jsi::Value createAsyncPromise(std::function<std::variant<jsi::Value, std::string>(jsi::Runtime&)> &&function);
+
  private:
   jsi::Runtime *runtime_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
+  std::shared_ptr<ThreadPool> threadPool_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>

package/common/cpp/audioapi/utils/ThreadPool.hpp

@@ -0,0 +1,104 @@
+#pragma once
+#include <thread>
+#include <vector>
+#include <functional>
+#include <variant>
+#include <audioapi/utils/SpscChannel.hpp>
+
+namespace audioapi {
+
+/// @brief A simple thread pool implementation using lock-free SPSC channels for task scheduling and execution.
+/// @note The thread pool consists of a load balancer thread and multiple worker threads.
+/// @note The load balancer receives tasks and distributes them to worker threads in a round-robin fashion.
+/// @note Each worker thread has its own SPSC channel to receive tasks from the load balancer.
+/// @note The thread pool can be shut down gracefully by sending a stop event to the load balancer, which then propagates the stop event to all worker threads.
+/// @note IMPORTANT: ThreadPool is not thread-safe and events should be scheduled from a single thread only.
+class ThreadPool {
+  struct StopEvent {};
+  struct TaskEvent { std::function<void()> task; };
+  using Event = std::variant<TaskEvent, StopEvent>;
+
+  using Sender = channels::spsc::Sender<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+  using Receiver = channels::spsc::Receiver<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+public:
+  /// @brief Construct a new ThreadPool
+  /// @param numThreads The number of worker threads to create
+  /// @param loadBalancerQueueSize The size of the load balancer's queue
+  /// @param workerQueueSize The size of each worker thread's queue
+  ThreadPool(size_t numThreads, size_t loadBalancerQueueSize = 32, size_t workerQueueSize = 32) {
+    auto [sender, receiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(loadBalancerQueueSize);
+    loadBalancerSender = std::move(sender);
+    std::vector<Sender> workerSenders;
+    workerSenders.reserve(numThreads);
+    for (size_t i = 0; i < numThreads; ++i) {
+      auto [workerSender, workerReceiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(workerQueueSize);
+      workers.emplace_back(&ThreadPool::workerThreadFunc, this, std::move(workerReceiver));
+      workerSenders.emplace_back(std::move(workerSender));
+    }
+    loadBalancerThread = std::thread(&ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+  }
+  ~ThreadPool() {
+    loadBalancerSender.send(StopEvent{});
+    loadBalancerThread.join();
+    for (auto& worker : workers) {
+      worker.join();
+    }
+  }
+
+  /// @brief Schedule a task to be executed by the thread pool
+  /// @param task The task to be executed
+  /// @note This function is lock-free and most of the time wait-free, but may block if the load balancer queue is full.
+  /// @note Please remember that the task will be executed in a different thread, so make sure to capture any required variables by value.
+  /// @note The task should not throw exceptions, as they will not be caught.
+  /// @note The task should end at some point, otherwise the thread pool will never be able to shut down.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only.
+  void schedule(std::function<void()> &&task) noexcept {
+    loadBalancerSender.send(TaskEvent{std::move(task)});
+  }
+
+private:
+  std::thread loadBalancerThread;
+  std::vector<std::thread> workers;
+  Sender loadBalancerSender;
+
+  void workerThreadFunc(Receiver &&receiver) {
+    Receiver localReceiver = std::move(receiver);
+    while (true) {
+      auto event = localReceiver.receive();
+      /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
+      /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
+      /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
+      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+        break;
+      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+        std::get<TaskEvent>(event).task();
+      }
+    }
+  }
+
+  void loadBalancerThreadFunc(Receiver &&receiver, std::vector<Sender> &&workerSenders) {
+    Receiver localReceiver = std::move(receiver);
+    std::vector<Sender> localWorkerSenders = std::move(workerSenders);
+    size_t nextWorker = 0;
+    while (true) {
+      auto event = localReceiver.receive();
+      /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
+      /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
+      /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
+      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+        // Propagate stop event to all workers
+        for (size_t i = 0; i < localWorkerSenders.size(); ++i) {
+          localWorkerSenders[i].send(StopEvent{});
+        }
+        break;
+      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+        // Dispatch task to the next worker in round-robin fashion
+        auto& taskEvent = std::get<TaskEvent>(event);
+        localWorkerSenders[nextWorker].send(std::move(taskEvent));
+        nextWorker = (nextWorker + 1) % localWorkerSenders.size();
+      }
+    }
+  }
+};
+
+}; // namespace audioapi