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

package/common/cpp/audioapi/utils/AudioFileProperties.cpp

@@ -0,0 +1,92 @@
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <jsi/jsi.h>
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+AudioFileProperties::AudioFileProperties(
+    FileDirectory directory,
+    const std::string &subDirectory,
+    const std::string &fileNamePrefix,
+    int channelCount,
+    size_t batchDurationSeconds,
+    Format format,
+    float sampleRate,
+    size_t bitRate,
+    BitDepth bitDepth,
+    int flacCompressionLevel,
+    int androidFlushIntervalMs,
+    IOSAudioQuality iosAudioQuality)
+    : directory(directory),
+      subDirectory(subDirectory),
+      fileNamePrefix(fileNamePrefix),
+      channelCount(channelCount),
+      batchDurationSeconds(batchDurationSeconds),
+      format(format),
+      sampleRate(sampleRate),
+      bitRate(bitRate),
+      bitDepth(bitDepth),
+      flacCompressionLevel(flacCompressionLevel),
+      androidFlushIntervalMs(androidFlushIntervalMs),
+      iosAudioQuality(iosAudioQuality) {}
+
+std::shared_ptr<AudioFileProperties> AudioFileProperties::CreateFromJSIValue(
+    facebook::jsi::Runtime &runtime,
+    const facebook::jsi::Value &value) {
+  auto options = value.getObject(runtime);
+
+  FileDirectory directory =
+      static_cast<FileDirectory>(options.getProperty(runtime, "directory").getNumber());
+
+  std::string subDirectory =
+      options.getProperty(runtime, "subDirectory").asString(runtime).utf8(runtime);
+
+  std::string fileNamePrefix =
+      options.getProperty(runtime, "fileNamePrefix").asString(runtime).utf8(runtime);
+
+  int channelCount = static_cast<int>(options.getProperty(runtime, "channelCount").getNumber());
+
+  size_t batchDurationSeconds =
+      static_cast<size_t>(options.getProperty(runtime, "batchDurationSeconds").getNumber());
+
+  Format format = static_cast<Format>(options.getProperty(runtime, "format").getNumber());
+
+  int androidFlushIntervalMs =
+      static_cast<int>(options.getProperty(runtime, "androidFlushIntervalMs").getNumber());
+
+  auto presetOptions = options.getProperty(runtime, "preset").getObject(runtime);
+
+  float sampleRate =
+      static_cast<float>(presetOptions.getProperty(runtime, "sampleRate").getNumber());
+
+  size_t bitRate = static_cast<size_t>(presetOptions.getProperty(runtime, "bitRate").getNumber());
+
+  BitDepth bitDepth =
+      static_cast<BitDepth>(presetOptions.getProperty(runtime, "bitDepth").getNumber());
+
+  int flacCompressionLevel =
+      static_cast<int>(presetOptions.getProperty(runtime, "flacCompressionLevel").getNumber());
+
+  IOSAudioQuality iosAudioQuality =
+      static_cast<IOSAudioQuality>(presetOptions.getProperty(runtime, "iosQuality").getNumber());
+
+  return std::make_shared<AudioFileProperties>(
+      directory,
+      subDirectory,
+      fileNamePrefix,
+      channelCount,
+      batchDurationSeconds,
+      format,
+      sampleRate,
+      bitRate,
+      bitDepth,
+      flacCompressionLevel,
+      androidFlushIntervalMs,
+      iosAudioQuality);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+namespace facebook {
+namespace jsi {
+class Runtime;
+class Value;
+} // namespace jsi
+} // namespace facebook
+
+namespace audioapi {
+
+class AudioFileProperties {
+ public:
+  enum class FileDirectory {
+    Document = 0,
+    Cache = 1,
+  };
+
+  enum class Format {
+    WAV = 0,
+    CAF = 1,
+    M4A = 2,
+    FLAC = 3,
+  };
+
+  enum class IOSAudioQuality {
+    Min = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3,
+    Max = 4,
+  };
+
+  enum class BitDepth {
+    Bit16 = 0,
+    Bit24 = 1,
+    Bit32 = 2,
+  };
+
+  AudioFileProperties(
+      FileDirectory directory,
+      const std::string &subDirectory,
+      const std::string &fileNamePrefix,
+      int channelCount,
+      size_t batchDurationSeconds,
+      Format format,
+      float sampleRate,
+      size_t bitRate,
+      BitDepth bitDepth,
+      int flacCompressionLevel,
+      int androidFlushIntervalMs,
+      IOSAudioQuality iosAudioQuality);
+
+  static std::shared_ptr<AudioFileProperties> CreateFromJSIValue(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value &value);
+
+  FileDirectory directory;
+  std::string subDirectory;
+  std::string fileNamePrefix;
+  int channelCount;
+  size_t batchDurationSeconds;
+  Format format;
+  float sampleRate;
+  size_t bitRate;
+  BitDepth bitDepth;
+  int flacCompressionLevel;
+  int androidFlushIntervalMs;
+  IOSAudioQuality iosAudioQuality;
+};
+
+} // namespace audioapi

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

@@ -1,8 +1,11 @@
 #pragma once
 
-/// Benchmarking utilities
+// Benchmarking utilities
 #include <chrono>
+#include <cstdio>
+#include <string>
 #include <unordered_map>
+#include <utility>
 
 #ifdef ANDROID
 #include <android/log.h>
@@ -10,49 +13,49 @@
 
 namespace audioapi::benchmarks {
 
-    /// @brief Gets the execution time of a function
-    /// @tparam Func The type of the function to benchmark
-    /// @param func The function to benchmark
-    /// @return The duration of the function execution in nanoseconds
-    /// @note This function is safe to use across threads
-    template <typename Func>
-    double getExecutionTime(Func&& func) {
-        auto start = std::chrono::high_resolution_clock::now();
-        std::forward<Func>(func)();
-        auto end = std::chrono::high_resolution_clock::now();
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
-    }
-
-    /// @brief Logs the average execution time of a function
-    /// @tparam Func The type of the function to benchmark
-    /// @param msg The message to log
-    /// @param func The function to benchmark
-    /// @return The duration of the function execution in nanoseconds
-    /// @note This function should not be used in production
-    /// @note This function is not thread-safe and should be used preferably once in a codebase when you need to measure performance
-    template <typename Func>
-    double logAvgExecutionTime(const std::string& msg, Func&& func) {
-        double duration = getExecutionTime(std::forward<Func>(func));
-
-        static std::unordered_map<std::string, double> durationsSum;
-        static std::unordered_map<std::string, int> durationsCount;
-
-        // Ensure initialization for first time
-        if (durationsSum.find(msg) == durationsSum.end()) {
-            durationsSum[msg] = 0.0;
-            durationsCount[msg] = 0;
-        }
-
-        durationsSum[msg] += duration;
-        durationsCount[msg]++;
-
-        long long avgDuration = static_cast<long long>(durationsSum[msg] / durationsCount[msg]);
-
-        #ifdef ANDROID
-            __android_log_print(ANDROID_LOG_INFO, "AudioAPI", "%s: %lld ns", msg.c_str(), avgDuration);
-        #else
-            printf("%s: %lld ns\n", msg.c_str(), avgDuration);
-        #endif
-        return duration;
-    }
-}
+/// @brief Gets the execution time of a function
+/// @tparam Func The type of the function to benchmark
+/// @param func The function to benchmark
+/// @return The duration of the function execution in nanoseconds
+/// @note This function is safe to use across threads
+template <typename Func>
+double getExecutionTime(Func &&func) {
+  auto start = std::chrono::high_resolution_clock::now();
+  std::forward<Func>(func)();
+  auto end = std::chrono::high_resolution_clock::now();
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
+}
+
+/// @brief Logs the average execution time of a function
+/// @tparam Func The type of the function to benchmark
+/// @param msg The message to log
+/// @param func The function to benchmark
+/// @return The duration of the function execution in nanoseconds
+/// @note This function should not be used in production
+/// @note This function is not thread-safe and should be used preferably once in a codebase when you need to measure performance
+template <typename Func>
+double logAvgExecutionTime(const std::string &msg, Func &&func) {
+  double duration = getExecutionTime(std::forward<Func>(func));
+
+  static std::unordered_map<std::string, double> durationsSum;
+  static std::unordered_map<std::string, int> durationsCount;
+
+  // Ensure initialization for first time
+  if (durationsSum.find(msg) == durationsSum.end()) {
+    durationsSum[msg] = 0.0;
+    durationsCount[msg] = 0;
+  }
+
+  durationsSum[msg] += duration;
+  durationsCount[msg]++;
+
+  int64_t avgDuration = static_cast<int64_t>(durationsSum[msg] / durationsCount[msg]);
+
+#ifdef ANDROID
+  __android_log_print(ANDROID_LOG_INFO, "AudioAPI", "%s: %lld ns", msg.c_str(), avgDuration);
+#else
+  printf("%s: %lld ns\n", msg.c_str(), avgDuration);
+#endif
+  return duration;
+}
+} // namespace audioapi::benchmarks

