react-native-audio-api 0.8.3 → 0.9.0-nightly-96a5bcd-20251007

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,68 @@
 #pragma once
 
+#include <audioapi/core/types/AudioFormat.h>
 #include <audioapi/libs/audio-stretch/stretch.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 +70,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/{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