react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

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,14 +71,13 @@ 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);
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
       : dsp::timeToSampleFrame(stopTime_, sampleRate);
-
   if (isFinished()) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
@@ -105,7 +99,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 +118,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 +154,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:
@@ -28,7 +28,7 @@ class AudioScheduledSourceNode : public AudioNode {
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
-  void start(double when);
+  virtual void start(double when);
   virtual void stop(double when);
 
   bool isUnscheduled();
@@ -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,

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

@@ -25,14 +25,12 @@ StreamerNode::StreamerNode(BaseAudioContext *context)
       codecpar_(nullptr),
       pkt_(nullptr),
       frame_(nullptr),
-      pendingFrame_(nullptr),
-      bufferedBus_(nullptr),
-      bufferedBusIndex_(0),
-      maxBufferSize_(0),
-      audio_stream_index_(-1),
       swrCtx_(nullptr),
       resampledData_(nullptr),
-      maxResampledSamples_(0) {}
+      bufferedBus_(nullptr),
+      audio_stream_index_(-1),
+      maxResampledSamples_(0),
+      processedSamples_(0) {}
 
 StreamerNode::~StreamerNode() {
   cleanup();
@@ -66,26 +64,22 @@ bool StreamerNode::initialize(const std::string &input_url) {
     return false;
   }
 
-  maxBufferSize_ = BUFFER_LENGTH_SECONDS * codecCtx_->sample_rate;
-  // If decoding is faster than playing, we buffer few seconds of audio
-  bufferedBus_ = std::make_shared<AudioBus>(
-      maxBufferSize_, codecpar_->ch_layout.nb_channels, codecCtx_->sample_rate);
-
   channelCount_ = codecpar_->ch_layout.nb_channels;
   audioBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
 
+  auto [sender, receiver] = channels::spsc::channel<
+      StreamingData,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::ATOMIC_WAIT>(CHANNEL_CAPACITY);
+  sender_ = std::move(sender);
+  receiver_ = std::move(receiver);
+
   streamingThread_ = std::thread(&StreamerNode::streamAudio, this);
-  streamFlag.store(true);
   isInitialized_ = true;
   return true;
 }
 
-void StreamerNode::stop(double when) {
-  AudioScheduledSourceNode::stop(when);
-  streamFlag.store(false);
-}
-
 bool StreamerNode::setupResampler() {
   // Allocate resampler context
   swrCtx_ = swr_alloc();
@@ -122,30 +116,27 @@ bool StreamerNode::setupResampler() {
 }
 
 void StreamerNode::streamAudio() {
-  while (streamFlag.load()) {
-    if (pendingFrame_ != nullptr) {
-      if (!processFrameWithResampler(pendingFrame_)) {
+  while (!isNodeFinished_.load(std::memory_order_acquire)) {
+    if (av_read_frame(fmtCtx_, pkt_) < 0) {
+      return;
+    }
+    if (pkt_->stream_index == audio_stream_index_) {
+      if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
         return;
       }
-    } else {
-      if (av_read_frame(fmtCtx_, pkt_) < 0) {
+      if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
         return;
       }
-      if (pkt_->stream_index == audio_stream_index_) {
-        if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
-          return;
-        }
-        if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
-          return;
-        }
-        if (!processFrameWithResampler(frame_)) {
-          return;
-        }
+      if (!processFrameWithResampler(frame_)) {
+        return;
       }
-      av_packet_unref(pkt_);
     }
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    av_packet_unref(pkt_);
   }
+  StreamingData dummy;
+  while (receiver_.try_receive(dummy) ==
+         channels::spsc::ResponseStatus::SUCCESS)
+    ; // clear the receiver
 }
 
 std::shared_ptr<AudioBus> StreamerNode::processNode(
@@ -154,34 +145,44 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
   size_t startOffset = 0;
   size_t offsetLength = 0;
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  isNodeFinished_.store(isFinished(), std::memory_order_release);
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
     return processingBus;
   }
 
-  // If we have enough buffered data, copy to output bus
-  if (bufferedBusIndex_ >= framesToProcess) {
-    Locker locker(mutex_);
+  int bufferRemaining = bufferedBusSize_ - processedSamples_;
+  int alreadyProcessed = 0;
+  if (bufferRemaining < framesToProcess) {
+    if (bufferedBus_ != nullptr) {
+      for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
+        memcpy(
+            processingBus->getChannel(ch)->getData(),
+            bufferedBus_->getChannel(ch)->getData() + processedSamples_,
+            bufferRemaining * sizeof(float));
+      }
+      framesToProcess -= bufferRemaining;
+      alreadyProcessed += bufferRemaining;
+    }
+    StreamingData data;
+    auto res = receiver_.try_receive(data);
+    if (res == channels::spsc::ResponseStatus::SUCCESS) {
+      bufferedBus_ = std::make_shared<AudioBus>(std::move(data.bus));
+      bufferedBusSize_ = data.size;
+      processedSamples_ = 0;
+    } else {
+      bufferedBus_ = nullptr;
+    }
+  }
+  if (bufferedBus_ != nullptr) {
     for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
       memcpy(
-          processingBus->getChannel(ch)->getData(),
-          bufferedBus_->getChannel(ch)->getData(),
-          offsetLength * sizeof(float));
-
-      memmove(
-          bufferedBus_->getChannel(ch)->getData(),
-          bufferedBus_->getChannel(ch)->getData() + offsetLength,
-          (maxBufferSize_ - offsetLength) * sizeof(float));
+          processingBus->getChannel(ch)->getData() + alreadyProcessed,
+          bufferedBus_->getChannel(ch)->getData() + processedSamples_,
+          framesToProcess * sizeof(float));
     }
-    bufferedBusIndex_ -= offsetLength;
-  } else {
-    if (VERBOSE)
-      printf(
-          "Buffer underrun: have %zu, need %zu\n",
-          bufferedBusIndex_,
-          (size_t)framesToProcess);
-    processingBus->zero();
+    processedSamples_ += framesToProcess;
   }
 
   return processingBus;
@@ -220,22 +221,21 @@ bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
     return false;
   }
 
