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

package/common/cpp/audioapi/core/effects/WorkletNode.cpp

@@ -1,4 +1,8 @@
 #include <audioapi/core/effects/WorkletNode.h>
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -12,8 +16,7 @@ WorkletNode::WorkletNode(
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  bus_ = std::make_shared<AudioBus>(
-      bufferLength, inputChannelCount, context->getSampleRate());
+  bus_ = std::make_shared<AudioBus>(bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 
@@ -21,9 +24,8 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t processed = 0;
-  size_t channelCount_ = std::min(
-      inputChannelCount_,
-      static_cast<size_t>(processingBus->getNumberOfChannels()));
+  size_t channelCount_ =
+      std::min(inputChannelCount_, static_cast<size_t>(processingBus->getNumberOfChannels()));
   while (processed < framesToProcess) {
     size_t framesToWorkletInvoke = bufferLength_ - curBuffIndex_;
     size_t needsToProcess = framesToProcess - processed;
@@ -43,8 +45,7 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     }
     // Reset buffer index, channel buffers and execute worklet
     curBuffIndex_ = 0;
-    workletRunner_.executeOnRuntimeSync([this, channelCount_](
-                                            jsi::Runtime &uiRuntimeRaw) {
+    workletRunner_.executeOnRuntimeSync([this, channelCount_](jsi::Runtime &uiRuntimeRaw) {
       /// Arguments preparation
       auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
       for (size_t ch = 0; ch < channelCount_; ch++) {
@@ -52,10 +53,8 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
         audioArray->copy(bus_->getChannel(ch));
         auto sharedAudioArray = std::make_shared<AudioArrayBuffer>(audioArray);
         auto sharedAudioArraySize = sharedAudioArray->size();
-        auto arrayBuffer =
-            jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
-        arrayBuffer.setExternalMemoryPressure(
-            uiRuntimeRaw, sharedAudioArraySize);
+        auto arrayBuffer = jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+        arrayBuffer.setExternalMemoryPressure(uiRuntimeRaw, sharedAudioArraySize);
         jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
       }
 
@@ -63,8 +62,7 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
 
       /// Call the worklet
       workletRunner_.callUnsafe(
-          std::move(jsArray),
-          jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
+          std::move(jsArray), jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
 
       return jsi::Value::undefined();
     });

package/common/cpp/audioapi/core/effects/WorkletNode.h

@@ -1,13 +1,12 @@
 #pragma once
 
-
-#include <jsi/jsi.h>
-#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/AudioArray.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <vector>
@@ -21,11 +20,15 @@ class WorkletNode : public AudioNode {
       BaseAudioContext *context,
       size_t bufferLength,
       size_t inputChannelCount,
-      WorkletsRunner &&workletRunner
-  ) : AudioNode(context) {}
+      WorkletsRunner &&workletRunner)
+      : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
@@ -37,14 +40,14 @@ class WorkletNode : public AudioNode {
       BaseAudioContext *context,
       size_t bufferLength,
       size_t inputChannelCount,
-      WorkletsRunner &&workletRunner
-  );
+      WorkletsRunner &&workletRunner);
 
   ~WorkletNode() override = default;
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   WorkletsRunner workletRunner_;

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp

@@ -1,5 +1,7 @@
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -19,8 +21,7 @@ WorkletProcessingNode::WorkletProcessingNode(
     inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(inputAudioArray);
 
     auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
-    outputBuffsHandles_[i] =
-        std::make_shared<AudioArrayBuffer>(outputAudioArray);
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
 }
 
@@ -52,8 +53,7 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
           inputJsArray.setValueAtIndex(rt, ch, inputArrayBuffer);
 
           // Create output array buffer
-          auto outputArrayBuffer =
-              jsi::ArrayBuffer(rt, outputBuffsHandles_[ch]);
+          auto outputArrayBuffer = jsi::ArrayBuffer(rt, outputBuffsHandles_[ch]);
           outputJsArray.setValueAtIndex(rt, ch, outputArrayBuffer);
         }
 

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <jsi/jsi.h>
-#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/AudioArray.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
 #include <memory>
 #include <vector>
@@ -16,13 +16,15 @@ namespace audioapi {
 #if RN_AUDIO_API_TEST
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(
-      BaseAudioContext *context,
-      WorkletsRunner &&workletRunner
-  ) : AudioNode(context) {}
+  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+      : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
@@ -30,13 +32,12 @@ using namespace facebook;
 
 class WorkletProcessingNode : public AudioNode {
  public:
-  explicit WorkletProcessingNode(
-      BaseAudioContext *context,
-      WorkletsRunner &&workletRunner
-  );
+  explicit WorkletProcessingNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
   WorkletsRunner workletRunner_;

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,135 +1,66 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
 
 namespace audioapi {
 
-AudioRecorder::AudioRecorder(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  isRunning_.store(false);
-  fileOutputEnabled_.store(false);
-  callbackOutputEnabled_.store(false);
-  isConnected_.store(false);
-}
+/// @brief Sets the error callback to be invoked when an error occurs during recording.
+/// This method should be called from the JS thread only.
+/// @param callbackId Identifier for the JS callback to be invoked.
+void AudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-bool AudioRecorder::isRecording() {
-  return isRunning_.load();
-}
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  // node->init();
-  // adapterNodeLock_.lock();
-  // adapterNode_ = node;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(true);
-  //   node->init(ringBufferSize_);
-  //   adapterNodeLock_.lock();
-  //   adapterNode_ = node;
-  //   adapterNodeLock_.unlock();
-}
+  if (usesCallback()) {
+    dataCallback_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::disconnect() {
-  // adapterNodeLock_.lock();
-  // adapterNode_ = nullptr;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(false);
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
-void AudioRecorder::setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId) {
-  callbackProperties_.sampleRate = sampleRate;
-  callbackProperties_.bufferLength = bufferLength;
-  callbackProperties_.channelCount = channelCount;
-  callbackProperties_.callbackId = callbackId;
-
-  callbackOutputEnabled_.store(true);
-}
+/// @brief Clears the error callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void AudioRecorder::clearOnErrorCallback() {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-void AudioRecorder::clearOnAudioReadyCallback() {
-  callbackOutputEnabled_.store(false);
-  callbackProperties_ = CallbackProperties{};
-}
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
 
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
-
-  //   auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  //   auto audioBufferHostObject =
-  //       std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  //   std::unordered_map<std::string, EventValue> body = {};
-  //   body.insert({"buffer", audioBufferHostObject});
-  //   body.insert({"numFrames", numFrames});
-
-  //   if (audioEventHandlerRegistry_ != nullptr) {
-  //     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-  //         "audioReady", onAudioReadyCallbackId_, body);
-  //   }
-}
+  if (usesCallback()) {
+    dataCallback_->clearOnErrorCallback();
+  }
 
-void AudioRecorder::sendRemainingCallbackData() {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
+  errorCallbackId_.store(0, std::memory_order_release);
+}
 
-  //   auto bus = std::make_shared<AudioBus>(
-  //       circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  //   auto *outputChannel = bus->getChannel(0)->getData();
-  //   auto availableFrames =
-  //       static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+/// @brief Gets the current duration of the recorded audio in seconds.
+/// @returns Duration in seconds.
+double AudioRecorder::getCurrentDuration() const {
+  double duration = 0.0;
 
-  //   circularBuffer_->pop_front(
-  //       outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  if (usesFileOutput()) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  //   invokeOnAudioReadyCallback(bus, availableFrames);
+  return duration;
 }
 
 bool AudioRecorder::usesCallback() const {
-  return callbackOutputEnabled_.load();
+  return callbackOutputEnabled_.load(std::memory_order_acquire);
 }
 
 bool AudioRecorder::usesFileOutput() const {
-  return fileOutputEnabled_.load();
+  return fileOutputEnabled_.load(std::memory_order_acquire);
 }
 
 bool AudioRecorder::isConnected() const {
-  return isConnected_.load();
+  return isConnected_.load(std::memory_order_acquire);
 }
 
-// AudioRecorder::AudioRecorder(
-//     const std::shared_ptr<AudioEventHandlerRegistry>
-//     &audioEventHandlerRegistry)
-//       audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-//   constexpr int minRingBufferSize = 8192;
-//   ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-
-//   circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-//   isRunning_.store(false);
-// }
-
-// void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-//   if (adapterNodeLock_.try_lock()) {
-//     if (adapterNode_ != nullptr) {
-//       adapterNode_->buff_->write(data, numFrames);
-//     }
-//     adapterNodeLock_.unlock();
-//   }
-
-//   if (hasCallback()) {
-//     circularBuffer_->push_back(data, numFrames);
-//   }
-// }
-
 } // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,81 +1,82 @@
 #pragma once
 
-#include <memory>
+#include <audioapi/utils/Result.hpp>
 #include <atomic>
+#include <memory>
 #include <mutex>
 #include <string>
+#include <tuple>
 
 namespace audioapi {
 
-class RecorderAdapterNode;
 class AudioBus;
+class AudioFileWriter;
 class CircularAudioArray;
+class RecorderAdapterNode;
+class AudioFileProperties;
+class AudioRecorderCallback;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  enum class RecorderState { Idle = 0, Recording, Paused };
+  explicit AudioRecorder(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+      : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  virtual void start() = 0;
-  virtual std::string stop() = 0;
+  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
 
-  bool isRecording();
-
-  virtual void enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) = 0;
+  virtual Result<std::string, std::string> enableFileOutput(
+      std::shared_ptr<AudioFileProperties> properties) = 0;
   virtual void disableFileOutput() = 0;
 
   virtual void pause() = 0;
   virtual void resume() = 0;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
-  void disconnect();
+  virtual void connect(const std::shared_ptr<RecorderAdapterNode> &node) = 0;
+  virtual void disconnect() = 0;
+
+  virtual Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
 
-  void setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId);
-  void clearOnAudioReadyCallback();
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
 
-  void invokeOnAudioReadyCallback(
-      const std::shared_ptr<AudioBus> &bus,
-      int numFrames);
-  void sendRemainingCallbackData();
+  virtual double getCurrentDuration() const;
 
   bool usesCallback() const;
   bool usesFileOutput() const;
   bool isConnected() const;
 
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
+
  protected:
-  struct CallbackProperties {
-    float sampleRate;
-    size_t bufferLength;
-    size_t channelCount;
-    uint64_t callbackId;
-  };
-
-  CallbackProperties callbackProperties_;
-  // size_t ringBufferSize_;
-
-  std::atomic<bool> isRunning_;
-  std::atomic<bool> fileOutputEnabled_;
-  std::atomic<bool> callbackOutputEnabled_;
-  std::atomic<bool> isConnected_;
-  // std::shared_ptr<CircularAudioArray> circularBuffer_;
-
-  mutable std::mutex adapterNodeLock_;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::atomic<RecorderState> state_{RecorderState::Idle};
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
+  std::atomic<bool> isConnected_{false};
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
+
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+  std::mutex errorCallbackMutex_;
+  mutable std::mutex adapterNodeMutex_;
 
-  // void writeToBuffers(const float *data, int numFrames);
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::string filePath_{""};
+  std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
+  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/AudioBuffer.cpp

@@ -2,14 +2,13 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
+#include <algorithm>
+#include <memory>
 #include <utility>
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(
-    int numberOfChannels,
-    size_t length,
-    float sampleRate) {
+AudioBuffer::AudioBuffer(int numberOfChannels, size_t length, float sampleRate) {
   bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
 }
 
@@ -45,8 +44,7 @@ void AudioBuffer::copyFromChannel(
   memcpy(
       destination,
       bus_->getChannel(channelNumber)->getData() + startInChannel,
-      std::min(destinationLength, getLength() - startInChannel) *
-          sizeof(float));
+      std::min(destinationLength, getLength() - startInChannel) * sizeof(float));
 }
 
 void AudioBuffer::copyToChannel(

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <algorithm>
+#include <cstddef>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
-#include <cstddef>
-#include <cstring>
 
 namespace audioapi {
 
@@ -28,11 +28,8 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
       size_t destinationLength,
       int channelNumber,
       size_t startInChannel) const;
-  void copyToChannel(
-      const float *source,
-      size_t sourceLength,
-      int channelNumber,
-      size_t startInChannel);
+  void
+  copyToChannel(const float *source, size_t sourceLength, int channelNumber, size_t startInChannel);
 
  private:
   friend class AudioBufferSourceNode;