react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -0,0 +1,101 @@
+
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+/// @brief Constructor
+/// Allocates circular buffer (as every property to do so is already known at this point).
+/// @param audioEventHandlerRegistry The audio event handler registry
+/// @param sampleRate The user desired sample rate
+/// @param bufferLength The user desired buffer length
+/// @param channelCount The user desired channel count
+/// @param callbackId The callback identifier
+AudioRecorderCallback::AudioRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  ringBufferSize_ = std::max(bufferLength * 2, static_cast<size_t>(8192));
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    circularBus_[i] = std::make_shared<CircularAudioArray>(ringBufferSize_);
+  }
+
+  isInitialized_.store(true, std::memory_order_release);
+}
+
+AudioRecorderCallback::~AudioRecorderCallback() {
+  isInitialized_.store(false, std::memory_order_release);
+}
+
+/// @brief Emits audio data from the circular buffer when enough frames are available.
+/// @param flush If true, emits all available data regardless of buffer length.
+void AudioRecorderCallback::emitAudioData(bool flush) {
+  size_t sizeLimit = flush ? circularBus_[0]->getNumberOfAvailableFrames() : bufferLength_;
+
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= sizeLimit) {
+    auto bus = std::make_shared<AudioBus>(sizeLimit, channelCount_, sampleRate_);
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, sizeLimit);
+    }
+
+    invokeCallback(bus, static_cast<int>(sizeLimit));
+  }
+}
+
+void AudioRecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+  }
+}
+
+void AudioRecorderCallback::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioRecorderCallback::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+/// @brief Invokes the error callback with the provided message.
+/// @param message The error message to be sent to the callback.
+void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AudioRecorderCallback {
+ public:
+  AudioRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId);
+  virtual ~AudioRecorderCallback();
+
+  virtual void cleanup() = 0;
+
+  void emitAudioData(bool flush = false);
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  std::atomic<bool> isInitialized_{false};
+
+  float sampleRate_;
+  size_t bufferLength_;
+  int channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+
+  // TODO: CircularAudioBus
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioStretcher.cpp

@@ -5,6 +5,8 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <cstdint>
+#include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -43,8 +45,8 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       outputChannels,
       0x1);
 
