react-native-audio-api 0.11.0-alpha.0 → 0.11.0-nightly-bfab178-20251107

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

@@ -5,131 +5,78 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/CircularOverflowableAudioArray.h>
 
 namespace audioapi {
 
 AudioRecorder::AudioRecorder(
+    float sampleRate,
+    int bufferLength,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  constexpr int minRingBufferSize = 8192;
+  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
+  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
   isRunning_.store(false);
-  fileOutputEnabled_.store(false);
-  callbackOutputEnabled_.store(false);
-  isConnected_.store(false);
-}
-
-bool AudioRecorder::isRecording() {
-  return isRunning_.load();
-}
-
-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);
-}
-
-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);
-}
-
-void AudioRecorder::clearOnAudioReadyCallback() {
-  callbackOutputEnabled_.store(false);
-  callbackProperties_ = CallbackProperties{};
+void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
+  onAudioReadyCallbackId_ = callbackId;
 }
 
 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);
-  //   }
+  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);
+  }
 }
 
-void AudioRecorder::sendRemainingCallbackData() {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
-
-  //   auto bus = std::make_shared<AudioBus>(
-  //       circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  //   auto *outputChannel = bus->getChannel(0)->getData();
-  //   auto availableFrames =
-  //       static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
+void AudioRecorder::sendRemainingData() {
+  auto bus = std::make_shared<AudioBus>(
+      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
+  auto *outputChannel = bus->getChannel(0)->getData();
+  auto availableFrames =
+      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
 
-  //   circularBuffer_->pop_front(
-  //       outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  circularBuffer_->pop_front(
+      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
 
-  //   invokeOnAudioReadyCallback(bus, availableFrames);
+  invokeOnAudioReadyCallback(bus, availableFrames);
 }
 
-bool AudioRecorder::usesCallback() const {
-  return callbackOutputEnabled_.load();
+void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+  node->init(ringBufferSize_);
+  adapterNodeLock_.lock();
+  adapterNode_ = node;
+  adapterNodeLock_.unlock();
 }
 
-bool AudioRecorder::usesFileOutput() const {
-  return fileOutputEnabled_.load();
+void AudioRecorder::disconnect() {
+  adapterNodeLock_.lock();
+  adapterNode_ = nullptr;
+  adapterNodeLock_.unlock();
 }
 
-bool AudioRecorder::isConnected() const {
-  return isConnected_.load();
+void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
+  if (adapterNodeLock_.try_lock()) {
+    if (adapterNode_ != nullptr) {
+      adapterNode_->buff_->write(data, numFrames);
+    }
+    adapterNodeLock_.unlock();
+  }
+  circularBuffer_->push_back(data, numFrames);
 }
 
-// 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

@@ -3,71 +3,53 @@
 #include <memory>
 #include <atomic>
 #include <mutex>
-#include <string>
 
 namespace audioapi {
 
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;
+class CircularOverflowableAudioArray;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-  virtual ~AudioRecorder() = default;
-
-  virtual void start() = 0;
-  virtual std::string stop() = 0;
-
-  bool isRecording();
-
-  virtual void enableFileOutput(
+  explicit AudioRecorder(
     float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) = 0;
-  virtual void disableFileOutput() = 0;
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
+  );
 
-  virtual void pause() = 0;
-  virtual void resume() = 0;
+  virtual ~AudioRecorder() = default;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
-  void disconnect();
+  void setOnAudioReadyCallbackId(uint64_t callbackId);
+  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
 
-  void setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId);
-  void clearOnAudioReadyCallback();
+  /// @brief
+  /// # Connects the recorder to the adapter node.
+  ///
+  /// The adapter node will be used to read audio data from the recorder.
+  /// @note Few frames of audio might not yet be written to the buffer when connecting.
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
 
-  void invokeOnAudioReadyCallback(
-      const std::shared_ptr<AudioBus> &bus,
-      int numFrames);
-  void sendRemainingCallbackData();
+  /// @brief
+  /// # Disconnects the recorder from the adapter node.
+  ///
+  /// The adapter node will no longer be used to read audio data from the recorder.
+  /// @note Last few frames of audio might be written to the buffer after disconnecting.
+  void disconnect();
 
-  bool usesCallback() const;
-  bool usesFileOutput() const;
-  bool isConnected() const;
+  virtual void start() = 0;
+  virtual void stop() = 0;
 
  protected:
-  struct CallbackProperties {
-    float sampleRate;
-    size_t bufferLength;
-    size_t channelCount;
-    uint64_t callbackId;
-  };
-
-  CallbackProperties callbackProperties_;
-  // size_t ringBufferSize_;
+  float sampleRate_;
+  int bufferLength_;
+  size_t ringBufferSize_;
 
   std::atomic<bool> isRunning_;
-  std::atomic<bool> fileOutputEnabled_;
-  std::atomic<bool> callbackOutputEnabled_;
-  std::atomic<bool> isConnected_;
-  // std::shared_ptr<CircularAudioArray> circularBuffer_;
+  std::shared_ptr<CircularAudioArray> circularBuffer_;
 
   mutable std::mutex adapterNodeLock_;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
@@ -75,7 +57,7 @@ class AudioRecorder {
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
   uint64_t onAudioReadyCallbackId_ = 0;
 
-  // void writeToBuffers(const float *data, int numFrames);
+  void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi

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

@@ -36,20 +36,15 @@ std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
   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) {
-  onPositionChangedCallbackId_ = callbackId;
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(
+      callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler(
+        "positionChanged", oldCallbackId);
+  }
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
@@ -66,14 +61,16 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_ &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
+  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;
   }

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

@@ -19,7 +19,6 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
-  void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
   [[nodiscard]] int getOnPositionChangedInterval() const;

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

@@ -123,19 +123,13 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::clearOnLoopEndedCallback() {
-  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "loopEnded", onLoopEndedCallbackId_);
-  onLoopEndedCallbackId_ = 0;
-}
-
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  onLoopEndedCallbackId_ = callbackId;
+  auto oldCallbackId =
+      onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
+  }
 }
 
 std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