-  // Check if converted data fits in buffer
-  if (bufferedBusIndex_ + converted_samples > maxBufferSize_) {
-    pendingFrame_ = frame;
+  // if we would like to finish dont copy anything
+  if (this->isFinished()) {
     return true;
-  } else {
-    pendingFrame_ = nullptr;
   }
-
-  // Copy converted data to our buffer
-  Locker locker(mutex_);
+  auto bus = AudioBus(
+      static_cast<size_t>(converted_samples),
+      codecCtx_->ch_layout.nb_channels,
+      context_->getSampleRate());
   for (int ch = 0; ch < codecCtx_->ch_layout.nb_channels; ch++) {
     auto *src = reinterpret_cast<float *>(resampledData_[ch]);
-    float *dst = bufferedBus_->getChannel(ch)->getData() + bufferedBusIndex_;
+    float *dst = bus.getChannel(ch)->getData();
     memcpy(dst, src, converted_samples * sizeof(float));
   }
-  bufferedBusIndex_ += converted_samples;
+  StreamingData data{std::move(bus), static_cast<size_t>(converted_samples)};
+  sender_.send(std::move(data));
   return true;
 }
 
@@ -280,7 +280,7 @@ bool StreamerNode::setupDecoder() {
 }
 
 void StreamerNode::cleanup() {
-  streamFlag.store(false);
+  this->playbackState_ = PlaybackState::FINISHED;
   // cleanup cannot be called from the streaming thread so there is no need to
   // check if we are in the same thread
   streamingThread_.join();

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

@@ -11,6 +11,7 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/utils/AudioBus.h>
 
 #ifndef AUDIO_API_TEST_SUITE
 extern "C" {
@@ -27,8 +28,35 @@ extern "C" {
 #include <memory>
 #include <string>
 #include <atomic>
+#include <utility>
+#ifndef AUDIO_API_TEST_SUITE
+#include <audioapi/utils/SpscChannel.hpp>
 
-static bool constexpr VERBOSE = false;
+static constexpr audioapi::channels::spsc::OverflowStrategy STREAMER_NODE_SPSC_OVERFLOW_STRATEGY =
+    audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
+static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_STRATEGY =
+    audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
+#endif
+
+static constexpr bool VERBOSE = false;
+static constexpr int CHANNEL_CAPACITY = 32;
+
+struct StreamingData{
+  audioapi::AudioBus bus;
+  size_t size;
+  StreamingData() = default;
+  StreamingData(audioapi::AudioBus b, size_t s) : bus(b), size(s) {}
+  StreamingData(const StreamingData& data) : bus(data.bus), size(data.size) {}
+  StreamingData(StreamingData&& data) noexcept : bus(std::move(data.bus)), size(data.size) {}
+  StreamingData& operator=(const StreamingData& data) {
+    if (this == &data) {
+      return *this;
+    }
+    bus = data.bus;
+    size = data.size;
+    return *this;
+  }
+};
 
 namespace audioapi {
 
@@ -43,7 +71,6 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @brief Initialize all necessary ffmpeg components for streaming audio
   */
   bool initialize(const std::string& inputUrl);
-  void stop(double when) override;
 
  protected:
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
@@ -56,19 +83,20 @@ class StreamerNode : public AudioScheduledSourceNode {
   AVCodecParameters* codecpar_;
   AVPacket* pkt_;
   AVFrame* frame_; // Frame that is currently being processed
-  AVFrame* pendingFrame_; // Frame that is saved if bufferedBus is full
-  std::shared_ptr<AudioBus> bufferedBus_; // audio bus for buffering hls frames
-  size_t bufferedBusIndex_; // index in the buffered bus where we write the next frame
-  size_t maxBufferSize_; // maximum size of the buffered bus
-  int audio_stream_index_; // index of the audio stream channel in the input
   SwrContext* swrCtx_;
   uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
+
+  std::shared_ptr<AudioBus> bufferedBus_; // audio bus for buffering hls frames
+  size_t bufferedBusSize_; // size of currently buffered bus
+  int audio_stream_index_; // index of the audio stream channel in the input
   int maxResampledSamples_;
-  std::mutex mutex_;
+  size_t processedSamples_;
+
   std::thread streamingThread_;
-  std::atomic<bool> streamFlag; // Flag to control the streaming thread
-  static constexpr float BUFFER_LENGTH_SECONDS = 5.0f; // Length of the buffer in seconds
+  std::atomic<bool> isNodeFinished_; // Flag to control the streaming thread
   static constexpr int INITIAL_MAX_RESAMPLED_SAMPLES = 8192; // Initial size for resampled data
+  channels::spsc::Sender<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> sender_;
+  channels::spsc::Receiver<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> receiver_;
 
   /**
    * @brief Setting up the resampler

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
@@ -221,6 +222,10 @@ inline bool AudioNodeManager::nodeCanBeDestructed(
   if constexpr (std::is_base_of_v<AudioScheduledSourceNode, U>) {
     return node.use_count() == 1 &&
         (node->isUnscheduled() || node->isFinished());
+  } else if constexpr (std::is_base_of_v<
+                           ConvolverNode,
+                           U>) { // convolver overrides disabling behavior
+    return node.use_count() == 1 && !node->isEnabled();
   }
   return node.use_count() == 1;
 }

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <numbers>
 #include <cmath>
 #include <limits>
 
@@ -19,7 +20,7 @@ static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
-static constexpr float PI = static_cast<float>(M_PI);
+static constexpr float PI = std::numbers::pi_v<float>;
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

package/common/cpp/audioapi/core/utils/worklets/SafeIncludes.h

@@ -5,14 +5,8 @@
 #include <string>
 #include <memory>
 
-#ifdef __APPLE__
-  /// We cannot make any conditional logic inside podspec but it should automatically compile those files
-  /// they should be accessible if someone has react-native-worklets in node_modules
-  #if __has_include(<worklets/WorkletRuntime/WorkletRuntime.h>)
-    #define RN_AUDIO_API_ENABLE_WORKLETS 1
-  #else
-    #define RN_AUDIO_API_ENABLE_WORKLETS 0
-  #endif
+#if ANDROID
+  #include <fbjni/detail/Environment.h>
 #endif
 
 #ifndef RN_AUDIO_API_TEST
@@ -78,4 +72,14 @@ class SerializableWorklet {
 struct RuntimeRegistry {
   std::weak_ptr<worklets::WorkletRuntime> uiRuntime;
   std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
+
+#if ANDROID
+    ~RuntimeRegistry() {
+        facebook::jni::ThreadScope::WithClassLoader(
+            [this]() {
+                uiRuntime.reset();
+                audioRuntime.reset();
+            });
+    }
+#endif
 };

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.cpp

@@ -4,7 +4,7 @@ namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     bool shouldLockRuntime)
     : weakRuntime_(std::move(weakRuntime)),
       shouldLockRuntime(shouldLockRuntime) {
@@ -33,8 +33,8 @@ WorkletsRunner::WorkletsRunner(
 WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
     : weakRuntime_(std::move(other.weakRuntime_)),
       unsafeRuntimePtr(other.unsafeRuntimePtr),
-      shouldLockRuntime(other.shouldLockRuntime),
-      workletInitialized(other.workletInitialized) {
+      workletInitialized(other.workletInitialized),
+      shouldLockRuntime(other.shouldLockRuntime) {
   if (workletInitialized) {
     std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
     other.workletInitialized = false;

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.h

@@ -28,7 +28,7 @@ class WorkletsRunner {
  public:
   explicit WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet>& shareableWorklet,
     bool shouldLockRuntime = true);
   WorkletsRunner(WorkletsRunner&&);
   ~WorkletsRunner();

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -30,4 +30,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return pow(10, value / 20);
 }
-} // namespace audioapi::dsp
+} // namespace audioapi::dsp