react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-52d0b79-20251216

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+typedef Result<std::string, std::string> OpenFileResult;
+typedef Result<std::tuple<double, double>, std::string> CloseFileResult;
+
+class AudioFileWriter {
+ public:
+  AudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  virtual ~AudioFileWriter() = default;
+
+  virtual CloseFileResult closeFile() = 0;
+
+  virtual std::string getFilePath() const = 0;
+  virtual double getCurrentDuration() const = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  bool isFileOpen();
+
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<size_t> framesWritten_{0};
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+};
+
+} // namespace audioapi

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/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/Result.hpp

@@ -0,0 +1,323 @@
+#pragma once
+
+#include <functional>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+struct NoneType {};
+inline constexpr NoneType None{};
+
+/// @brief A Result type that can represent either a success (Ok) or an error (Err).
+/// @tparam T value type for success
+/// @tparam E error type for failure
+/// @note Specializations for void T and/or void E are not provided. Use NoneType instead.
+/// Design inspired by Rust's Result type.
+/// https://doc.rust-lang.org/std/result/
+///
+/// @example
+/// /// Creating an Ok Result and mapping its error:
+/// Result<int, std::string> res = Result<int, int>::Err(404)
+///   .map_err<std::string>([](auto code){
+///      return "Error code: " + std::to_string(code);
+///    });
+///
+template <typename T = NoneType, typename E = NoneType>
+class Result {
+  struct OkTag {};
+  struct ErrTag {};
+
+  explicit Result(OkTag, const T &value) : ok_value(value), is_ok_(true) {}
+  explicit Result(OkTag, T &&value) : ok_value(std::move(value)), is_ok_(true) {}
+  explicit Result(ErrTag, const E &error) : err_value(error), is_ok_(false) {}
+  explicit Result(ErrTag, E &&error) : err_value(std::move(error)), is_ok_(false) {}
+
+ public:
+  Result(const Result<T, E> &other) {
+    is_ok_ = other.is_ok_;
+    if (is_ok_) {
+      new (&ok_value) T(other.ok_value);
+    } else {
+      new (&err_value) E(other.err_value);
+    }
+  }
+
+  Result(Result<T, E> &&other) noexcept(
+      std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_constructible_v<E>) {
+    is_ok_ = other.is_ok_;
+    if (is_ok_) {
+      new (&ok_value) T(std::move(other.ok_value));
+    } else {
+      new (&err_value) E(std::move(other.err_value));
+    }
+  }
+
+  Result &operator=(const Result &other) {
+    if (this == &other)
+      return *this;
+    if (is_ok_ == other.is_ok_) {
+      if (is_ok_)
+        ok_value = other.ok_value;
+      else
+        err_value = other.err_value;
+    } else {
+      if (is_ok_) {
+        ok_value.~T();
+        new (&err_value) E(other.err_value);
+        is_ok_ = false;
+      } else {
+        err_value.~E();
+        new (&ok_value) T(other.ok_value);
+        is_ok_ = true;
+      }
+    }
+    return *this;
+  }
+
+  Result &operator=(Result &&other) noexcept(
+      std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_assignable_v<E> &&
+      std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_constructible_v<E>) {
+    if (this == &other)
+      return *this;
+    if (is_ok_ == other.is_ok_) {
+      if (is_ok_)
+        ok_value = std::move(other.ok_value);
+      else
+        err_value = std::move(other.err_value);
+    } else {
+      if (is_ok_) {
+        ok_value.~T();
+        new (&err_value) E(std::move(other.err_value));
+        is_ok_ = false;
+      } else {
+        err_value.~E();
+        new (&ok_value) T(std::move(other.ok_value));
+        is_ok_ = true;
+      }
+    }
+    return *this;
+  }
+
+  ~Result() {
+    if (is_ok_) {
+      ok_value.~T();
+    } else {
+      err_value.~E();
+    }
+  }
+
+  /// @brief Creates a success Result.
+  static Result<T, E> Ok(const T &value) {
+    return Result<T, E>(OkTag{}, value);
+  }
+
+  /// @brief Creates a success Result from an rvalue.
+  static Result<T, E> Ok(T &&value) {
+    return Result<T, E>(OkTag{}, std::move(value));
+  }
+
+  /// @brief Creates an error Result.
+  static Result<T, E> Err(const E &error) {
+    return Result<T, E>(ErrTag{}, error);
+  }
+
+  /// @brief Creates an error Result from an rvalue.
+  static Result<T, E> Err(E &&error) {
+    return Result<T, E>(ErrTag{}, std::move(error));
+  }
+
+  /// @brief Returns true if the result is Ok.
+  [[nodiscard]] bool is_ok() const {
+    return is_ok_;
+  }
+
+  /// @brief Returns true if the result is Err.
+  [[nodiscard]] bool is_err() const {
+    return !is_ok_;
+  }
+
+  /// @brief Returns the contained Ok value, consuming the Result.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] T expect(const std::string &msg) && {
+    if (!is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] const T &expect(const std::string &msg) const & {
+    if (!is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Ok value, consuming the Result.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] T unwrap() && {
+    if (!is_ok_) {
+      throw std::runtime_error("Called unwrap on an Err value");
+    }
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] const T &unwrap() const & {
+    if (!is_ok_) {
+      throw std::runtime_error("Called unwrap on an Err value");
+    }
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Ok value or a default. Consumes self.
+  [[nodiscard]] T unwrap_or(T &&default_value) && {
+    if (is_ok_) {
+      return std::move(ok_value);
+    }
+    return std::move(default_value);
+  }
+
+  /// @brief Returns the contained Ok value or computes it from a closure. Consumes self.
+  [[nodiscard]] T unwrap_or_else(const std::function<T(E &&)> &func) && {
+    if (is_ok_) {
+      return std::move(ok_value);
+    }
+    return func(std::move(err_value));
+  }
+
+  /// @brief Returns the contained Ok value without checking. UB if Err.
+  [[nodiscard]] T unwrap_unchecked() && noexcept {
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value without checking. UB if Err.
+  [[nodiscard]] const T &unwrap_unchecked() const & noexcept {
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Err value, consuming the Result.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] E unwrap_err() && {
+    if (is_ok_) {
+      throw std::runtime_error("Called unwrap_err on an Ok value");
+    }
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] const E &unwrap_err() const & {
+    if (is_ok_) {
+      throw std::runtime_error("Called unwrap_err on an Ok value");
+    }
+    return err_value;
+  }
+
+  /// @brief Returns the contained Err value, consuming the Result.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] E expect_err(const std::string &msg) && {
+    if (is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] const E &expect_err(const std::string &msg) const & {
+    if (is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return err_value;
+  }
+
+  /// @brief Returns the contained Err value without checking. UB if Ok.
+  [[nodiscard]] E unwrap_err_unchecked() && noexcept {
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value without checking. UB if Ok.
+  [[nodiscard]] const E &unwrap_err_unchecked() const & noexcept {
+    return err_value;
+  }
+
+  /// @brief Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value.
+  template <typename F>
+  [[nodiscard]] auto map(F &&ok_func) && {
+    using U = std::invoke_result_t<F, T>;
+    using ResultType = Result<U, E>;
+    if (is_ok_) {
+      return ResultType::Ok(ok_func(std::move(ok_value)));
+    } else {
+      return ResultType::Err(std::move(err_value));
+    }
+  }
+
+  /// @brief Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value.
+  template <typename F>
+  [[nodiscard]] auto map_err(F &&err_func) && {
+    using U = std::invoke_result_t<F, E>;
+    using ResultType = Result<T, U>;
+    if (is_ok_) {
+      return ResultType::Ok(std::move(ok_value));
+    } else {
+      return ResultType::Err(err_func(std::move(err_value)));
+    }
+  }
+
+  /// @brief Returns the provided default (if Err), or applies a function to the contained value (if Ok).
+  template <typename F, typename U>
+  [[nodiscard]] auto map_or(F &&ok_func, U &&default_value) && {
+    if (is_ok_) {
+      return ok_func(std::move(ok_value));
+    } else {
+      return std::forward<U>(default_value);
+    }
+  }
+
+  /// @brief Maps a Result<T, E> to U by applying fallback function default to a contained Err value, or function f to a contained Ok value.
+  template <typename FT, typename FE>
+  [[nodiscard]] auto map_or_else(FT &&ok_func, FE &&err_func) && {
+    if (is_ok_) {
+      return ok_func(std::move(ok_value));
+    } else {
+      return err_func(std::move(err_value));
+    }
+  }
+
+  /// @brief Calls the provided closure with the contained Ok value, if any, otherwise returns the Err value of self.
+  /// @tparam for Result<T,E> F is a closure that takes T and returns Result<TNew, E>
+  template <typename F>
+  [[nodiscard]] auto and_then(F &&ok_func) && {
+    using ResultType = std::invoke_result_t<F, T>;
+    if (is_ok_) {
+      return ok_func(std::move(ok_value));
+    } else {
+      return ResultType::Err(std::move(err_value));
+    }
+  }
+
+  /// @brief Calls the provided closure with the contained Err value, if any, otherwise returns the Ok value of self.
+  /// @tparam for Result<T,E> F is a closure that takes E and returns Result<T, ENew>
+  template <typename F>
+  [[nodiscard]] auto or_else(F &&err_func) && {
+    using ResultType = std::invoke_result_t<F, E>;
+    if (is_ok_) {
+      return ResultType::Ok(std::move(ok_value));
+    } else {
+      return err_func(std::move(err_value));
+    }
+  }
+
+ private:
+  union {
+    T ok_value;
+    E err_value;
+  };
+  bool is_ok_;
+};

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

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace audioapi {
+
+static constexpr double KB_IN_BYTES = 1024.0;
+static constexpr double MB_IN_BYTES = KB_IN_BYTES * 1024.0;
+static constexpr double GB_IN_BYTES = MB_IN_BYTES * 1024.0;
+
+} // namespace audioapi