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

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,

package/common/cpp/audioapi/libs/ffmpeg/relinking.md

@@ -0,0 +1,24 @@
+## If you would like to relink ffmpeg to your implementation there are two options:
+
+### Option A)
+
+you can modify script in scripts/download-prebuilt-binaries.sh
+
+- ios dynamic frameworks are in `ffmpeg_ios.zip` directory
+- android shared libraries are in `jniLibs.zip`
+
+just replace way of downloading them that links to your binaries
+
+### Option B)
+
+directly modify libraries in source code
+
+- ios dynamic frameworks are placed in `common/cpp/audioapi/external`
+- android shared libraries are placed in `android/src/main/jniLibs`
+
+---
+`USED_LIBRARIES`:
+- libavcodec
+- libavformat
+- libavutil
+- libswresample

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

@@ -0,0 +1,50 @@
+#pragma once
+#include <cstddef>
+#include <new>
+
+template<typename T, std::size_t Align = 16>
+class AlignedAllocator {
+public:
+  using value_type = T;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  AlignedAllocator() noexcept = default;
+  template<class U> AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept {}
+
+  T* allocate(std::size_t n) {
+    // We want to maximize performance on hot paths, so we hint unlikely branches
+    if (n == 0) [[ unlikely ]] {
+      return nullptr;
+    }
+    std::size_t bytes = n * sizeof(T);
+    // C++17 aligned new
+    void* p = ::operator new(bytes, std::align_val_t(Align));
+
+    // We have more serious problems if this happens than speed concerns
+    // so we can opt the branch prediction
+    if (!p) [[ unlikely ]] {
+      throw std::bad_alloc();
+    }
+    return static_cast<T*>(p);
+  }
+
+  void deallocate(T* p, std::size_t) noexcept {
+      ::operator delete(p, std::align_val_t(Align));
+  }
+
+  // Rebind allocator to type U (required by std::vector)
+  template<class U>
+  struct rebind { using other = AlignedAllocator<U, Align>; };
+
+  // Comparison operators (required by std::vector)
+  template<typename U, std::size_t UAlign>
+  bool operator==(const AlignedAllocator<U, UAlign>&) const noexcept {
+    return Align == UAlign;
+  }
+
+  template<typename U, std::size_t UAlign>
+  bool operator!=(const AlignedAllocator<U, UAlign>&) const noexcept {
+    return Align != UAlign;
+  }
+};

package/common/cpp/audioapi/utils/AudioArray.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
+#include <algorithm>
 
 namespace audioapi {
 
@@ -93,10 +94,7 @@ void AudioArray::sum(
     size_t destinationStart,
     size_t length) {
   dsp::add(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      data_ + destinationStart,
-      length);
+      data_ + destinationStart, source->getData() + sourceStart, data_ + destinationStart, length);
 }
 
 void AudioArray::copy(const AudioArray *source) {
@@ -112,10 +110,7 @@ void AudioArray::copy(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) {
-  memcpy(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      length * sizeof(float));
+  memcpy(data_ + destinationStart, source->getData() + sourceStart, length * sizeof(float));
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/AudioArray.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <algorithm>
-#include <memory>
 #include <cstddef>
 #include <cstring>
+#include <memory>
 
 namespace audioapi {
 
@@ -29,19 +29,11 @@ class AudioArray {
 
   void sum(const AudioArray *source);
   void sum(const AudioArray *source, size_t start, size_t length);
-  void sum(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void sum(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
   void copy(const AudioArray *source);
   void copy(const AudioArray *source, size_t start, size_t length);
-  void copy(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void copy(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
  protected:
   float *data_;