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

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,36 +1,58 @@
-// 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();
-// }
-
-// void AudioRecorder::disconnect() {
-// adapterNodeLock_.lock();
-// adapterNode_ = nullptr;
-// adapterNodeLock_.unlock();
-// isConnected_.store(false);
-// }
-
-// 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_);
-//   state_.store(RecorderState::Idle);
-// }
-
-// void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-//   if (adapterNodeLock_.try_lock()) {
-//     if (adapterNode_ != nullptr) {
-//       adapterNode_->buff_->write(data, numFrames);
-//     }
-//     adapterNodeLock_.unlock();
-//   }
-// }
+
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+
+namespace audioapi {
+
+void AudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
+
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
+
+  if (usesCallback()) {
+    dataCallback_->setOnErrorCallback(callbackId);
+  }
+
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioRecorder::clearOnErrorCallback() {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
+
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
+
+  if (usesCallback()) {
+    dataCallback_->clearOnErrorCallback();
+  }
+
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+double AudioRecorder::getCurrentDuration() const {
+  double duration = 0.0;
+
+  if (usesFileOutput()) {
+    duration = fileWriter_->getCurrentDuration();
+  }
+
+  return duration;
+}
+
+bool AudioRecorder::usesCallback() const {
+  return callbackOutputEnabled_.load(std::memory_order_acquire);
+}
+
+bool AudioRecorder::usesFileOutput() const {
+  return fileOutputEnabled_.load(std::memory_order_acquire);
+}
+
+bool AudioRecorder::isConnected() const {
+  return isConnected_.load(std::memory_order_acquire);
+}
+
+} // namespace audioapi

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

@@ -1,83 +1,81 @@
 #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:
-  enum RecorderState { Idle, Recording, Paused };
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry):
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
+  enum class RecorderState { Idle = 0, Recording, Paused };
+  explicit AudioRecorder(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+      : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  virtual std::string start() = 0;
-  virtual std::tuple<std::string, double, double> stop() = 0;
+  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
 
-  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 void setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId) = 0;
+  virtual Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) = 0;
   virtual void clearOnAudioReadyCallback() = 0;
 
-  virtual double getCurrentDuration() const = 0;
-
-  bool usesCallback() const {
-    return callbackOutputEnabled_.load();
-  }
-
-  bool usesFileOutput() const {
-    return fileOutputEnabled_.load();
-  }
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
 
-  bool isConnected() const {
-    return isConnected_.load();
-  }
+  virtual double getCurrentDuration() const;
 
-  bool isRecording() const {
-    return state_.load() == RecorderState::Recording;
-  }
+  bool usesCallback() const;
+  bool usesFileOutput() const;
+  bool isConnected() const;
 
-  bool isPaused() const {
-    return state_.load() == RecorderState::Paused;
-  }
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
 
  protected:
-  // size_t ringBufferSize_;
+  std::atomic<RecorderState> state_{RecorderState::Idle};
 
-  std::atomic<RecorderState> state_{ RecorderState::Idle };
+  std::atomic<bool> isConnected_{false};
   std::atomic<bool> fileOutputEnabled_{false};
   std::atomic<bool> callbackOutputEnabled_{false};
-  std::atomic<bool> isConnected_{false};
-  // std::shared_ptr<CircularAudioArray> circularBuffer_;
 
-  mutable std::mutex adapterNodeLock_;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+  std::mutex errorCallbackMutex_;
+  mutable std::mutex adapterNodeMutex_;
 
+  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_;
 };
 

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;

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

@@ -5,14 +5,15 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
     BaseAudioContext *context,
     bool pitchCorrection)