package/common/cpp/audioapi/utils/CircularAudioArray.cpp

@@ -4,10 +4,7 @@ namespace audioapi {
 
 CircularAudioArray::CircularAudioArray(size_t size) : AudioArray(size) {}
 
-void CircularAudioArray::push_back(
-    const float *data,
-    size_t size,
-    bool skipAvailableSpaceCheck) {
+void CircularAudioArray::push_back(const float *data, size_t size, bool skipAvailableSpaceCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -24,14 +21,10 @@ void CircularAudioArray::push_back(
     memcpy(data_ + vWriteIndex_, data, size * sizeof(float));
   }
 
-  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_
-                                             : vWriteIndex_ + size;
+  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_ : vWriteIndex_ + size;
 }
 
-void CircularAudioArray::pop_front(
-    float *data,
-    size_t size,
-    bool skipAvailableDataCheck) {
+void CircularAudioArray::pop_front(float *data, size_t size, bool skipAvailableDataCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -48,8 +41,7 @@ void CircularAudioArray::pop_front(
     memcpy(data, data_ + vReadIndex_, size * sizeof(float));
   }
 
-  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_
-                                           : vReadIndex_ + size;
+  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_ : vReadIndex_ + size;
 }
 
 void CircularAudioArray::pop_back(
@@ -66,10 +58,7 @@ void CircularAudioArray::pop_back(
   }
 
   if (vWriteIndex_ <= offset) {
-    memcpy(
-        data,
-        data_ + size_ - (offset - vWriteIndex_) - size,
-        size * sizeof(float));
+    memcpy(data, data_ + size_ - (offset - vWriteIndex_) - size, size * sizeof(float));
   } else if (vWriteIndex_ <= size + offset) {
     auto partSize = size + offset - vWriteIndex_;
     memcpy(data, data_ + size_ - partSize, partSize * sizeof(float));
@@ -78,8 +67,7 @@ void CircularAudioArray::pop_back(
     memcpy(data, data_ + vWriteIndex_ - size - offset, size * sizeof(float));
   }
 
-  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset
-                                          : vWriteIndex_ - offset;
+  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset : vWriteIndex_ - offset;
 }
 
 size_t CircularAudioArray::getNumberOfAvailableFrames() const {

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.cpp

@@ -1,16 +1,14 @@
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <algorithm>
 #include <type_traits>
 
 namespace audioapi {
 
-CircularOverflowableAudioArray::CircularOverflowableAudioArray(
-    size_t
-        size) noexcept(std::is_nothrow_constructible<AudioArray, size_t>::value)
+CircularOverflowableAudioArray::CircularOverflowableAudioArray(size_t size) noexcept(
+    std::is_nothrow_constructible<AudioArray, size_t>::value)
     : AudioArray(size) {}
 
-void CircularOverflowableAudioArray::write(
-    const float *data,
-    const size_t size) {
+void CircularOverflowableAudioArray::write(const float *data, const size_t size) {
   size_t writeIndex = vWriteIndex_.load(std::memory_order_relaxed);
 
   if (size > size_) {
@@ -43,8 +41,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
   size_t partSize = size_ - vReadIndex_;
   if (readSize > partSize) {
     std::memcpy(output, data_ + vReadIndex_, partSize * sizeof(float));
-    std::memcpy(
-        output + partSize, data_, (readSize - partSize) * sizeof(float));
+    std::memcpy(output + partSize, data_, (readSize - partSize) * sizeof(float));
   } else {
     std::memcpy(output, data_ + vReadIndex_, readSize * sizeof(float));
   }
@@ -54,8 +51,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
 }
 
 size_t CircularOverflowableAudioArray::getAvailableSpace() const {
-  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) %
-      size_;
+  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) % size_;
 }
 
 } // namespace audioapi

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

@@ -2,9 +2,9 @@
 #pragma once
 
 #include <audioapi/utils/AudioArray.h>
-#include <stdexcept>
 #include <atomic>
 #include <mutex>
+#include <stdexcept>
 
 namespace audioapi {
 
@@ -32,7 +32,7 @@ class CircularOverflowableAudioArray : public AudioArray {
   size_t read(float *output, size_t size) const;
 
  private:
-  std::atomic<size_t> vWriteIndex_ = { 0 };
+  std::atomic<size_t> vWriteIndex_ = {0};
   mutable size_t vReadIndex_ = 0; // it is only used after acquiring readLock_
   mutable std::mutex readLock_;
 

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

@@ -2,8 +2,9 @@
 
 #include <audioapi/utils/SpscChannel.hpp>
 
-#include <type_traits>
 #include <functional>
+#include <type_traits>
+#include <utility>
 
 namespace audioapi {
 using namespace channels::spsc;
@@ -27,32 +28,34 @@ template <typename T>
 class CrossThreadEventScheduler {
  public:
   explicit CrossThreadEventScheduler(size_t capacity) {
-    auto [sender, receiver] = channel<std::function<void(T&)>>(capacity);
+    auto [sender, receiver] = channel<std::function<void(T &)>>(capacity);
     eventSender_ = std::move(sender);
     eventReceiver_ = std::move(receiver);
   }
-  CrossThreadEventScheduler(const CrossThreadEventScheduler&) = delete;
-  CrossThreadEventScheduler& operator=(const CrossThreadEventScheduler&) = delete;
+  CrossThreadEventScheduler(const CrossThreadEventScheduler &) = delete;
+  CrossThreadEventScheduler &operator=(const CrossThreadEventScheduler &) = delete;
 
   /// @brief Schedules an event to be processed on the audio thread.
   /// @param event The event to schedule.
   /// @return True if the event was successfully scheduled, false if the queue is full.
-  bool scheduleEvent(std::function<void(T&)> &&event) noexcept(noexcept(eventSender_.try_send(std::move(event)))) {
+  bool scheduleEvent(std::function<void(T &)> &&event) noexcept(
+      noexcept(eventSender_.try_send(std::move(event)))) {
     return eventSender_.try_send(std::move(event)) == ResponseStatus::SUCCESS;
   }
 
   /// @brief Processes all scheduled events.
   /// @param data The data to pass to each event.
-  void processAllEvents(T& data) noexcept(noexcept(eventReceiver_.try_receive(std::declval<std::function<void(T&)>&>()))) {
-    std::function<void(T&)> event;
+  void processAllEvents(T &data) noexcept(
+      noexcept(eventReceiver_.try_receive(std::declval<std::function<void(T &)> &>()))) {
+    std::function<void(T &)> event;
     while (eventReceiver_.try_receive(event) == ResponseStatus::SUCCESS) {
       event(data);
     }
   }
 
  private:
-  Sender<std::function<void(T&)>> eventSender_;
-  Receiver<std::function<void(T&)>> eventReceiver_;
+  Sender<std::function<void(T &)>> eventSender_;
+  Receiver<std::function<void(T &)>> eventReceiver_;
 };
 
 } // namespace audioapi

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

@@ -1,12 +1,14 @@
 #pragma once
 #include <functional>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
 /// @brief A forward declaration of a move-only function wrapper.
 /// @note it is somehow required to have <R(Args...)> specialization below
 /// @tparam Signature
-template<typename Signature>
+template <typename Signature>
 class move_only_function; // Forward declaration
 
 /// @brief A move-only function wrapper similar to std::function but non-copyable.
@@ -18,7 +20,7 @@ class move_only_function; // Forward declaration
 /// @note IMPORTANT: This thing is implemented in C++23 standard and can be replaced with std::move_only_function once we switch to C++23.
 /// @tparam R
 /// @tparam ...Args
-template<typename R, typename... Args>
+template <typename R, typename... Args>
 class move_only_function<R(Args...)> {
   /// @brief The base class for type erasure.
   /// @note It gets optimized by Empty Base Optimization (EBO) when possible.
@@ -29,7 +31,7 @@ class move_only_function<R(Args...)> {
 
   /// @brief The implementation of the callable object.
   /// @tparam F
-  template<typename F>
+  template <typename F>
   struct callable_impl : callable_base {
     /// @brief The stored callable object.
     F f;
@@ -38,8 +40,8 @@ class move_only_function<R(Args...)> {
     /// @tparam G
     /// @param func
     /// @note The enable_if_t ensures that F can be constructed from G&&.
-    template<typename G, typename = std::enable_if_t<std::is_constructible_v<F, G&&>>>
-    callable_impl(G&& func) : f(std::forward<G>(func)) {}
+    template <typename G, typename = std::enable_if_t<std::is_constructible_v<F, G &&>>>
+    explicit callable_impl(G &&func) : f(std::forward<G>(func)) {}
 
     /// @brief Invoke the stored callable object with the given arguments.
     /// @param args
@@ -58,19 +60,19 @@ class move_only_function<R(Args...)> {
   /// @brief The unique pointer to the base callable type.
   std::unique_ptr<callable_base> impl_;
 
-public:
+ public:
   move_only_function() = default;
   move_only_function(std::nullptr_t) noexcept : impl_(nullptr) {}
 
-  template<typename F>
-  move_only_function(F&& f)
-    : impl_(std::make_unique<callable_impl<std::decay_t<F>>>(std::forward<F>(f))) {}
+  template <typename F>
+  move_only_function(F &&f)
+      : impl_(std::make_unique<callable_impl<std::decay_t<F>>>(std::forward<F>(f))) {}
 
-  move_only_function(const move_only_function&) = delete;
-  move_only_function& operator=(const move_only_function&) = delete;
+  move_only_function(const move_only_function &) = delete;
+  move_only_function &operator=(const move_only_function &) = delete;
 
-  move_only_function(move_only_function&&) = default;
-  move_only_function& operator=(move_only_function&&) = default;
+  move_only_function(move_only_function &&) = default;
+  move_only_function &operator=(move_only_function &&) = default;
 
   inline explicit operator bool() const noexcept {
     return impl_ != nullptr;
@@ -78,13 +80,13 @@ public:
 
   inline R operator()(Args... args) {
     /// We are unlikely to hit this case as we want to optimize for the common case.
-    if (impl_ == nullptr) [[ unlikely ]] {
+    if (impl_ == nullptr) [[unlikely]] {
       throw std::bad_function_call{};
     }
     return (*impl_)(std::forward<Args>(args)...);
   }
 
-  void swap(move_only_function& other) noexcept {
+  void swap(move_only_function &other) noexcept {
     impl_.swap(other.impl_);
   }
 };