react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/refstruct.h

@@ -161,7 +161,7 @@ int av_refstruct_exclusive(const void *obj);
  *
  * Frequently allocating and freeing large or complicated objects may be slow
  * and wasteful. This API is meant to solve this in cases when the caller
- * needs a set of interchangable objects.
+ * needs a set of interchangeable objects.
  *
  * At the beginning, the user must call allocate the pool via
  * av_refstruct_pool_alloc() or its analogue av_refstruct_pool_alloc_ext().

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/spherical.h

@@ -82,6 +82,12 @@ enum AVSphericalProjection {
      * See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/fisheye
      */
     AV_SPHERICAL_FISHEYE,
+
+    /**
+     * Parametric Immersive projection (Apple).
+     * See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/parametricimmersive
+     */
+    AV_SPHERICAL_PARAMETRIC_IMMERSIVE,
 };
 
 /**

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/tdrdi.h

@@ -119,7 +119,7 @@ typedef struct AV3DReferenceDisplay {
     uint8_t mantissa_ref_display_width;
 
     /**
-     * Tthe exponent part of the reference viewing distance of the n-th reference display.
+     * The exponent part of the reference viewing distance of the n-th reference display.
      */
     uint8_t exponent_ref_viewing_distance;
 

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/tx.h

@@ -50,7 +50,7 @@ enum AVTXType {
 
     /**
      * Standard MDCT with a sample data type of float, double or int32_t,
-     * respecively. For the float and int32 variants, the scale type is
+     * respectively. For the float and int32 variants, the scale type is
      * 'float', while for the double variant, it's 'double'.
      * If scale is NULL, 1.0 will be used as a default.
      *

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/version.h

@@ -35,7 +35,7 @@
  * Useful to check and match library version in order to maintain
  * backward compatibility.
  *
- * The FFmpeg libraries follow a versioning sheme very similar to
+ * The FFmpeg libraries follow a versioning scheme very similar to
  * Semantic Versioning (http://semver.org/)
  * The difference is that the component called PATCH is called MICRO in FFmpeg
  * and its value is reset to 100 instead of 0 to keep it above or equal to 100.
@@ -72,14 +72,14 @@
 /**
  * @defgroup lavu_ver Version and Build diagnostics
  *
- * Macros and function useful to check at compiletime and at runtime
+ * Macros and function useful to check at compile time and at runtime
  * which version of libavutil is in use.
  *
  * @{
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  60
-#define LIBAVUTIL_VERSION_MINOR   6
+#define LIBAVUTIL_VERSION_MINOR   8
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/video_hint.h

@@ -80,7 +80,7 @@ av_video_hint_get_rect(const AVVideoHint *hints, size_t idx) {
  * The side data contains a list of rectangles for the portions of the frame
  * which changed from the last encoded one (and the remainder are assumed to be
  * changed), or, alternately (depending on the type parameter) the unchanged
- * ones (and the remanining ones are those which changed).
+ * ones (and the remaining ones are those which changed).
  * Macroblocks will thus be hinted either to be P_SKIP-ped or go through the
  * regular encoding procedure.
  *

package/common/cpp/audioapi/external/ffmpeg_include/libswresample/swresample.h

@@ -337,7 +337,7 @@ int64_t swr_next_pts(struct SwrContext *s, int64_t pts);
  * @}
  *
  * @name Low-level option setting functions
- * These functons provide a means to set low-level options that is not possible
+ * These functions provide a means to set low-level options that is not possible
  * with the AVOption API.
  * @{
  */

package/common/cpp/audioapi/external/ffmpeg_include/libswresample/version.h

@@ -30,7 +30,7 @@
 
 #include "version_major.h"
 
-#define LIBSWRESAMPLE_VERSION_MINOR   0
+#define LIBSWRESAMPLE_VERSION_MINOR   1
 #define LIBSWRESAMPLE_VERSION_MICRO 100
 
 #define LIBSWRESAMPLE_VERSION_INT  AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \

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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <audioapi/utils/AudioArray.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <utility>
@@ -12,11 +12,11 @@ using namespace facebook;
 
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
-  explicit AudioArrayBuffer(const std::shared_ptr<AudioArray> &audioArray): audioArray_(audioArray) {}
+  explicit AudioArrayBuffer(const std::shared_ptr<AudioArray> &audioArray)
+      : audioArray_(audioArray) {}
   ~AudioArrayBuffer() override = default;
 
-  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
-      : audioArray_(std::move(other.audioArray_)) {
+  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept : audioArray_(std::move(other.audioArray_)) {
     other.audioArray_ = nullptr;
   }
 
@@ -32,4 +32,3 @@ class AudioArrayBuffer : public jsi::MutableBuffer {
 };
 
 } // namespace audioapi
-

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

@@ -1,4 +1,9 @@
 #include <audioapi/jsi/JsiHostObject.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 
 //  set this value to 1 in order to debug the construction/destruction
 #define JSI_DEBUG_ALLOCATIONS 0
@@ -11,9 +16,8 @@ std::vector<JsiHostObject *> objects;
 #endif
 
 JsiHostObject::JsiHostObject() {
-  getters_ = std::make_unique<std::unordered_map<
-      std::string,
-      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  getters_ = std::make_unique<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
   functions_ = std::make_unique<std::unordered_map<
       std::string,
       jsi::Value (JsiHostObject::*)(
@@ -70,8 +74,7 @@ JsiHostObject::~JsiHostObject() {
 
 std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> propertyNames;
-  propertyNames.reserve(
-      getters_->size() + functions_->size() + setters_->size());
+  propertyNames.reserve(getters_->size() + functions_->size() + setters_->size());
 
   for (const auto &it : *getters_) {
     propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
@@ -88,9 +91,7 @@ std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
   return propertyNames;
 }
 
-jsi::Value JsiHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &name) {
+jsi::Value JsiHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
   auto nameAsString = name.utf8(runtime);
   auto &hostFunctionCache = hostFunctionCache_.get(runtime);
 
@@ -117,9 +118,7 @@ jsi::Value JsiHostObject::get(
         std::placeholders::_4);
 
     return hostFunctionCache
-        .emplace(
-            nameAsString,
-            jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher))
+        .emplace(nameAsString, jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher))
         .first->second.asFunction(runtime);
   }
 
@@ -135,8 +134,7 @@ void JsiHostObject::set(
   auto setter = setters_->find(nameAsString);
 
   if (setter != setters_->end()) {
-    auto dispatcher = std::bind(
-        setter->second, this, std::placeholders::_1, std::placeholders::_2);
+    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1, std::placeholders::_2);
 
     return dispatcher(runtime, value);
   }

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

@@ -10,30 +10,32 @@
 #include <utility>
 #include <vector>
 
-#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),                                               \
-      static_cast<jsi::Value (JsiHostObject::*)(                            \
-          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
-          &CLASS::FUNCTION))
+#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), \
+      static_cast<jsi::Value (JsiHostObject::*)( \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>(&CLASS::FUNCTION))
 
 #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_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION) \