-    : AudioScheduledSourceNode(context),
-      pitchCorrection_(pitchCorrection),
-      vReadIndex_(0.0) {
+    : AudioScheduledSourceNode(context), pitchCorrection_(pitchCorrection), vReadIndex_(0.0) {
   onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
 
   detuneParam_ = std::make_shared<AudioParam>(
@@ -20,41 +21,31 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
   playbackRateParam_ = std::make_shared<AudioParam>(
       1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
 
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+  playbackRateBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+  stretch_ = std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }
 
-std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
-    const {
+std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam() const {
   return playbackRateParam_;
 }
 
-void AudioBufferBaseSourceNode::clearOnPositionChangedCallback() {
-  if (onPositionChangedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "positionChanged", onPositionChangedCallbackId_);
-  onPositionChangedCallbackId_ = 0;
-}
+void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(uint64_t callbackId) {
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
-void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
-    uint64_t callbackId) {
-  onPositionChangedCallbackId_ = callbackId;
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("positionChanged", oldCallbackId);
+  }
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
-  onPositionChangedInterval_ = static_cast<int>(
-      context_->getSampleRate() * static_cast<float>(interval) / 1000);
+  onPositionChangedInterval_ =
+      static_cast<int>(context_->getSampleRate() * static_cast<float>(interval) / 1000);
 }
 
 int AudioBufferBaseSourceNode::getOnPositionChangedInterval() const {
@@ -65,15 +56,28 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
   return bufferLock_;
 }
 
+double AudioBufferBaseSourceNode::getInputLatency() const {
+  if (pitchCorrection_) {
+    return static_cast<double>(stretch_->inputLatency()) / context_->getSampleRate();
+  }
+  return 0;
+}
+
+double AudioBufferBaseSourceNode::getOutputLatency() const {
+  if (pitchCorrection_) {
+    return static_cast<double>(stretch_->outputLatency()) / context_->getSampleRate();
+  }
+  return 0;
+}
+
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_ &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    std::unordered_map<std::string, EventValue> body = {
-        {"value", getCurrentPosition()}};
+  auto onPositionChangedCallbackId = onPositionChangedCallbackId_.load(std::memory_order_acquire);
+
+  if (onPositionChangedCallbackId != 0 && onPositionChangedTime_ > onPositionChangedInterval_) {
+    std::unordered_map<std::string, EventValue> body = {{"value", getCurrentPosition()}};
 
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "positionChanged", onPositionChangedCallbackId_, body);
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "positionChanged", onPositionChangedCallbackId, body);
 
     onPositionChangedTime_ = 0;
   }
@@ -88,34 +92,26 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
   size_t offsetLength = 0;
 
   auto time = context_->getCurrentTime();
-  auto playbackRate = std::clamp(
-      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
-  auto detune = std::clamp(
-      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
-      -12.0f,
-      12.0f);
+  auto playbackRate =
+      std::clamp(playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune =
+      std::clamp(detuneParam_->processKRateParam(framesToProcess, time) / 100.0f, -12.0f, 12.0f);
 
   playbackRateBus_->zero();
 
-  auto framesNeededToStretch =
-      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+  auto framesNeededToStretch = static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
 
-  updatePlaybackInfo(
-      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+  updatePlaybackInfo(playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
   if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }
 
-  processWithoutInterpolation(
-      playbackRateBus_, startOffset, offsetLength, playbackRate);
+  processWithoutInterpolation(playbackRateBus_, startOffset, offsetLength, playbackRate);
 
   stretch_->process(
-      playbackRateBus_.get()[0],
-      framesNeededToStretch,
-      processingBus.get()[0],
-      framesToProcess);
+      playbackRateBus_.get()[0], framesNeededToStretch, processingBus.get()[0], framesToProcess);
 
   if (detune != 0.0f) {
     stretch_->setTransposeSemitones(detune);
@@ -139,24 +135,19 @@ void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
   }
 
   if (std::fabs(computedPlaybackRate) == 1.0) {
-    processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
+    processWithoutInterpolation(processingBus, startOffset, offsetLength, computedPlaybackRate);
   } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
+    processWithInterpolation(processingBus, startOffset, offsetLength, computedPlaybackRate);
   }
 
   sendOnPositionChangedEvent();
 }
 
-float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(
-    int framesToProcess) {
+float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
   auto time = context_->getCurrentTime();
 
-  auto playbackRate =
-      playbackRateParam_->processKRateParam(framesToProcess, time);
-  auto detune = std::pow(
-      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
+  auto playbackRate = playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto detune = std::pow(2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
 
   return playbackRate * detune;
 }