-  int maxOutputFrames = stretch_output_capacity(
-      stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
+  int maxOutputFrames =
+      stretch_output_capacity(stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
   std::vector<int16_t> stretchedBuffer(maxOutputFrames * outputChannels);
 
   int outputFrames = stretch_samples(
@@ -54,13 +56,11 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       stretchedBuffer.data(),
       1 / playbackSpeed);
 
-  outputFrames +=
-      stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+  outputFrames += stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
   stretchedBuffer.resize(outputFrames * outputChannels);
   stretch_deinit(stretcher);
 
-  auto audioBus =
-      std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
+  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();

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

@@ -2,6 +2,7 @@
 
 #include <cmath>
 #include <limits>
+#include <numbers>
 
 // https://webaudio.github.io/web-audio-api/
 
@@ -9,17 +10,20 @@ namespace audioapi {
 // audio
 static constexpr int RENDER_QUANTUM_SIZE = 128;
 static constexpr size_t MAX_FFT_SIZE = 32768;
+static constexpr int MAX_CHANNEL_COUNT = 32;
 
 // stretcher
 static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;
 static constexpr float LOWER_FREQUENCY_LIMIT_DETECTION = 55.0f;
 
 // general
-static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
-static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
+static constexpr float MOST_POSITIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::max());
+static constexpr float MOST_NEGATIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
-static constexpr float PI = static_cast<float>(M_PI);
+static constexpr float PI = std::numbers::pi_v<float>;
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

package/common/cpp/audioapi/core/utils/ParamChangeEvent.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/utils/ParamChangeEvent.h>
+#include <utility>
 
 namespace audioapi {
 

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

@@ -20,16 +20,16 @@ class ParamChangeEvent {
       ParamChangeEventType type);
 
   ParamChangeEvent(const ParamChangeEvent &other) = delete;
-  ParamChangeEvent& operator=(const ParamChangeEvent &other) = delete;
+  ParamChangeEvent &operator=(const ParamChangeEvent &other) = delete;
 
   explicit ParamChangeEvent(ParamChangeEvent &&other) noexcept
-    : startTime_(other.startTime_),
-      endTime_(other.endTime_),
-      calculateValue_(std::move(other.calculateValue_)),
-      startValue_(other.startValue_),
-      endValue_(other.endValue_),
-      type_(other.type_) {}
-  ParamChangeEvent& operator=(ParamChangeEvent &&other) noexcept {
+      : startTime_(other.startTime_),
+        endTime_(other.endTime_),
+        calculateValue_(std::move(other.calculateValue_)),
+        startValue_(other.startValue_),
+        endValue_(other.endValue_),
+        type_(other.type_) {}
+  ParamChangeEvent &operator=(ParamChangeEvent &&other) noexcept {
     if (this != &other) {
       startTime_ = other.startTime_;
       endTime_ = other.endTime_;
@@ -53,7 +53,7 @@ class ParamChangeEvent {
   [[nodiscard]] inline float getStartValue() const noexcept {
     return startValue_;
   }
-  [[nodiscard]] inline const std::function<float(double, double, float, float, double)>&
+  [[nodiscard]] inline const std::function<float(double, double, float, float, double)> &
   getCalculateValue() const noexcept {
     return calculateValue_;
   }

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

@@ -2,34 +2,28 @@
 
 #include <jsi/jsi.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
-#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
+#if ANDROID
+#include <fbjni/detail/Environment.h>
 #endif
 
 #ifndef RN_AUDIO_API_TEST
-  #define RN_AUDIO_API_TEST 0
+#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
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#if ANDROID
+#include <worklets/android/WorkletsModule.h>
+#endif
 #else
 
 #define RN_AUDIO_API_WORKLETS_DISABLED_ERROR \
-  std::runtime_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
@@ -42,28 +36,24 @@ class MessageQueueThread {};
 class WorkletsModuleProxy {};
 class WorkletRuntime {
  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 {
+  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 {
  public:
-  SerializableWorklet(jsi::Runtime*, const jsi::Object &) {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Value toJSValue(jsi::Runtime &rt) {
+  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
   }
 };
@@ -78,4 +68,13 @@ class SerializableWorklet {
 struct RuntimeRegistry {
   std::weak_ptr<worklets::WorkletRuntime> uiRuntime;
   std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
+
+#if ANDROID
+  ~RuntimeRegistry() {
+    facebook::jni::ThreadScope::WithClassLoader([this]() {
+      uiRuntime.reset();
+      audioRuntime.reset();
+    });
+  }
+#endif
 };

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

@@ -1,28 +1,28 @@
 #include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     bool shouldLockRuntime)
-    : weakRuntime_(std::move(weakRuntime)),
-      shouldLockRuntime(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();
-      });
+  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;
@@ -33,8 +33,8 @@ WorkletsRunner::WorkletsRunner(
 WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
     : weakRuntime_(std::move(other.weakRuntime_)),
       unsafeRuntimePtr(other.unsafeRuntimePtr),
-      shouldLockRuntime(other.shouldLockRuntime),
-      workletInitialized(other.workletInitialized) {
+      workletInitialized(other.workletInitialized),
+      shouldLockRuntime(other.shouldLockRuntime) {
   if (workletInitialized) {
     std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
     other.workletInitialized = false;
@@ -56,8 +56,7 @@ WorkletsRunner::~WorkletsRunner() {
 }
 
 std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
-    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
-    noexcept(noexcept(job)) {
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job)) {
   auto strongRuntime = weakRuntime_.lock();
   if (strongRuntime == nullptr) {
     return std::nullopt;
@@ -70,13 +69,12 @@ std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
 }
 
 std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeUnsafe(
-    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
-    noexcept(noexcept(job)) {
+    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

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <jsi/jsi.h>
 
-#include <functional>
 #include <atomic>
+#include <functional>
 #include <memory>
-#include <utility>
 #include <optional>
+#include <utility>
 
 namespace audioapi {
 using namespace facebook;
@@ -27,10 +27,10 @@ using namespace facebook;
 class WorkletsRunner {
  public:
   explicit WorkletsRunner(
-    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
-    bool shouldLockRuntime = true);
-  WorkletsRunner(WorkletsRunner&&);
+      std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+      const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      bool shouldLockRuntime = true);
+  WorkletsRunner(WorkletsRunner &&);
   ~WorkletsRunner();
 
   /// @brief Call the worklet function with the given arguments.
@@ -38,19 +38,18 @@ class WorkletsRunner {
   /// @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) {
+  template <typename... Args>
+  inline jsi::Value callUnsafe(Args &&...args) {
     return getUnsafeWorklet().call(*unsafeRuntimePtr, std::forward<Args>(args)...);
   }
 
-
   /// @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) {
+  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)...);
     });
@@ -60,14 +59,17 @@ class WorkletsRunner {
   /// @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));
+  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> weakRuntime_;
-  jsi::Runtime* unsafeRuntimePtr = nullptr;
+  jsi::Runtime *unsafeRuntimePtr = nullptr;
 
   /// @note We want to avoid automatic destruction as
   /// when runtime is destroyed, underlying pointer will be invalid
@@ -76,12 +78,14 @@ class WorkletsRunner {
   bool shouldLockRuntime = true;
 
   inline jsi::Function &getUnsafeWorklet() {
-    return *reinterpret_cast<jsi::Function*>(&unsafeWorklet);
+    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> 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));
+  std::optional<jsi::Value> executeOnRuntimeUnsafe(
+      const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job));
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -9,18 +9,12 @@ double sampleFrameToTime(int sampleFrame, float sampleRate) {
   return static_cast<double>(sampleFrame) / sampleRate;
 }
 
-float linearInterpolate(
-    const float *source,
-    size_t firstIndex,
-    size_t secondIndex,
-    float factor) {
+float linearInterpolate(const float *source, size_t firstIndex, size_t secondIndex, float factor) {
   if (firstIndex == secondIndex && firstIndex >= 1) {
-    return source[firstIndex] +
-        factor * (source[firstIndex] - source[firstIndex - 1]);
+    return source[firstIndex] + factor * (source[firstIndex] - source[firstIndex - 1]);
   }
 
-  return source[firstIndex] +
-      factor * (source[secondIndex] - source[firstIndex]);
+  return source[firstIndex] + factor * (source[secondIndex] - source[firstIndex]);
 }
 
 float linearToDecibels(float value) {
@@ -30,4 +24,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return pow(10, value / 20);
 }
-} // namespace audioapi::dsp
+} // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/AudioUtils.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <cmath>
 
 namespace audioapi::dsp {