react-native-audio-api 0.8.1-nightly-2c9c6a6-20250903 → 0.8.1-nightly-da0ddc8-20250904

package/common/cpp/audioapi/core/AudioParam.h

@@ -1,16 +1,17 @@
 #pragma once
 
-#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParamEventQueue.h>
 
-#include <deque>
+#include <cstddef>
+#include <utility>
 #include <memory>
 #include <vector>
 #include <unordered_set>
-#include <cstddef>
-#include <mutex>
+#include <audioapi/utils/CrossThreadEventScheduler.hpp>
 
 namespace audioapi {
 
@@ -18,52 +19,128 @@ class AudioParam {
  public:
   explicit AudioParam(float defaultValue, float minValue, float maxValue, BaseAudioContext *context);
 
-  [[nodiscard]] float getValue() const;
-  float getValueAtTime(double time);
-  [[nodiscard]] float getDefaultValue() const;
-  [[nodiscard]] float getMinValue() const;
-  [[nodiscard]] float getMaxValue() const;
+  /// JS-Thread only methods
+  /// These methods are called only from HostObjects invoked on the JS thread.
+
+  // JS-Thread only
+  [[nodiscard]] inline float getValue() const noexcept {
+    return value_;
+  }
+
+  // JS-Thread only
+  [[nodiscard]] inline float getDefaultValue() const noexcept {
+    return defaultValue_;
+  }
+
+  // JS-Thread only
+  [[nodiscard]] inline float getMinValue() const noexcept {
+    return minValue_;
+  }
 
-  void setValue(float value);
+  // JS-Thread only
+  [[nodiscard]] inline float getMaxValue() const noexcept {
+    return maxValue_;
+  }
 
+  // JS-Thread only
+  inline void setValue(float value) {
+    value_ = std::clamp(value, minValue_, maxValue_);
+  }
+
+  // JS-Thread only
   void setValueAtTime(float value, double startTime);
+
+  // JS-Thread only
   void linearRampToValueAtTime(float value, double endTime);
+
+  // JS-Thread only
   void exponentialRampToValueAtTime(float value, double endTime);
+
+  // JS-Thread only
   void setTargetAtTime(float target, double startTime, double timeConstant);
+
+  // JS-Thread only
   void setValueCurveAtTime(
-      const float *values,
+      std::shared_ptr<std::vector<float>> values,
       size_t length,
       double startTime,
       double duration);
+
+  // JS-Thread only
   void cancelScheduledValues(double cancelTime);
+
+  // JS-Thread only
   void cancelAndHoldAtTime(double cancelTime);
+
+
+  /// Audio-Thread only methods
+  /// These methods are called only from the Audio rendering thread.
+
+  // Audio-Thread only (indirectly through AudioNode::connectParam by AudioNodeManager)
   void addInputNode(AudioNode* node);
+
+  // Audio-Thread only (indirectly through AudioNode::disconnectParam by AudioNodeManager)
   void removeInputNode(AudioNode* node);
+
+  // Audio-Thread only
   std::shared_ptr<AudioBus> processARateParam(int framesToProcess, double time);
+
+  // Audio-Thread only
   float processKRateParam(int framesToProcess, double time);
 
  private:
+  // Core parameter state
+  BaseAudioContext *context_;
   float value_;
   float defaultValue_;
   float minValue_;
   float maxValue_;
-  BaseAudioContext *context_;
-  std::deque<ParamChangeEvent> eventsQueue_;
-  std::unordered_set<AudioNode *> inputNodes_;
-  std::shared_ptr<AudioBus> audioBus_;
-  std::mutex queueLock_;
 
+  AudioParamEventQueue eventsQueue_;
+  CrossThreadEventScheduler<AudioParam> eventScheduler_;
+
+  // Current automation state (cached for performance)
   double startTime_;
   double endTime_;
   float startValue_;
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
-  std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
 
-  std::mutex &getQueueLock();
-  double getQueueEndTime();
-  float getQueueEndValue();
-  void updateQueue(ParamChangeEvent &event);
+  // Input modulation system
+  std::vector<AudioNode *> inputNodes_;
+  std::shared_ptr<AudioBus> audioBus_;
+  std::vector<std::shared_ptr<AudioBus>> inputBuses_;
+
+  /// @brief Get the end time of the parameter queue.
+  /// @return The end time of the parameter queue or last endTime_ if queue is empty.
+  inline double getQueueEndTime() const noexcept {
+    if (eventsQueue_.isEmpty()) {
+      return endTime_;
+    }
+    return eventsQueue_.back().getEndTime();
+  }
+
+  /// @brief Get the end value of the parameter queue.
+  /// @return The end value of the parameter queue or last endValue_ if queue is empty.
+  inline float getQueueEndValue() const noexcept {
+    if (eventsQueue_.isEmpty()) {
+      return endValue_;
+    }
+    return eventsQueue_.back().getEndValue();
+  }
+
+  /// @brief Process all scheduled events.
+  inline void processScheduledEvents() noexcept(noexcept(eventScheduler_.processAllEvents(*this))) {
+    eventScheduler_.processAllEvents(*this);
+  }
+
+  /// @brief Update the parameter queue with a new event.
+  /// @param event The new event to add to the queue.
+  /// @note Handles connecting start value of the new event to the end value of the previous event.
+  inline void updateQueue(ParamChangeEvent &&event) {
+    eventsQueue_.pushBack(std::move(event));
+  }
+  float getValueAtTime(double time);
   void processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
   void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
   std::shared_ptr<AudioBus> calculateInputs(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess);

package/common/cpp/audioapi/core/AudioParamEventQueue.cpp

@@ -0,0 +1,65 @@
+#include <audioapi/core/AudioParamEventQueue.h>
+
+namespace audioapi {
+
+AudioParamEventQueue::AudioParamEventQueue() : eventQueue_() {}
+
+void AudioParamEventQueue::pushBack(ParamChangeEvent &&event) {
+  if (eventQueue_.isEmpty()) {
+    eventQueue_.pushBack(std::move(event));
+    return;
+  }
+  auto &prev = eventQueue_.peekBackMut();
+  if (prev.getType() == ParamChangeEventType::SET_TARGET) {
+    prev.setEndTime(event.getStartTime());
+    // Calculate what the SET_TARGET value would be at the new event's start
+    // time
+    prev.setEndValue(prev.getCalculateValue()(
+        prev.getStartTime(),
+        prev.getEndTime(),
+        prev.getStartValue(),
+        prev.getEndValue(),
+        event.getStartTime()));
+  }
+  event.setStartValue(prev.getEndValue());
+  eventQueue_.pushBack(std::move(event));
+}
+
+bool AudioParamEventQueue::popFront(ParamChangeEvent &event) {
+  return eventQueue_.popFront(event);
+}
+
+void AudioParamEventQueue::cancelScheduledValues(double cancelTime) {
+  while (!eventQueue_.isEmpty()) {
+    auto &front = eventQueue_.peekBack();
+    if (front.getEndTime() < cancelTime) {
+      break;
+    }
+    if (front.getStartTime() >= cancelTime ||
+        front.getType() == ParamChangeEventType::SET_VALUE_CURVE) {
+      eventQueue_.popBack();
+    }
+  }
+}
+
+void AudioParamEventQueue::cancelAndHoldAtTime(
+    double cancelTime,
+    double &endTimeCache) {
+  while (!eventQueue_.isEmpty()) {
+    auto &front = eventQueue_.peekBack();
+    if (front.getEndTime() < cancelTime || front.getStartTime() <= cancelTime) {
+      break;
+    }
+    eventQueue_.popBack();
+  }
+
+  if (eventQueue_.isEmpty()) {
+    endTimeCache = cancelTime;
+    return;
+  }
+
+  auto &back = eventQueue_.peekBackMut();
+  back.setEndTime(std::min(cancelTime, back.getEndTime()));
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/AudioParamEventQueue.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <audioapi/core/utils/ParamChangeEvent.h>
+#include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/utils/RingBiDirectionalBuffer.hpp>
+
+namespace audioapi {
+
+/// @brief A queue for managing audio parameter change events.
+/// @note The invariant of the queue is that its internal buffer always contains non-overlapping events.
+class AudioParamEventQueue {
+ public:
+  /// @brief Constructor for AudioParamEventQueue.
+  /// @note Capacity must be valid power of two.
+  explicit AudioParamEventQueue();
+
+  /// @brief Push a new event to the back of the queue.
+  /// @note Handles connecting the start value of the new event to the end value of the last event in the queue.
+  void pushBack(ParamChangeEvent&& event);
+
+  /// @brief Pop the front event from the queue.
+  /// @return The front event in the queue.
+  bool popFront(ParamChangeEvent &event);
+
+  /// @brief Cancel scheduled parameter changes at or after the given time.
+  /// @param cancelTime The time at which to cancel scheduled changes.
+  void cancelScheduledValues(double cancelTime);
+
+  /// @brief Cancel scheduled parameter changes and hold the current value at the given time.
+  /// @param cancelTime The time at which to cancel scheduled changes.
+  void cancelAndHoldAtTime(double cancelTime, double& endTimeCache);
+
+  /// @brief Get the first event in the queue.
+  /// @return The first event in the queue.
+  inline const ParamChangeEvent& front() const noexcept {
+    return eventQueue_.peekFront();
+  }
+
+  /// @brief Get the last event in the queue.
+  /// @return The last event in the queue.
+  inline const ParamChangeEvent& back() const noexcept {
+    return eventQueue_.peekBack();
+  }
+
+  /// @brief Check if the event queue is empty.
+  /// @return True if the queue is empty, false otherwise.
+  inline bool isEmpty() const noexcept {
+    return eventQueue_.isEmpty();
+  }
+
+  /// @brief Check if the event queue is full.
+  /// @return True if the queue is full, false otherwise.
+  inline bool isFull() const noexcept {
+    return eventQueue_.isFull();
+  }
+
+ private:
+  /// @brief The queue of parameter change events.
+  /// @note INVARIANT it always holds non-overlapping events sorted by start time.
+  RingBiDirectionalBuffer<ParamChangeEvent, 32> eventQueue_;
+};
+
+} // namespace audioapi

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

@@ -1,10 +1,11 @@
 /*
- * This file links to the FFmpeg library, which is licensed under the
- * GNU Lesser General Public License (LGPL) version 2.1 or later.
+ * This file dynamically links to the FFmpeg library, which is licensed under
+ * the GNU Lesser General Public License (LGPL) version 2.1 or later.
  *
- * Our own code in this file is licensed under the MIT License, but note
- * that linking with FFmpeg means you must comply with the terms of the
- * LGPL for FFmpeg itself.
+ * Our own code in this file is licensed under the MIT License and dynamic
+ * linking allows you to use this code without your entire project being subject
+ * to the terms of the LGPL. However, note that if you link statically to
+ * FFmpeg, you must comply with the terms of the LGPL for FFmpeg itself.
  */
 
 #include <audioapi/core/BaseAudioContext.h>

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

@@ -1,10 +1,11 @@
 /*
- * This file links to the FFmpeg library, which is licensed under the
+ * This file dynamically links to the FFmpeg library, which is licensed under the
  * GNU Lesser General Public License (LGPL) version 2.1 or later.
  *
- * Our own code in this file is licensed under the MIT License, but note
- * that linking with FFmpeg means you must comply with the terms of the
- * LGPL for FFmpeg itself.
+ * Our own code in this file is licensed under the MIT License and dynamic linking
+ * allows you to use this code without your entire project being subject to the
+ * terms of the LGPL. However, note that if you link statically to FFmpeg, you must
+ * comply with the terms of the LGPL for FFmpeg itself.
  */
 
 #pragma once

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

@@ -7,50 +7,13 @@ ParamChangeEvent::ParamChangeEvent(
     double endTime,
     float startValue,
     float endValue,
-    std::function<float(double, double, float, float, double)> calculateValue,
+    std::function<float(double, double, float, float, double)> &&calculateValue,
     ParamChangeEventType type)
     : startTime_(startTime),
       endTime_(endTime),
+      calculateValue_(std::move(calculateValue)),
       startValue_(startValue),
       endValue_(endValue),
-      calculateValue_(std::move(calculateValue)),
       type_(type) {}
 
-double ParamChangeEvent::getEndTime() const {
-  return endTime_;
-}
-
-double ParamChangeEvent::getStartTime() const {
-  return startTime_;
-}
-
-float ParamChangeEvent::getEndValue() const {
-  return endValue_;
-}
-
-float ParamChangeEvent::getStartValue() const {
-  return startValue_;
-}
-
-std::function<float(double, double, float, float, double)>
-ParamChangeEvent::getCalculateValue() const {
-  return calculateValue_;
-}
-
-ParamChangeEventType ParamChangeEvent::getType() const {
-  return type_;
-}
-
-void ParamChangeEvent::setEndTime(double endTime) {
-  endTime_ = endTime;
-}
-
-void ParamChangeEvent::setStartValue(float startValue) {
-  startValue_ = startValue;
-}
-
-void ParamChangeEvent::setEndValue(float endValue) {
-  endValue_ = endValue;
-}
-
 } // namespace audioapi

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

@@ -10,32 +10,73 @@ namespace audioapi {
 
 class ParamChangeEvent {
  public:
+  ParamChangeEvent() = default;
   explicit ParamChangeEvent(
       double startTime,
       double endTime,
       float startValue,
       float endValue,
-      std::function<float(double, double, float, float, double)> calculateValue,
+      std::function<float(double, double, float, float, double)> &&calculateValue,
       ParamChangeEventType type);
 
-  [[nodiscard]] double getEndTime() const;
-  [[nodiscard]] double getStartTime() const;
-  [[nodiscard]] float getEndValue() const;
-  [[nodiscard]] float getStartValue() const;
-  [[nodiscard]] std::function<float(double, double, float, float, double)>
-  getCalculateValue() const;
-  [[nodiscard]] ParamChangeEventType getType() const;
+  ParamChangeEvent(const ParamChangeEvent &other) = delete;
+  ParamChangeEvent& operator=(const ParamChangeEvent &other) = delete;
 
-  void setEndTime(double endTime);
-  void setStartValue(float startValue);
-  void setEndValue(float endValue);
+  explicit ParamChangeEvent(ParamChangeEvent &&other) noexcept
+    : startTime_(other.startTime_),
+      endTime_(other.endTime_),
+      calculateValue_(std::move(other.calculateValue_)),
+      startValue_(other.startValue_),
+      endValue_(other.endValue_),
+      type_(other.type_) {}
+  ParamChangeEvent& operator=(ParamChangeEvent &&other) noexcept {
+    if (this != &other) {
+      startTime_ = other.startTime_;
+      endTime_ = other.endTime_;
+      calculateValue_ = std::move(other.calculateValue_);
+      startValue_ = other.startValue_;
+      endValue_ = other.endValue_;
+      type_ = other.type_;
+    }
+    return *this;
+  }
+
+  [[nodiscard]] inline double getEndTime() const noexcept {
+    return endTime_;
+  }
+  [[nodiscard]] inline double getStartTime() const noexcept {
+    return startTime_;
+  }
+  [[nodiscard]] inline float getEndValue() const noexcept {
+    return endValue_;
+  }
+  [[nodiscard]] inline float getStartValue() const noexcept {
+    return startValue_;
+  }
+  [[nodiscard]] inline const std::function<float(double, double, float, float, double)>&
+  getCalculateValue() const noexcept {
+    return calculateValue_;
+  }
+  [[nodiscard]] inline ParamChangeEventType getType() const noexcept {
+    return type_;
+  }
+
+  inline void setEndTime(double endTime) noexcept {
+    endTime_ = endTime;
+  }
+  inline void setStartValue(float startValue) noexcept {
+    startValue_ = startValue;
+  }
+  inline void setEndValue(float endValue) noexcept {
+    endValue_ = endValue;
+  }
 
  private:
   double startTime_;
   double endTime_;
+  std::function<float(double, double, float, float, double)> calculateValue_;
   float startValue_;
   float endValue_;
-  std::function<float(double, double, float, float, double)> calculateValue_;
   ParamChangeEventType type_;
 };
 

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -1,3 +1,13 @@
+/*
+ * This file dynamically links to the FFmpeg library, which is licensed under the
+ * GNU Lesser General Public License (LGPL) version 2.1 or later.
+ *
+ * Our own code in this file is licensed under the MIT License and dynamic linking
+ * allows you to use this code without your entire project being subject to the
+ * terms of the LGPL. However, note that if you link statically to FFmpeg, you must
+ * comply with the terms of the LGPL for FFmpeg itself.
+ */
+
 #include "FFmpegDecoding.h"
 
 namespace audioapi::ffmpegdecoding {

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h

@@ -1,3 +1,13 @@
+/*
+ * This file dynamically links to the FFmpeg library, which is licensed under the
+ * GNU Lesser General Public License (LGPL) version 2.1 or later.
+ *
+ * Our own code in this file is licensed under the MIT License and dynamic linking
+ * allows you to use this code without your entire project being subject to the
+ * terms of the LGPL. However, note that if you link statically to FFmpeg, you must
+ * comply with the terms of the LGPL for FFmpeg itself.
+ */
+
 #include <audioapi/utils/AudioBus.h>
 #include <iostream>
 #include <memory>

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <audioapi/utils/SpscChannel.hpp>
+
+#include <type_traits>
+#include <functional>
+
+namespace audioapi {
+using namespace channels::spsc;
+
+/// @brief A scheduler for cross-thread events.
+/// @tparam T The type of data to be processed by the events.
+////
+/// It lets to schedule an event that should be performed on a different thread.
+///
+/// - T1 - JS thread
+///
+/// - T2 - Audio thread
+///
+/// Audio thread is looping every render quantum (~128 frames).
+/// We want to modify some parameter on the resource used by audio thread.
+/// We can schedule function on JS-Thread and process it before processing frames.
+/// In this setup no locking happens and modifications can be seen by Audio thread.
+/// @note it is intended to be used for two threads one which schedules events and one which processes them
+/// @note it is not safe to be copied across two threads use std::shared_ptr if you need to share data
+template <typename T>
+class CrossThreadEventScheduler {
+ public:
+  explicit CrossThreadEventScheduler(size_t capacity) {
+    auto [sender, receiver] = channel<std::function<void(T&)>>(capacity);
+    eventSender_ = std::move(sender);
+    eventReceiver_ = std::move(receiver);
+  }
+  CrossThreadEventScheduler(const CrossThreadEventScheduler&) = delete;
+  CrossThreadEventScheduler& operator=(const CrossThreadEventScheduler&) = delete;
+
+  /// @brief Schedules an event to be processed on the audio thread.
+  /// @param event The event to schedule.
+  /// @return True if the event was successfully scheduled, false if the queue is full.
+  bool scheduleEvent(std::function<void(T&)> &&event) noexcept(noexcept(eventSender_.try_send(std::move(event)))) {
+    return eventSender_.try_send(std::move(event)) == ResponseStatus::SUCCESS;
+  }
+
+  /// @brief Processes all scheduled events.
+  /// @param data The data to pass to each event.
+  void processAllEvents(T& data) noexcept(noexcept(eventReceiver_.try_receive(std::declval<std::function<void(T&)>&>()))) {
+    std::function<void(T&)> event;
+    while (eventReceiver_.try_receive(event) == ResponseStatus::SUCCESS) {
+      event(data);
+    }
+  }
+
+ private:
+  Sender<std::function<void(T&)>> eventSender_;
+  Receiver<std::function<void(T&)>> eventReceiver_;
+};
+
+} // namespace audioapi