react-native-audio-api 0.7.2-nightly-31b46b8-20250820 → 0.7.2-nightly-c06331b-20250821

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

@@ -77,6 +77,8 @@ void BiquadFilterNode::getFrequencyResponse(
     float *magResponseOutput,
     float *phaseResponseOutput,
     const int length) {
+  applyFilter();
+
   // Local copies for micro-optimization
   float b0 = b0_;
   float b1 = b1_;
@@ -91,7 +93,7 @@ void BiquadFilterNode::getFrequencyResponse(
       continue;
     }
 
-    auto omega = -PI * frequencyArray[i];
+    auto omega = -PI * frequencyArray[i] / context_->getNyquistFrequency();
     auto z = std::complex<float>(cos(omega), sin(omega));
     auto response = (b0 + (b1 + b2 * z) * z) /
         (std::complex<float>(1, 0) + (a1 + a2 * z) * z);
@@ -101,13 +103,6 @@ void BiquadFilterNode::getFrequencyResponse(
   }
 }
 
-void BiquadFilterNode::resetCoefficients() {
-  x1_ = 0.0;
-  x2_ = 0.0;
-  y1_ = 0.0;
-  y2_ = 0.0;
-}
-
 void BiquadFilterNode::setNormalizedCoefficients(
     float b0,
     float b1,
@@ -163,7 +158,7 @@ void BiquadFilterNode::setHighpassCoefficients(float frequency, float Q) {
   float theta = PI * frequency;
   float alpha = std::sin(theta) / (2 * g);
   float cosW = std::cos(theta);
-  float beta = (1 - cosW) / 2;
+  float beta = (1 + cosW) / 2;
 
   setNormalizedCoefficients(
       beta, -2 * beta, beta, 1 + alpha, -2 * cosW, 1 - alpha);
@@ -313,13 +308,17 @@ void BiquadFilterNode::setAllpassCoefficients(float frequency, float Q) {
       1 - alpha, -2 * cosW, 1 + alpha, 1 + alpha, -2 * cosW, 1 - alpha);
 }
 
-void BiquadFilterNode::updateCoefficientsForFrame(
-    float frequency,
-    float detune,
-    float Q,
-    float gain) {
-  float normalizedFrequency = frequency / context_->getNyquistFrequency();
+void BiquadFilterNode::applyFilter() {
+  double currentTime = context_->getCurrentTime();
 
+  float frequency =
+      frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  float detune =
+      detuneParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  auto Q = QParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+  auto gain = gainParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
+
+  float normalizedFrequency = frequency / context_->getNyquistFrequency();
   if (detune != 0.0f) {
     normalizedFrequency *= std::pow(2.0f, detune / 1200.0f);
   }
@@ -357,47 +356,43 @@ void BiquadFilterNode::updateCoefficientsForFrame(
 void BiquadFilterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  double currentTime = context_->getCurrentTime();
-  auto frequencyValues =
-      frequencyParam_->processARateParam(framesToProcess, currentTime)
-          ->getChannel(0)
-          ->getData();
-  auto detuneValues =
-      detuneParam_->processARateParam(framesToProcess, currentTime)
-          ->getChannel(0)
-          ->getData();
-  auto qValues = QParam_->processARateParam(framesToProcess, currentTime)
-                     ->getChannel(0)
-                     ->getData();
-  auto gainValues = gainParam_->processARateParam(framesToProcess, currentTime)
-                        ->getChannel(0)
-                        ->getData();
-
-  for (int c = 0; c < processingBus->getNumberOfChannels(); c++) {
-    float x1 = x1_;
-    float x2 = x2_;
-    float y1 = y1_;
-    float y2 = y2_;
-
-    for (int i = 0; i < framesToProcess; i++) {
-      updateCoefficientsForFrame(
-          frequencyValues[i], detuneValues[i], qValues[i], gainValues[i]);
-
-      float input = (*processingBus->getChannel(c))[i];
-      float output = b0_ * input + b1_ * x1 + b2_ * x2 - a1_ * y1 - a2_ * y2;
-
-      (*processingBus->getChannel(c))[i] = output;
+  int numChannels = processingBus->getNumberOfChannels();
+
+  applyFilter();
+
+  // local copies for micro-optimization
+  float b0 = b0_;
+  float b1 = b1_;
+  float b2 = b2_;
+  float a1 = a1_;
+  float a2 = a2_;
+
+  float x1, x2, y1, y2;
+
+  for (int c = 0; c < numChannels; ++c) {
+    auto channelData = processingBus->getChannel(c)->getData();
+
+    x1 = x1_;
+    x2 = x2_;
+    y1 = y1_;
+    y2 = y2_;
+
+    for (int i = 0; i < framesToProcess; ++i) {
+      float input = channelData[i];
+      float output = b0 * input + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+
+      channelData[i] = output;
 
       x2 = x1;
       x1 = input;
       y2 = y1;
       y1 = output;
     }
-    x1_ = x1;
-    x2_ = x2;
-    y1_ = y1;
-    y2_ = y2;
   }
+  x1_ = x1;
+  x2_ = x2;
+  y1_ = y1;
+  y2_ = y2;
 }
 
 } // namespace audioapi

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

@@ -54,7 +54,7 @@ class BiquadFilterNode : public AudioNode {
   float b0_ = 1.0;
   float b1_ = 0;
   float b2_ = 0;
-  float a1_ = 1.0;
+  float a1_ = 0;
   float a2_ = 0;
 
   static BiquadFilterType fromString(const std::string &type) {
@@ -105,7 +105,6 @@ class BiquadFilterNode : public AudioNode {
     }
   }
 
-  void resetCoefficients();
   void setNormalizedCoefficients(
       float b0,
       float b1,
@@ -121,11 +120,7 @@ class BiquadFilterNode : public AudioNode {
   void setPeakingCoefficients(float frequency, float Q, float gain);
   void setNotchCoefficients(float frequency, float Q);
   void setAllpassCoefficients(float frequency, float Q);
-  void updateCoefficientsForFrame(
-      float frequency,
-      float detune,
-      float q,
-      float gain);
+  void applyFilter();
 };
 
 } // namespace audioapi

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

@@ -5,50 +5,40 @@
 namespace audioapi {
 
 AudioNodeDestructor::AudioNodeDestructor() {
-  isExiting_ = false;
-  nodesForDeconstruction_.reserve(10);
-  thread_ = std::thread(&AudioNodeDestructor::process, this);
+  isExiting_.store(false, std::memory_order_release);
+  auto [sender, receiver] = channels::spsc::channel<
+      std::shared_ptr<AudioNode>,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::ATOMIC_WAIT>(kChannelCapacity);
+  sender_ = std::move(sender);
+  workerHandle_ =
+      std::thread(&AudioNodeDestructor::process, this, std::move(receiver));
 }
 
 AudioNodeDestructor::~AudioNodeDestructor() {
-  isExiting_ = true;
+  isExiting_.store(true, std::memory_order_release);
 
-  cv_.notify_one(); // call process for the last time
-  if (thread_.joinable()) {
-    thread_.join();
+  // We need to send a nullptr to unblock the receiver
+  sender_.send(nullptr);
+  if (workerHandle_.joinable()) {
+    workerHandle_.join();
   }
 }
 
-void AudioNodeDestructor::tryCallWithLock(
-    const std::function<void()> &callback) {
-  if (auto lock = Locker::tryLock(mutex_)) {
-    callback();
-  }
-}
-
-void AudioNodeDestructor::addNodeForDeconstruction(
-    const std::shared_ptr<AudioNode> &node) {
-  // NOTE: this method must be called within `tryCallWithLock`
-  nodesForDeconstruction_.emplace_back(node);
+bool AudioNodeDestructor::tryAddNodeForDeconstruction(
+    std::shared_ptr<AudioNode> &&node) {
+  return sender_.try_send(std::move(node)) ==
+      channels::spsc::ResponseStatus::SUCCESS;
 }
 
-void AudioNodeDestructor::notify() {
-  cv_.notify_one();
-}
-
-void AudioNodeDestructor::process() {
-  std::unique_lock<std::mutex> lock(mutex_);
-  while (!isExiting_) {
-    cv_.wait(lock, [this] {
-      return isExiting_ || !nodesForDeconstruction_.empty();
-    });
-
-    if (isExiting_)
-      break;
-
-    if (!isExiting_ && !nodesForDeconstruction_.empty()) {
-      nodesForDeconstruction_.clear();
-    }
+void AudioNodeDestructor::process(
+    channels::spsc::Receiver<
+        std::shared_ptr<AudioNode>,
+        channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+        channels::spsc::WaitStrategy::ATOMIC_WAIT> &&receiver) {
+  auto rcv = std::move(receiver);
+  while (!isExiting_.load(std::memory_order_acquire)) {
+    rcv.receive();
   }
 }
 

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

@@ -1,34 +1,46 @@
 #pragma once
 
-#include <condition_variable>
-#include <mutex>
 #include <thread>
 #include <atomic>
-#include <functional>
 #include <vector>
 #include <memory>
+#include <audioapi/utils/SpscChannel.hpp>
 
 namespace audioapi {
 
 class AudioNode;
 
+#define AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS \
+  std::shared_ptr<AudioNode>, \
+  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+  channels::spsc::WaitStrategy::ATOMIC_WAIT
+
 class AudioNodeDestructor {
  public:
   AudioNodeDestructor();
   ~AudioNodeDestructor();
 
-  void tryCallWithLock(const std::function<void()> &callback);
-  void addNodeForDeconstruction(const std::shared_ptr<AudioNode> &node);
-  void notify();
+  /// @brief Adds a node to the deconstruction queue.
+  /// @param node The audio node to be deconstructed.
+  /// @return True if the node was successfully added, false otherwise.
+  /// @note node does NOT get moved out if it is not successfully added.
+  bool tryAddNodeForDeconstruction(std::shared_ptr<AudioNode> &&node);
 
  private:
-  mutable std::mutex mutex_;
-  std::thread thread_;
-  std::condition_variable cv_;
-  std::vector<std::shared_ptr<AudioNode>> nodesForDeconstruction_;
+  static constexpr size_t kChannelCapacity = 1024;
 
+  std::thread workerHandle_;
   std::atomic<bool> isExiting_;
 
-  void process();
+  channels::spsc::Sender<
+    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> sender_;
+
+  /// @brief Processes audio nodes for deconstruction.
+  /// @param receiver The receiver channel for incoming audio nodes.
+  void process(channels::spsc::Receiver<
+    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> &&receiver);
 };
+
+#undef AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS
+
 } // namespace audioapi

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

@@ -6,6 +6,80 @@
 
 namespace audioapi {
 
+AudioNodeManager::Event::Event(Event &&other) {
+  *this = std::move(other);
+}
+
+AudioNodeManager::Event &AudioNodeManager::Event::operator=(Event &&other) {
+  if (this != &other) {
+    // Clean up current resources
+    this->~Event();
+
+    // Move resources from the other event
+    type = other.type;
+    payloadType = other.payloadType;
+    switch (payloadType) {
+      case EventPayloadType::NODES:
+        payload.nodes.from = std::move(other.payload.nodes.from);
+        payload.nodes.to = std::move(other.payload.nodes.to);
+        break;
+      case EventPayloadType::PARAMS:
+        payload.params.from = std::move(other.payload.params.from);
+        payload.params.to = std::move(other.payload.params.to);
+        break;
+      case EventPayloadType::SOURCE_NODE:
+        payload.sourceNode = std::move(other.payload.sourceNode);
+        break;
+      case EventPayloadType::AUDIO_PARAM:
+        payload.audioParam = std::move(other.payload.audioParam);
+        break;
+      case EventPayloadType::NODE:
+        payload.node = std::move(other.payload.node);
+        break;
+
+      default:
+        break;
+    }
+  }
+  return *this;
+}
+
+AudioNodeManager::Event::~Event() {
+  switch (payloadType) {
+    case EventPayloadType::NODES:
+      payload.nodes.from.~shared_ptr();
+      payload.nodes.to.~shared_ptr();
+      break;
+    case EventPayloadType::PARAMS:
+      payload.params.from.~shared_ptr();
+      payload.params.to.~shared_ptr();
+      break;
+    case EventPayloadType::SOURCE_NODE:
+      payload.sourceNode.~shared_ptr();
+      break;
+    case EventPayloadType::AUDIO_PARAM:
+      payload.audioParam.~shared_ptr();
+      break;
+    case EventPayloadType::NODE:
+      payload.node.~shared_ptr();
+      break;
+  }
+}
+
+AudioNodeManager::AudioNodeManager() {
+  sourceNodes_.reserve(kInitialCapacity);
+  processingNodes_.reserve(kInitialCapacity);
+  audioParams_.reserve(kInitialCapacity);
+
+  auto channel_pair = channels::spsc::channel<
+      std::unique_ptr<Event>,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::BUSY_LOOP>(kChannelCapacity);
+
+  sender_ = std::move(channel_pair.first);
+  receiver_ = std::move(channel_pair.second);
+}
+
 AudioNodeManager::~AudioNodeManager() {
   cleanup();
 }
@@ -14,133 +88,185 @@ void AudioNodeManager::addPendingNodeConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioNode> &to,
     ConnectionType type) {
-  Locker lock(getGraphLock());
+  auto event = std::make_unique<Event>();
+  event->type = type;
+  event->payloadType = EventPayloadType::NODES;
+  event->payload.nodes.from = from;
+  event->payload.nodes.to = to;
 
-  audioNodesToConnect_.emplace_back(from, to, type);
+  sender_.send(std::move(event));
 }
 
 void AudioNodeManager::addPendingParamConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioParam> &to,
     ConnectionType type) {
-  Locker lock(getGraphLock());
+  auto event = std::make_unique<Event>();
+  event->type = type;
+  event->payloadType = EventPayloadType::PARAMS;
+  event->payload.params.from = from;
+  event->payload.params.to = to;
 
-  audioParamToConnect_.emplace_back(from, to, type);
+  sender_.send(std::move(event));
 }
 
 void AudioNodeManager::preProcessGraph() {
-  if (auto locker = Locker::tryLock(getGraphLock())) {
-    settlePendingConnections();
-    prepareNodesForDestruction();
-  }
-}
-
-std::mutex &AudioNodeManager::getGraphLock() {
-  return graphLock_;
+  settlePendingConnections();
+  prepareNodesForDestruction(sourceNodes_);
+  prepareNodesForDestruction(processingNodes_);
 }
 
 void AudioNodeManager::addProcessingNode(
     const std::shared_ptr<AudioNode> &node) {
-  Locker lock(getGraphLock());
-  processingNodes_.insert(node);
+  auto event = std::make_unique<Event>();
+  event->type = ConnectionType::ADD;
+  event->payloadType = EventPayloadType::NODE;
+  event->payload.node = node;
+
+  sender_.send(std::move(event));
 }
 
 void AudioNodeManager::addSourceNode(
     const std::shared_ptr<AudioScheduledSourceNode> &node) {
-  Locker lock(getGraphLock());
-  sourceNodes_.insert(node);
+  auto event = std::make_unique<Event>();
+  event->type = ConnectionType::ADD;
+  event->payloadType = EventPayloadType::SOURCE_NODE;
+  event->payload.sourceNode = node;
+
+  sender_.send(std::move(event));
 }
 
 void AudioNodeManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
-  Locker lock(getGraphLock());
-  audioParams_.insert(param);
+  auto event = std::make_unique<Event>();
+  event->type = ConnectionType::ADD;
+  event->payloadType = EventPayloadType::AUDIO_PARAM;
+  event->payload.audioParam = param;
+
+  sender_.send(std::move(event));
 }
 
 void AudioNodeManager::settlePendingConnections() {
-  for (int i = 0; i < audioNodesToConnect_.size(); ++i) {
-    auto &connection = audioNodesToConnect_[i];
-    std::shared_ptr<AudioNode> from = std::get<0>(connection);
-    std::shared_ptr<AudioNode> to = std::get<1>(connection);
-    ConnectionType type = std::get<2>(connection);
-
-    assert(from != nullptr);
-
-    if (type == ConnectionType::CONNECT) {
-      assert(to != nullptr);
-      from->connectNode(to);
-    } else if (type == ConnectionType::DISCONNECT) {
-      assert(to != nullptr);
-      from->disconnectNode(to);
-    } else {
-      for (auto it = from->outputNodes_.begin();
-           it != from->outputNodes_.end();) {
-        auto next = std::next(it);
-        from->disconnectNode(*it);
-        it = next;
-      }
+  std::unique_ptr<Event> value;
+  while (receiver_.try_receive(value) !=
+         channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
+    switch (value->type) {
+      case ConnectionType::CONNECT:
+        handleConnectEvent(std::move(value));
+        break;
+      case ConnectionType::DISCONNECT:
+        handleDisconnectEvent(std::move(value));
+        break;
+      case ConnectionType::DISCONNECT_ALL:
+        handleDisconnectAllEvent(std::move(value));
+        break;
+      case ConnectionType::ADD:
+        handleAddToDeconstructionEvent(std::move(value));
+        break;
     }
   }
+}
 
-  audioNodesToConnect_.clear();
-
-  for (auto it = audioParamToConnect_.begin(), end = audioParamToConnect_.end();
-       it != end;
-       ++it) {
-    std::shared_ptr<AudioNode> from = std::get<0>(*it);
-    std::shared_ptr<AudioParam> to = std::get<1>(*it);
-    ConnectionType type = std::get<2>(*it);
-
-    assert(from != nullptr);
-    assert(to != nullptr);
+void AudioNodeManager::handleConnectEvent(std::unique_ptr<Event> event) {
+  if (event->payloadType == EventPayloadType::NODES) {
+    event->payload.nodes.from->connectNode(event->payload.nodes.to);
+  } else if (event->payloadType == EventPayloadType::PARAMS) {
+    event->payload.params.from->connectParam(event->payload.params.to);
+  } else {
+    assert(false && "Invalid payload type for connect event");
+  }
+}
 
-    if (type == ConnectionType::CONNECT) {
-      from->connectParam(to);
-    } else {
-      from->disconnectParam(to);
-    }
+void AudioNodeManager::handleDisconnectEvent(std::unique_ptr<Event> event) {
+  if (event->payloadType == EventPayloadType::NODES) {
+    event->payload.nodes.from->disconnectNode(event->payload.nodes.to);
+  } else if (event->payloadType == EventPayloadType::PARAMS) {
+    event->payload.params.from->disconnectParam(event->payload.params.to);
+  } else {
+    assert(false && "Invalid payload type for disconnect event");
   }
+}
 
-  audioParamToConnect_.clear();
+void AudioNodeManager::handleDisconnectAllEvent(std::unique_ptr<Event> event) {
+  assert(event->payloadType == EventPayloadType::NODES);
+  for (auto it = event->payload.nodes.from->outputNodes_.begin();
+       it != event->payload.nodes.from->outputNodes_.end();) {
+    auto next = std::next(it);
+    event->payload.nodes.from->disconnectNode(*it);
+    it = next;
+  }
 }
 
-void AudioNodeManager::cleanupNode(const std::shared_ptr<AudioNode> &node) {
-  nodeDeconstructor_.addNodeForDeconstruction(node);
-  node->cleanup();
+void AudioNodeManager::handleAddToDeconstructionEvent(
+    std::unique_ptr<Event> event) {
+  switch (event->payloadType) {
+    case EventPayloadType::NODE:
+      processingNodes_.push_back(event->payload.node);
+      break;
+    case EventPayloadType::SOURCE_NODE:
+      sourceNodes_.push_back(event->payload.sourceNode);
+      break;
+    case EventPayloadType::AUDIO_PARAM:
+      audioParams_.push_back(event->payload.audioParam);
+      break;
+    default:
+      assert(false && "Unknown event payload type");
+  }
 }
 
-void AudioNodeManager::prepareNodesForDestruction() {
-  nodeDeconstructor_.tryCallWithLock([this]() {
-    auto sNodesIt = sourceNodes_.begin();
+template <typename U>
+void AudioNodeManager::prepareNodesForDestruction(
+    std::vector<std::shared_ptr<U>> &vec) {
+  if (vec.empty()) {
+    return;
+  }
+  /// An example of input-output
+  /// for simplicity we will be considering vector where each value represents
+  /// use_count() of an element vec = [1, 2, 1, 3, 1] our end result will be vec
+  /// = [2, 3, 1, 1, 1] After this operation all nodes with use_count() == 1
+  /// will be at the end and we will try to send them After sending, we will
+  /// only keep nodes with use_count() > 1 or which failed vec = [2, 3, failed,
+  /// sent, sent] // failed will be always before sents vec = [2, 3, failed] and
+  /// we resize
+  /// @note if there are no nodes with use_count() == 1 `begin` will be equal to
+  /// vec.size()
+  /// @note if all nodes have use_count() == 1 `begin` will be 0
 
-    while (sNodesIt != sourceNodes_.end()) {
-      // we don't want to destroy nodes that are still playing or will be
-      // playing
-      if (sNodesIt->use_count() == 1 &&
-          (sNodesIt->get()->isUnscheduled() || sNodesIt->get()->isFinished())) {
-        cleanupNode(*sNodesIt);
-        sNodesIt = sourceNodes_.erase(sNodesIt);
-      } else {
-        ++sNodesIt;
-      }
+  int begin = 0;
+  int end = vec.size() - 1; // can be -1 (edge case)
+
+  // Moves all nodes with use_count() == 1 to the end
+  // nodes in range [begin, vec.size()) should be deleted
+  // so new size of the vector will be `begin`
+  while (begin <= end) {
+    while (begin < end && vec[end].use_count() == 1) {
+      end--;
+    }
+    if (vec[begin].use_count() == 1) {
+      std::swap(vec[begin], vec[end]);
+      end--;
     }
+    begin++;
+  }
 
-    auto pNodesIt = processingNodes_.begin();
+  for (int i = begin; i < vec.size(); i++) {
+    if (vec[i])
+      vec[i]->cleanup();
 
-    while (pNodesIt != processingNodes_.end()) {
-      if (pNodesIt->use_count() == 1) {
-        cleanupNode(*pNodesIt);
-        pNodesIt = processingNodes_.erase(pNodesIt);
-      } else {
-        ++pNodesIt;
-      }
+    /// If we fail to add we can't safely remove the node from the vector
+    /// so we swap it and advance begin cursor
+    /// @note vec[i] does NOT get moved out if it is not successfully added.
+    if (!nodeDeconstructor_.tryAddNodeForDeconstruction(std::move(vec[i]))) {
+      std::swap(vec[i], vec[begin]);
+      begin++;
     }
-  });
-  nodeDeconstructor_.notify();
+  }
+  if (begin < vec.size()) {
+    // it does not realocate if newer size is < current size
+    vec.resize(begin);
+  }
 }
 
 void AudioNodeManager::cleanup() {
-  Locker lock(getGraphLock());
-
   for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end;
        ++it) {
     it->get()->cleanup();
@@ -154,6 +280,7 @@ void AudioNodeManager::cleanup() {
 
   sourceNodes_.clear();
   processingNodes_.clear();
+  audioParams_.clear();
 }
 
 } // namespace audioapi

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

@@ -6,7 +6,8 @@
 #include <mutex>
 #include <tuple>
 #include <vector>
-#include <unordered_set>
+
+#include <audioapi/utils/SpscChannel.hpp>
 
 namespace audioapi {
 
@@ -14,56 +15,119 @@ class AudioNode;
 class AudioScheduledSourceNode;
 class AudioParam;
 
+#define AUDIO_NODE_MANAGER_SPSC_OPTIONS \
+  std::unique_ptr<Event>, \
+  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+  channels::spsc::WaitStrategy::BUSY_LOOP
+
 class AudioNodeManager {
  public:
-  enum class ConnectionType { CONNECT, DISCONNECT, DISCONNECT_ALL };
-  AudioNodeManager() = default;
+  enum class ConnectionType { CONNECT, DISCONNECT, DISCONNECT_ALL, ADD };
+  typedef ConnectionType EventType; // for backwards compatibility
+  enum class EventPayloadType { NODES, PARAMS, SOURCE_NODE, AUDIO_PARAM, NODE };
+  union EventPayload {
+    struct {
+      std::shared_ptr<AudioNode> from;
+      std::shared_ptr<AudioNode> to;
+    } nodes;
+    struct {
+      std::shared_ptr<AudioNode> from;
+      std::shared_ptr<AudioParam> to;
+    } params;
+    std::shared_ptr<AudioScheduledSourceNode> sourceNode;
+    std::shared_ptr<AudioParam> audioParam;
+    std::shared_ptr<AudioNode> node;
+
+    // Default constructor that initializes the first member
+    EventPayload() : nodes{} {}
+
+    // Destructor - we'll handle cleanup explicitly in Event destructor
+    ~EventPayload() {}
+  };
+  struct Event {
+    EventType type;
+    EventPayloadType payloadType;
+    EventPayload payload;
+
+    Event(Event&& other);
+    Event& operator=(Event&& other);
+    Event() : type(ConnectionType::CONNECT), payloadType(EventPayloadType::NODES), payload() {}
+    ~Event();
+  };
+
+  AudioNodeManager();
   ~AudioNodeManager();
 
   void preProcessGraph();
 
+  /// @brief Adds a pending connection between two audio nodes.
+  /// @param from The source audio node.
+  /// @param to The destination audio node.
+  /// @param type The type of connection (connect/disconnect).
+  /// @note Should be only used from JavaScript/HostObjects thread
   void addPendingNodeConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioNode> &to,
       ConnectionType type);
 
+  /// @brief Adds a pending connection between an audio node and an audio parameter.
+  /// @param from The source audio node.
+  /// @param to The destination audio parameter.
+  /// @param type The type of connection (connect/disconnect).
+  /// @note Should be only used from JavaScript/HostObjects thread
   void addPendingParamConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioParam> &to,
     ConnectionType type);
 
+  /// @brief Adds a processing node to the manager.
+  /// @param node The processing node to add.
+  /// @note Should be only used from JavaScript/HostObjects thread
   void addProcessingNode(const std::shared_ptr<AudioNode> &node);
+
+  /// @brief Adds a source node to the manager.
+  /// @param node The source node to add.
+  /// @note Should be only used from JavaScript/HostObjects thread
   void addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node);
+
+  /// @brief Adds an audio parameter to the manager.
+  /// @param param The audio parameter to add.
+  /// @note Should be only used from JavaScript/HostObjects thread
   void addAudioParam(const std::shared_ptr<AudioParam> &param);
 
   void cleanup();
 
  private:
-  std::mutex graphLock_;
   AudioNodeDestructor nodeDeconstructor_;
 
-  // all nodes created in the context
-  std::unordered_set<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
-  std::unordered_set<std::shared_ptr<AudioNode>> processingNodes_;
-  std::unordered_set<std::shared_ptr<AudioParam>> audioParams_;
-
-  // connections to be settled
-  std::vector<std::tuple<
-      std::shared_ptr<AudioNode>,
-      std::shared_ptr<AudioNode>,
-      ConnectionType>>
-      audioNodesToConnect_;
-
-  std::vector<std::tuple<
-      std::shared_ptr<AudioNode>,
-      std::shared_ptr<AudioParam>,
-      ConnectionType>>
-      audioParamToConnect_;
-
-  std::mutex &getGraphLock();
+  /// @brief Initial capacity for various node types for deletion
+  /// @note Higher capacity decreases number of reallocations at runtime (can be easily adjusted to 128 if needed)
+  static constexpr size_t kInitialCapacity = 32;
+
+  /// @brief Initial capacity for event passing channel
+  /// @note High value reduces wait time for sender (JavaScript/HostObjects thread here)
+  static constexpr size_t kChannelCapacity = 1024;
+
+  std::vector<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
+  std::vector<std::shared_ptr<AudioNode>> processingNodes_;
+  std::vector<std::shared_ptr<AudioParam>> audioParams_;
+
+  channels::spsc::Receiver<
+    AUDIO_NODE_MANAGER_SPSC_OPTIONS> receiver_;
+
+  channels::spsc::Sender<
+    AUDIO_NODE_MANAGER_SPSC_OPTIONS> sender_;
+
   void settlePendingConnections();
-  void cleanupNode(const std::shared_ptr<AudioNode> &node);
-  void prepareNodesForDestruction();
+  void handleConnectEvent(std::unique_ptr<Event> event);
+  void handleDisconnectEvent(std::unique_ptr<Event> event);
+  void handleDisconnectAllEvent(std::unique_ptr<Event> event);
+  void handleAddToDeconstructionEvent(std::unique_ptr<Event> event);
+
+  template <typename U>
+  void prepareNodesForDestruction(std::vector<std::shared_ptr<U>> &vec);
 };
 
+#undef AUDIO_NODE_MANAGER_SPSC_OPTIONS
+
 } // namespace audioapi

package/common/cpp/audioapi/utils/Benchmark.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+/// Benchmarking utilities
+#include <chrono>
+#include <unordered_map>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+namespace audioapi::benchmarks {
+
+    /// @brief Gets the execution time of a function
+    /// @tparam Func The type of the function to benchmark
+    /// @param func The function to benchmark
+    /// @return The duration of the function execution in nanoseconds
+    /// @note This function is safe to use across threads
+    template <typename Func>
+    double getExecutionTime(Func&& func) {
+        auto start = std::chrono::high_resolution_clock::now();
+        std::forward<Func>(func)();
+        auto end = std::chrono::high_resolution_clock::now();
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
+    }
+
+    /// @brief Logs the average execution time of a function
+    /// @tparam Func The type of the function to benchmark
+    /// @param msg The message to log
+    /// @param func The function to benchmark
+    /// @return The duration of the function execution in nanoseconds
+    /// @note This function should not be used in production
+    /// @note This function is not thread-safe and should be used preferably once in a codebase when you need to measure performance
+    template <typename Func>
+    double logAvgExecutionTime(const std::string& msg, Func&& func) {
+        double duration = getExecutionTime(std::forward<Func>(func));
+
+        static std::unordered_map<std::string, double> durationsSum;
+        static std::unordered_map<std::string, int> durationsCount;
+
+        // Ensure initialization for first time
+        if (durationsSum.find(msg) == durationsSum.end()) {
+            durationsSum[msg] = 0.0;
+            durationsCount[msg] = 0;
+        }
+
+        durationsSum[msg] += duration;
+        durationsCount[msg]++;
+
+        long long avgDuration = static_cast<long long>(durationsSum[msg] / durationsCount[msg]);
+
+        #ifdef ANDROID
+            __android_log_print(ANDROID_LOG_INFO, "AudioAPI", "%s: %lld ns", msg.c_str(), avgDuration);
+        #else
+            printf("%s: %lld ns\n", msg.c_str(), avgDuration);
+        #endif
+        return duration;
+    }
+}

package/common/cpp/audioapi/utils/SpscChannel.hpp

@@ -0,0 +1,397 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <algorithm>
+#include <thread>
+#include <type_traits>
+
+
+namespace audioapi::channels::spsc {
+
+/// @brief Overflow strategy for sender when the channel is full
+enum class OverflowStrategy {
+    /// @brief Block and wait for space (default behavior)
+    WAIT_ON_FULL,
+
+    /// @brief Overwrite the oldest unread element
+    OVERWRITE_ON_FULL
+};
+
+/// @brief Wait strategy for receiver and sender when looping and trying
+enum class WaitStrategy {
+    /// @brief Busy loop waiting strategy
+    /// @note should be used when low latency is required and channel is not expected to wait
+    /// @note should be definitely used with OverflowStrategy::OVERWRITE_ON_FULL
+    /// @note it uses `asm volatile ("" ::: "memory")` to prevent harmful compiler optimizations
+    BUSY_LOOP,
+
+    /// @brief Yielding waiting strategy
+    /// @note should be used when low latency is not critical and channel is expected to wait
+    /// @note it uses std::this_thread::yield under the hood
+    YIELD,
+
+    /// @brief Atomic waiting strategy
+    /// @note should be used when low latency is required and channel is expected to wait for longer
+    /// @note it uses std::atomic_wait under the hood
+    ATOMIC_WAIT,
+};
+
+/// @brief Response status for channel operations
+enum class ResponseStatus {
+    SUCCESS,
+    CHANNEL_FULL,
+    CHANNEL_EMPTY,
+
+    /// @brief Indicates that the last value is being overwritten or read so try fails
+    /// @note This status is only returned if given channel supports OVERWRITE_ON_FULL strategy
+    SKIP_DUE_TO_OVERWRITE
+};
+
+template<typename T, OverflowStrategy Strategy, WaitStrategy Wait>
+class Sender;
+template<typename T, OverflowStrategy Strategy, WaitStrategy Wait>
+class Receiver;
+template<typename T, OverflowStrategy Strategy, WaitStrategy Wait>
+class InnerChannel;
+
+/// @brief Create a bounded single-producer, single-consumer channel
+/// @param capacity The minimum capacity of the channel, real capacity will be equal to the closest higher or equal power of two - 1. So for example, if capacity = 12 then channel will hold 15 elements.
+/// @tparam T The type of values sent through the channel
+/// @tparam Strategy The overflow strategy (default: WAIT_ON_FULL)
+/// @tparam Wait The wait strategy used when looping and trying to send or receive (default: BUSY_LOOP)
+/// @return A pair of sender and receiver for the channel
+template <typename T, OverflowStrategy Strategy = OverflowStrategy::WAIT_ON_FULL, WaitStrategy Wait = WaitStrategy::BUSY_LOOP>
+std::pair<Sender<T, Strategy, Wait>, Receiver<T, Strategy, Wait>> channel(size_t capacity) {
+    auto channel = std::make_shared<InnerChannel<T, Strategy, Wait>>(capacity);
+    return { Sender<T, Strategy, Wait>(channel), Receiver<T, Strategy, Wait>(channel) };
+}
+
+/// @brief Sender for a single-producer, single-consumer channel
+/// @tparam T The type of values sent through the channel
+/// @tparam Strategy The overflow strategy used by the channel
+/// It allows to send values to the channel. It is designed to be used only from one thread at a time.
+template <typename T, OverflowStrategy Strategy = OverflowStrategy::WAIT_ON_FULL, WaitStrategy Wait = WaitStrategy::BUSY_LOOP>
+class Sender {
+    /// Disallows sender creation outside of channel function
+    explicit Sender(std::shared_ptr<InnerChannel<T, Strategy, Wait>> chan) : channel_(chan) {}
+public:
+    /// @brief Default constructor
+    /// @note required to have sender as class member
+    Sender() = default;
+    Sender(const Sender&) = delete;
+    Sender& operator=(const Sender&) = delete;
+
+    Sender& operator=(Sender&& other) noexcept {
+        channel_ = std::move(other.channel_);
+        return *this;
+    } 
+    Sender(Sender&& other) noexcept : channel_(std::move(other.channel_)) {}
+
+    /// @brief Try to send a value to the channel
+    /// @param value The value to send
+    /// @return ResponseStatus indicating the result of the operation
+    /// @note this function is lock-free and wait-free
+    template<typename U>
+    ResponseStatus try_send(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
+        return channel_->try_send(std::forward<U>(value));
+    }
+
+    /// @brief Send a value to the channel (copy version)
+    /// @param value The value to send
+    /// @note This function is lock-free but may block if the channel is full
+    void send(const T& value) noexcept(std::is_nothrow_constructible_v<T, const T&>) {
+        while (channel_->try_send(value) != ResponseStatus::SUCCESS) {
+            if constexpr (Wait == WaitStrategy::YIELD) {
+                std::this_thread::yield(); // Yield to allow other threads to run
+            } else if constexpr (Wait == WaitStrategy::BUSY_LOOP) {
+                asm volatile ("" ::: "memory"); // Busy loop, just spin with compiler barrier
+            } else if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+                channel_->rcvCursor_.wait(channel_->rcvCursorCache_, std::memory_order_acquire);
+            }
+        }
+    }
+
+    /// @brief Send a value to the channel (move version)
+    /// @param value The value to send
+    /// @note This function is lock-free but may block if the channel is full.
+    void send(T&& value) noexcept(std::is_nothrow_constructible_v<T, T&&>) {
+        while (channel_->try_send(std::move(value)) != ResponseStatus::SUCCESS) {
+            if constexpr (Wait == WaitStrategy::YIELD) {
+                std::this_thread::yield(); // Yield to allow other threads to run
+            } else if constexpr (Wait == WaitStrategy::BUSY_LOOP) {
+                asm volatile ("" ::: "memory"); // Busy loop, just spin with compiler barrier
+            } else if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+                channel_->rcvCursor_.wait(channel_->rcvCursorCache_, std::memory_order_acquire);
+            }
+        }
+    }
+
+private:
+    std::shared_ptr<InnerChannel<T, Strategy, Wait>> channel_;
+
+    friend std::pair<Sender<T, Strategy, Wait>, Receiver<T, Strategy, Wait>> channel<T, Strategy, Wait>(size_t capacity);
+};
+
+/// @brief Receiver for a single-producer, single-consumer channel
+/// @tparam T The type of values sent through the channel
+/// @tparam Strategy The overflow strategy used by the channel
+/// It allows to receive values from the channel. It is designed to be used only from one thread at a time.
+template <typename T, OverflowStrategy Strategy = OverflowStrategy::WAIT_ON_FULL, WaitStrategy Wait = WaitStrategy::BUSY_LOOP>
+class Receiver {
+    /// Disallows receiver creation outside of channel function
+    explicit Receiver(std::shared_ptr<InnerChannel<T, Strategy, Wait>> chan) : channel_(chan) {}
+public:
+    /// @brief Default constructor
+    /// @note required to have receiver as class member
+    Receiver() = default;
+    Receiver(const Receiver&) = delete;
+    Receiver& operator=(const Receiver&) = delete;
+
+    Receiver& operator=(Receiver&& other) noexcept {
+        channel_ = std::move(other.channel_);
+        return *this;
+    }
+    Receiver(Receiver&& other) noexcept : channel_(std::move(other.channel_)) {}
+
+    /// @brief Try to receive a value from the channel
+    /// @param value The received value
+    /// @return ResponseStatus indicating the result of the operation
+    /// @note This function is lock-free and wait-free.
+    ResponseStatus try_receive(T& value) noexcept(std::is_nothrow_move_assignable_v<T> && std::is_nothrow_destructible_v<T>) {
+        return channel_->try_receive(value);
+    }
+
+    /// @brief Receive a value from the channel
+    /// @return The received value
+    /// @note This function is lock-free but may block if the channel is empty.
+    T receive() noexcept(std::is_nothrow_default_constructible_v<T> && std::is_nothrow_move_assignable_v<T> && std::is_nothrow_destructible_v<T>) {
+        T value;
+        while (channel_->try_receive(value) != ResponseStatus::SUCCESS) {
+            if constexpr (Wait == WaitStrategy::YIELD) {
+                std::this_thread::yield(); // Yield to allow other threads to run
+            } else if constexpr (Wait == WaitStrategy::BUSY_LOOP) {
+                asm volatile ("" ::: "memory"); // Busy loop, just spin with compiler barrier
+            } else if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+                channel_->sendCursor_.wait(channel_->sendCursorCache_, std::memory_order_acquire);
+            }
+        }
+        return value;
+    }
+
+private:
+    std::shared_ptr<InnerChannel<T, Strategy, Wait>> channel_;
+
+    friend std::pair<Sender<T, Strategy, Wait>, Receiver<T, Strategy, Wait>> channel<T, Strategy, Wait>(size_t capacity);
+};
+
+/// @brief Inner channel implementation for the SPSC queue
+/// @tparam T The type of values sent through the channel
+/// @tparam Strategy The overflow strategy to use when the channel is full
+/// @tparam Wait The wait strategy used for internal operations
+/// This class is not intended to be used directly by users.
+/// @note this class is not thread safe and should be wrapped in std::shared_ptr
+template <typename T, OverflowStrategy Strategy = OverflowStrategy::WAIT_ON_FULL, WaitStrategy Wait = WaitStrategy::BUSY_LOOP>
+class InnerChannel {
+public:
+    /// @brief Construct a channel with a given capacity
+    /// @param capacity The minimum capacity of the channel, for performance it will be allocated with next power of 2
+    /// Uses raw memory allocation so the T type is not required to provide default constructors
+    /// alignment is the key for performance it makes sure that objects are properly aligned in memory for faster access
+    explicit InnerChannel(size_t capacity) : 
+        capacity_(next_power_of_2(capacity)),
+        capacity_mask_(capacity_ - 1),
+        buffer_(static_cast<T*>(operator new[](capacity_ * sizeof(T), std::align_val_t{alignof(T)}))) {
+        
+        // Initialize cache values for better performance
+        rcvCursorCache_ = 0;
+        sendCursorCache_ = 0;
+        
+        // Initialize reader state for overwrite strategy
+        if constexpr (Strategy == OverflowStrategy::OVERWRITE_ON_FULL) {
+            oldestOccupied_.store(false, std::memory_order_relaxed);
+        }
+    }
+    
+    /// This should not be called if there is existing handle to reader or writer
+    ~InnerChannel() {
+        size_t sendCursor = sendCursor_.load(std::memory_order_seq_cst);
+        size_t rcvCursor = rcvCursor_.load(std::memory_order_seq_cst);
+
+        // Call destructors for all elements in the buffer
+        size_t i = rcvCursor;
+        while (i != sendCursor) {
+            buffer_[i].~T();
+            i = next_index(i);
+        }
+
+        // Deallocate the buffer
+        ::operator delete[](buffer_);
+    }
+
+    /// @brief Try to send a value to the channel
+    /// @param value The value to send
+    /// @return ResponseStatus indicating the result of the operation
+    /// @note This function is lock-free and wait-free
+    template<typename U>
+    ResponseStatus try_send(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
+        if constexpr (Strategy == OverflowStrategy::WAIT_ON_FULL) {
+            return try_send_wait_on_full(std::forward<U>(value));
+        } else {
+            return try_send_overwrite_on_full(std::forward<U>(value));
+        }
+    }    
+    
+    /// @brief Try to receive a value from the channel
+    /// @param value The variable to store the received value
+    /// @return ResponseStatus indicating the result of the operation
+    /// @note This function is lock-free and wait-free
+    ResponseStatus try_receive(T& value) noexcept(std::is_nothrow_move_assignable_v<T> && std::is_nothrow_destructible_v<T>) {
+        if constexpr (Strategy == OverflowStrategy::OVERWRITE_ON_FULL) {
+            // Set reader active flag to prevent overwrites during read
+            bool isOccupied = oldestOccupied_.exchange(true, std::memory_order_acq_rel);
+            if (isOccupied) {
+                // It means that the oldest element is being overwritten so we cannot read
+                return ResponseStatus::SKIP_DUE_TO_OVERWRITE;
+            }
+        }
+        
+        size_t rcvCursor = rcvCursor_.load(std::memory_order_relaxed); // only receiver thread reads this
+
+        if (rcvCursor == sendCursorCache_) {
+            // Refresh cache
+            sendCursorCache_ = sendCursor_.load(std::memory_order_acquire);
+            if (rcvCursor == sendCursorCache_) {
+                if constexpr (Strategy == OverflowStrategy::OVERWRITE_ON_FULL) {
+                    oldestOccupied_.store(false, std::memory_order_release);
+                }
+
+                return ResponseStatus::CHANNEL_EMPTY;
+            }
+        }
+
+        value = std::move(buffer_[rcvCursor]);
+        buffer_[rcvCursor].~T(); // Call destructor
+
+        rcvCursor_.store(next_index(rcvCursor), std::memory_order_release);
+        
+        if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+            rcvCursor_.notify_one(); // Notify sender that a value has been received
+        }
+        
+        if constexpr (Strategy == OverflowStrategy::OVERWRITE_ON_FULL) {
+            oldestOccupied_.store(false, std::memory_order_release);
+        }
+
+        return ResponseStatus::SUCCESS;
+    }
+
+private:
+    /// @brief Try to send with WAIT_ON_FULL strategy (original behavior)
+    template<typename U>
+    inline ResponseStatus try_send_wait_on_full(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
+        size_t sendCursor = sendCursor_.load(std::memory_order_relaxed); // only sender thread writes this
+        size_t next_sendCursor = next_index(sendCursor);
+
+        if (next_sendCursor == rcvCursorCache_) {
+            // Refresh the cache
+            rcvCursorCache_ = rcvCursor_.load(std::memory_order_acquire);
+            if (next_sendCursor == rcvCursorCache_) return ResponseStatus::CHANNEL_FULL;
+        }
+
+        // Construct the new element in place
+        new (&buffer_[sendCursor]) T(std::forward<U>(value));
+        
+        sendCursor_.store(next_sendCursor, std::memory_order_release);
+
+        if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+            sendCursor_.notify_one(); // Notify receiver that a value has been sent
+        }
+
+        return ResponseStatus::SUCCESS;
+    }
+    
+    /// @brief Try to send with OVERWRITE_ON_FULL strategy
+    template<typename U>
+    inline ResponseStatus try_send_overwrite_on_full(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
+        size_t sendCursor = sendCursor_.load(std::memory_order_relaxed); // only sender thread writes this
+        size_t next_sendCursor = next_index(sendCursor);
+
+        if (next_sendCursor == rcvCursorCache_) {
+            // Refresh the cache
+            rcvCursorCache_ = rcvCursor_.load(std::memory_order_acquire);
+            if (next_sendCursor == rcvCursorCache_) {
+                bool isOldestOccupied = oldestOccupied_.exchange(true, std::memory_order_acq_rel);
+                if (isOldestOccupied) {
+                    // If the oldest element is occupied, we cannot overwrite
+                    return ResponseStatus::SKIP_DUE_TO_OVERWRITE;
+                }
+
+                size_t newestRcvCursor = rcvCursor_.load(std::memory_order_acquire);
+
+                /// If the receiver did not advance, we can safely advance the cursor
+                if (rcvCursorCache_ == newestRcvCursor) {
+                    rcvCursorCache_ = next_index(newestRcvCursor);
+                    rcvCursor_.store(rcvCursorCache_, std::memory_order_release);
+                } else {
+                    rcvCursorCache_ = newestRcvCursor;
+                }
+                
+                oldestOccupied_.store(false, std::memory_order_release);
+            }
+        }
+
+        // Normal case: buffer not full
+        new (&buffer_[sendCursor]) T(std::forward<U>(value));
+        sendCursor_.store(next_sendCursor, std::memory_order_release);
+        
+        if constexpr (Wait == WaitStrategy::ATOMIC_WAIT) {
+            sendCursor_.notify_one(); // Notify receiver that a value has been sent
+        }
+        
+        return ResponseStatus::SUCCESS;
+    }
+
+    /// @brief Calculate the next power of 2 greater than or equal to n
+    /// @param n The input value
+    /// @return The next power of 2
+    static constexpr size_t next_power_of_2(const size_t n) noexcept {
+        if (n <= 1) return 1;
+        
+        // Use bit manipulation for efficiency
+        size_t power = 1;
+        while (power < n) {
+            power <<= 1;
+        }
+        return power;
+    }
+
+    /// @brief Get the next index in a circular buffer
+    /// @param val The current index
+    /// @return The next index
+    /// @note it might not be used for performance but it is a good reference
+    inline size_t next_index(const size_t val) const noexcept {
+        return (val + 1) & capacity_mask_;
+    }
+
+    const size_t capacity_;
+    const size_t capacity_mask_; // mask for bitwise next_index
+    T* buffer_;
+
+    /// Producer-side data (accessed by sender thread)
+    alignas(64) std::atomic<size_t> sendCursor_{0};
+    alignas(64) size_t rcvCursorCache_{0}; // reduces cache coherency
+
+    /// Consumer-side data (accessed by receiver thread)  
+    alignas(64) std::atomic<size_t> rcvCursor_{0};
+    alignas(64) size_t sendCursorCache_{0}; // reduces cache coherency
+
+    /// Flag indicating if the oldest element is occupied
+    alignas(64) std::atomic<bool> oldestOccupied_{false};
+
+    friend class Sender<T, Strategy, Wait>;
+    friend class Receiver<T, Strategy, Wait>;
+};
+
+
+} // namespace channels::spsc

package/common/cpp/test/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.14)
 project(rnaudioapi_test)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(ROOT ${CMAKE_SOURCE_DIR}/../../../../..)
 set(REACT_NATIVE_DIR "${ROOT}/node_modules/react-native")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.7.2-nightly-31b46b8-20250820",
+  "version": "0.7.2-nightly-c06331b-20250821",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"