@@ -171,8 +165,8 @@ void AudioBufferSourceNode::sendOnLoopEndedEvent() {
   auto onLoopEndedCallbackId =
       onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId, {});
   }
 }
 

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

@@ -34,7 +34,6 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
-  void clearOnLoopEndedCallback();
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
  protected:

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

@@ -14,6 +14,7 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
       stopTime_(-1.0),
       playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  audioEventHandlerRegistry_ = context_->audioEventHandlerRegistry_;
 }
 
 void AudioScheduledSourceNode::start(double when) {
@@ -45,19 +46,13 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::clearOnEndedCallback() {
-  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "ended", onEndedCallbackId_);
-  onEndedCallbackId_ = 0;
-}
-
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
-  onEndedCallbackId_ = callbackId;
+  auto oldCallbackId =
+      onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
+  }
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -76,7 +71,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
-  size_t lastFrame = firstFrame + framesToProcess;
+  size_t lastFrame = firstFrame + framesToProcess - 1;
 
   size_t startFrame =
       std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
@@ -105,7 +100,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
     nonSilentFramesToProcess =
-        std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+        std::max(std::min(lastFrame, stopFrame) + 1, startFrame) - startFrame;
 
     assert(startOffset <= framesToProcess);
     assert(nonSilentFramesToProcess <= framesToProcess);
@@ -124,7 +119,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
   // stop will happen in this render quantum
   // zero remaining frames after stop frame
-  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+  if (stopFrame <= lastFrame && stopFrame >= firstFrame) {
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
@@ -160,9 +155,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "ended", onEndedCallbackId_, {});
+  auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
+  if (onEndedCallbackId != 0) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "ended", onEndedCallbackId, {});
   }
 }
 

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

@@ -16,7 +16,7 @@
 
 namespace audioapi {
 
-class AudioEventHandlerRegistry;
+class IAudioEventHandlerRegistry;
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
@@ -37,7 +37,6 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -49,6 +48,7 @@ class AudioScheduledSourceNode : public AudioNode {
   PlaybackState playbackState_;
 
   std::atomic<uint64_t> onEndedCallbackId_ = 0;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,