+  std::make_pair( \
+      std::string(#FUNCTION), \
+      static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>(&CLASS::FUNCTION))
 
 #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_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),                       \
-      static_cast<void (JsiHostObject::*)(          \
-          jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+  std::make_pair( \
+      std::string(#FUNCTION), \
+      static_cast<void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
 
 namespace audioapi {
 
@@ -52,10 +54,7 @@ class JsiHostObject : public jsi::HostObject {
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &name, const jsi::Value &value) override;
 
   template <typename... Args>
   void addGetters(Args... args) {
@@ -73,23 +72,17 @@ class JsiHostObject : public jsi::HostObject {
   }
 
  protected:
-  std::unique_ptr<std::unordered_map<
-      std::string,
-      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
+  std::unique_ptr<std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
       getters_;
 
   std::unique_ptr<std::unordered_map<
       std::string,
-      jsi::Value (JsiHostObject::*)(
-          jsi::Runtime &,
-          const jsi::Value &,
-          const jsi::Value *,
-          size_t)>>
+      jsi::Value (
+          JsiHostObject::*)(jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>>
       functions_;
 
-  std::unique_ptr<std::unordered_map<
-      std::string,
-      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+  std::unique_ptr<
+      std::unordered_map<std::string, void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
       setters_;
 
  private:

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

@@ -1,68 +1,14 @@
 #include <audioapi/jsi/JsiPromise.h>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <utility>
 
 namespace audioapi {
 
 using namespace facebook;
 
-jsi::Value PromiseVendor::createPromise(
-    const std::function<void(std::shared_ptr<Promise>)> &function) {
-  if (runtime_ == nullptr) {
-    throw std::runtime_error("Runtime was null!");
-  }
-
-  auto &runtime = *runtime_;
-  auto callInvoker = callInvoker_;
-
-  // get Promise constructor
-  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-
-  // create a "run" function (first Promise arg)
-  auto runPromise = jsi::Function::createFromHostFunction(
-      runtime,
-      jsi::PropNameID::forUtf8(runtime, "runPromise"),
-      2,
-      [callInvoker, 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));
-
-        auto resolveWrapper =
-            [resolve, &runtime, callInvoker](
-                const std::function<jsi::Value(jsi::Runtime &)> &resolver)
-            -> void {
-          callInvoker->invokeAsync([resolve, &runtime, resolver]() -> void {
-            auto valueShared = std::make_shared<jsi::Value>(resolver(runtime));
-
-            resolve->call(runtime, *valueShared);
-          });
-        };
-
-        auto rejectWrapper = [reject, &runtime, callInvoker](
-                                 const std::string &errorMessage) -> void {
-          callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
-            auto error = jsi::JSError(runtime, errorMessage);
-            reject->call(runtime, error.value());
-          });
-        };
-
-        auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
-        function(promise);
-
-        return jsi::Value::undefined();
-      });
-
-  // return new Promise((resolve, reject) => ...)
-  return promiseCtor.callAsConstructor(runtime, runPromise);
-}
-
-jsi::Value PromiseVendor::createAsyncPromise(
-    std::function<PromiseResolver()> &&function) {
+jsi::Value PromiseVendor::createAsyncPromise(std::function<PromiseResolver()> &&function) {
   auto &runtime = *runtime_;
   auto callInvoker = callInvoker_;
   auto threadPool = threadPool_;
@@ -88,10 +34,33 @@ jsi::Value PromiseVendor::createAsyncPromise(
     return jsi::Value::undefined();
   };
   auto promiseFunction = jsi::Function::createFromHostFunction(
-      runtime,
-      jsi::PropNameID::forUtf8(runtime, "asyncPromise"),
-      2,
-      std::move(promiseLambda));
+      runtime, jsi::PropNameID::forUtf8(runtime, "asyncPromise"), 2, std::move(promiseLambda));
+  return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
+}
+
+jsi::Value PromiseVendor::createAsyncPromise(std::function<void(Promise &&)> &&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) mutable -> jsi::Value {
+    auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+    auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+
+    Promise promise(std::move(callInvoker), std::move(resolveLocal), std::move(rejectLocal));
+
+    threadPool->schedule(std::move(function), std::move(promise));
+
+    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));
 }
 
@@ -102,13 +71,11 @@ void PromiseVendor::asyncPromiseJob(
     std::shared_ptr<jsi::Function> &&reject) {
   auto resolver = function();
   callInvoker->invokeAsync(
-      [resolver = std::move(resolver),
-       reject = std::move(reject),
-       resolve = std::move(resolve)](jsi::Runtime &runtime) -> void {
+      [resolver = std::move(resolver), reject = std::move(reject), resolve = std::move(resolve)](
+          jsi::Runtime &runtime) -> void {
         auto result = resolver(runtime);
         if (std::holds_alternative<jsi::Value>(result)) {
-          auto valueShared = std::make_shared<jsi::Value>(
-              std::move(std::get<jsi::Value>(result)));
+          auto valueShared = std::make_shared<jsi::Value>(std::move(std::get<jsi::Value>(result)));
           resolve->call(runtime, *valueShared);
         } else {
           auto errorMessage = std::get<std::string>(result);

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

@@ -1,49 +1,82 @@
 #pragma once
 
-
-#include <audioapi/core/utils/Constants.h>
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/utils/ThreadPool.hpp>
 #include <jsi/jsi.h>
-#include <variant>
-#include <thread>
+#include <functional>
 #include <memory>
 #include <string>
+#include <thread>
 #include <utility>
-#include <functional>
-#include <audioapi/utils/ThreadPool.hpp>
+#include <variant>
 
 namespace audioapi {
 
 using namespace facebook;
 
 class Promise {
+  struct Inner {
+    std::shared_ptr<react::CallInvoker> callInvoker;
+    jsi::Function resolve;
+    jsi::Function reject;
+  };
+
  public:
-  Promise(std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve, std::function<void(const std::string &)> reject) : resolve_(std::move(resolve)), reject_(std::move(reject)) {}
+  explicit Promise(
+      std::shared_ptr<react::CallInvoker> &&callInvoker,
+      jsi::Function &&resolve,
+      jsi::Function &&reject)
+      : inner_(
+            std::make_shared<Inner>(
+                Inner{std::move(callInvoker), std::move(resolve), std::move(reject)})) {}
+
+  Promise(const Promise &other) {
+    inner_ = other.inner_;
+  }
+  Promise(Promise &&other) noexcept : inner_(std::move(other.inner_)) {}
+  Promise &operator=(Promise &&other) noexcept {
+    if (this != &other) {
+      inner_ = std::move(other.inner_);
+    }
+    return *this;
+  }
 
-  void resolve(const std::function<jsi::Value(jsi::Runtime&)> &resolver) {
-    resolve_(std::forward<const std::function<jsi::Value(jsi::Runtime&)>>(resolver));
+  void resolve(const std::function<jsi::Value(jsi::Runtime &)> &&resolver) const {
+    auto inner = inner_;
+    inner->callInvoker->invokeAsync(
+        [inner = std::move(inner),
+         resolver = std::forward<decltype(resolver)>(resolver)](jsi::Runtime &runtime) -> void {
+          auto valueShared = std::make_shared<jsi::Value>(resolver(runtime));
+          inner->resolve.call(runtime, *valueShared);
+        });
   }
 
-  void reject(const std::string &errorMessage) {
-    reject_(errorMessage);
+  void reject(const std::string &errorMessage) const {
+    auto inner = inner_;
+    inner->callInvoker->invokeAsync(
+        [inner = std::move(inner), errorMessage](jsi::Runtime &runtime) -> void {
+          auto error = jsi::JSError(runtime, errorMessage);
+          inner->reject.call(runtime, error.value());
+        });
   }
 
  private:
-  std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve_;
-  std::function<void(const std::string &)> reject_;
+  std::shared_ptr<Inner> inner_;
 };
 
-using PromiseResolver = std::function<std::variant<jsi::Value, std::string>(jsi::Runtime&)>;
+using PromiseResolver = std::function<std::variant<jsi::Value, std::string>(jsi::Runtime &)>;
 
 class PromiseVendor {
  public:
-  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);
+  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)) {}
 
   /// @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.
@@ -66,17 +99,23 @@ class PromiseVendor {
   /// return promise;
   jsi::Value createAsyncPromise(std::function<PromiseResolver()> &&function);
 
+  /// @brief Creates an asynchronous promise.
+  /// @param function The function to execute asynchronously. It receives a Promise object to resolve or reject the promise.
+  /// @return The created promise.
+  /// @note The function is executed on a different thread, the promise should be resolved or rejected using the provided Promise object.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only. (comes from underlying ThreadPool implementation)
+  jsi::Value createAsyncPromise(std::function<void(Promise &&)> &&function);
+
  private:
   jsi::Runtime *runtime_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
   std::shared_ptr<ThreadPool> threadPool_;
 
   static void asyncPromiseJob(
-    std::shared_ptr<react::CallInvoker> callInvoker,
-    std::function<PromiseResolver()> &&function,
-    std::shared_ptr<jsi::Function> &&resolve,
-    std::shared_ptr<jsi::Function> &&reject
-    );
+      std::shared_ptr<react::CallInvoker> callInvoker,
+      std::function<PromiseResolver()> &&function,
+      std::shared_ptr<jsi::Function> &&resolve,
+      std::shared_ptr<jsi::Function> &&reject);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp

@@ -1,11 +1,12 @@
 #include <audioapi/jsi/RuntimeLifecycleMonitor.h>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 
 namespace audioapi {
 
-static std::unordered_map<
-    jsi::Runtime *,
-    std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
+static std::unordered_map<jsi::Runtime *, std::unordered_set<RuntimeLifecycleListener *>> listeners;
 
 struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
   jsi::Runtime *rt_;
@@ -21,9 +22,7 @@ struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
   }
 };
 
-void RuntimeLifecycleMonitor::addListener(
-    jsi::Runtime &rt,
-    RuntimeLifecycleListener *listener) {
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // We install a global host object in the provided runtime, this way we can
@@ -43,9 +42,7 @@ void RuntimeLifecycleMonitor::addListener(
   }
 }
 
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt,
-    RuntimeLifecycleListener *listener) {
+void RuntimeLifecycleMonitor::removeListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // nothing to do here

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

@@ -27,9 +27,7 @@ struct RuntimeLifecycleListener {
  */
 struct RuntimeLifecycleMonitor {
   static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(
-      jsi::Runtime &rt,
-      RuntimeLifecycleListener *listener);
+  static void removeListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -9,7 +9,9 @@
  */
 
 #include <audioapi/core/sources/AudioBuffer.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <functional>
@@ -277,8 +279,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
 
   constexpr size_t buffer_size = 4096;
-  auto io_buffer = std::unique_ptr<uint8_t, decltype(&av_free)>(
-      static_cast<uint8_t *>(av_malloc(buffer_size)), &av_free);
+  uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
   if (io_buffer == nullptr) {
     return nullptr;
   }
@@ -286,7 +287,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   auto avio_ctx =
       std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
           avio_alloc_context(
-              io_buffer.get(),
+              io_buffer,
               buffer_size,
               0,
               &io_ctx,