react-native-audio-api 0.6.2-rc.6 → 0.6.3-rc.1

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

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <memory>
+#include <string>
+#include <cstring>
+#include <functional>
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include <any>
+#include <utility>
+
+namespace audioapi {
+
+class AudioBus;
+
+/**
+ * @brief Interface for defining custom audio processors that can be attached to nodes.
+ */
+class CustomAudioProcessor {
+ public:
+  virtual ~CustomAudioProcessor() = default;
+
+  /**
+   * @brief Processes audio data in-place.
+   * @param channelData Array of float pointers for each channel.
+   * @param numChannels Number of audio channels.
+   * @param numFrames Number of frames per channel.
+   */
+  virtual void processInPlace(float** channelData, int numChannels, int numFrames) {
+    // Default: do nothing
+  }
+
+  /**
+   * @brief Processes audio data from input to output buffers.
+   * Default behavior copies input to output and then calls in-place processing.
+   * @param input Input audio buffers.
+   * @param output Output audio buffers.
+   * @param numChannels Number of channels.
+   * @param numFrames Number of frames per channel.
+   */
+  virtual void processThrough(float** input, float** output, int numChannels, int numFrames) {
+    for (int ch = 0; ch < numChannels; ++ch) {
+      std::memcpy(output[ch], input[ch], sizeof(float) * numFrames);
+    }
+    processInPlace(output, numChannels, numFrames);
+  }
+};
+
+/**
+ * @brief Audio node that wraps a user-defined processor for custom audio processing.
+ */
+class CustomProcessorNode : public AudioNode {
+ public:
+  /**
+   * @brief Enumerates supported audio processing modes.
+   */
+  enum class ProcessorMode {
+    ProcessInPlace,
+    ProcessThrough
+  };
+
+  /**
+   * @brief Constructs a new CustomProcessorNode attached to a given context with a processor identifier.
+   * @param context Audio context this node belongs to.
+   * @param identifier The identifier of the processor to instantiate and bind.
+   */
+  CustomProcessorNode(BaseAudioContext* context, const std::string& identifier);
+
+  /**
+   * @brief Destroys the node and removes it from active tracking.
+   */
+  ~CustomProcessorNode();
+
+  /**
+   * @brief Gets the custom AudioParam associated with this node.
+   * @return Shared pointer to an AudioParam.
+   */
+  std::shared_ptr<AudioParam> getCustomProcessorParam() const;
+
+  /**
+   * @brief Gets the processor mode.
+   * @return The current processing mode as an enum.
+   */
+  ProcessorMode getProcessorMode() const;
+
+  /**
+   * @brief Sets the processor mode.
+   * @param processorMode Processing mode to apply.
+   */
+  void setProcessorMode(ProcessorMode processorMode);
+
+  /**
+   * @brief Registers a factory for creating processors for a given identifier.
+   * @param identifier Unique string key.
+   * @param factory Function that returns a shared CustomAudioProcessor.
+   */
+  static void registerProcessorFactory(
+      const std::string& identifier,
+      std::function<std::shared_ptr<CustomAudioProcessor>()> factory);
+
+  /**
+   * @brief Unregisters a processor factory.
+   * @param identifier Key to remove.
+   */
+  static void unregisterProcessorFactory(const std::string& identifier);
+
+  /**
+   * @brief Alias for control callbacks accepting arbitrary parameters.
+   */
+  using GenericControlHandler = std::function<void(const std::vector<std::any>&)>;
+
+  /**
+   * @brief Registers a control handler for automation (e.g., gain or filter changes).
+   * @param identifier Control name key.
+   * @param handler Function to handle dynamic updates.
+   */
+  static void registerControlHandler(const std::string& identifier, GenericControlHandler handler);
+
+  /**
+   * @brief Unregisters a control handler by identifier.
+   * @param identifier The key to remove.
+   */
+  static void unregisterControlHandler(const std::string& identifier);
+
+  /**
+   * @brief Invokes a control handler using variadic arguments.
+   * @tparam Args Parameter types.
+   * @param identifier Key associated with the control handler.
+   * @param args Arguments passed to the handler.
+   */
+  template <typename... Args>
+  static void applyControlToNode(const std::string& identifier, Args&&... args) {
+    auto it = s_controlHandlersByIdentifier.find(identifier);
+    if (it != s_controlHandlersByIdentifier.end()) {
+      std::vector<std::any> paramList = { std::forward<Args>(args)... };
+      it->second(paramList);
+    }
+  }
+
+ protected:
+  /**
+   * @brief Core audio processing callback invoked each render cycle.
+   * @param processingBus The audio bus containing buffers.
+   * @param framesToProcess Number of frames to process.
+   */
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  /**
+   * @brief In-place audio processing.
+   * @param bus The shared audio bus buffer.
+   * @param frames Number of frames to process.
+   */
+  void processInPlace(const std::shared_ptr<AudioBus>& bus, int frames);
+
+  /**
+   * @brief Processes audio using separate input and output buffers.
+   * @param bus Audio bus used for both input and output access.
+   * @param frames Number of frames to process.
+   */
+  void processThrough(const std::shared_ptr<AudioBus>& bus, int frames);
+
+  /**
+   * @brief Ensures that preallocated output buffers match the required frame and channel dimensions.
+   * This avoids real-time heap allocations.
+   */
+  void ensurePreallocatedBuffers(int numChannels, int numFrames);
+
+  std::shared_ptr<AudioParam> customProcessorParam_; ///< Optional real-time modifiable parameter.
+  ProcessorMode processorMode_ = ProcessorMode::ProcessInPlace; ///< Determines processing style.
+  std::shared_ptr<CustomAudioProcessor> processor_; ///< Processor instance.
+
+  std::vector<std::vector<float>> preallocatedOutputBuffers_; ///< Storage for preallocated channel data.
+  std::vector<float*> preallocatedOutputPointers_; ///< Pointers to preallocatedOutputBuffers_ for processor API.
+
+  static void notifyProcessorChanged(const std::string& identifier); ///< Notify and update all nodes with given identifier.
+
+  static std::map<std::string, std::function<std::shared_ptr<CustomAudioProcessor>()>> s_processorFactoriesByIdentifier; ///< Global registry of processor factories.
+  static std::unordered_map<std::string, GenericControlHandler> s_controlHandlersByIdentifier; ///< Global registry of control handlers.
+  static std::unordered_map<std::string, std::vector<CustomProcessorNode*>> s_activeNodes; ///< Tracks active node instances by identifier.
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,106 @@
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/Constants.h>
+#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context), vReadIndex_(0.0) {
+  onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
+
+  detuneParam_ = std::make_shared<AudioParam>(
+      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  playbackRateParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
+  stretch_ =
+      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+}
+
+std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
+    const {
+  return playbackRateParam_;
+}
+
+void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
+    uint64_t callbackId) {
+  onPositionChangedCallbackId_ = callbackId;
+}
+
+void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
+  onPositionChangedInterval_ = static_cast<int>(
+      context_->getSampleRate() * static_cast<float>(interval) / 1000);
+}
+
+std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
+  return bufferLock_;
+}
+
+void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
+  if (onPositionChangedCallbackId_ != 0 &&
+      onPositionChangedTime_ > onPositionChangedInterval_) {
+    std::unordered_map<std::string, EventValue> body = {
+        {"value", getCurrentPosition()}};
+
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "positionChanged", onPositionChangedCallbackId_, body);
+
+    onPositionChangedTime_ = 0;
+  }
+
+  onPositionChangedTime_ += RENDER_QUANTUM_SIZE;
+}
+
+void AudioBufferBaseSourceNode::processWithPitchCorrection(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  auto time = context_->getCurrentTime();
+  auto playbackRate = std::clamp(
+      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune = std::clamp(
+      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
+      -12.0f,
+      12.0f);
+
+  playbackRateBus_->zero();
+
+  auto framesNeededToStretch =
+      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+
+  updatePlaybackInfo(
+      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+
+  if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
+    processingBus->zero();
+    return;
+  }
+
+  processWithoutInterpolation(
+      playbackRateBus_, startOffset, offsetLength, playbackRate);
+
+  stretch_->process(
+      playbackRateBus_.get()[0],
+      framesNeededToStretch,
+      processingBus.get()[0],
+      framesToProcess);
+
+  if (detune != 0.0f) {
+    stretch_->setTransposeSemitones(detune);
+  }
+  sendOnPositionChangedEvent();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
+
+#include <memory>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioParam;
+
+class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit AudioBufferBaseSourceNode(BaseAudioContext *context);
+
+    [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+    [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
+
+    void setOnPositionChangedCallbackId(uint64_t callbackId);
+    void setOnPositionChangedInterval(int interval);
+
+ protected:
+    std::mutex bufferLock_;
+
+    // pitch correction
+    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+    std::shared_ptr<AudioBus> playbackRateBus_;
+
+    // k-rate params
+    std::shared_ptr<AudioParam> detuneParam_;
+    std::shared_ptr<AudioParam> playbackRateParam_;
+
+    // internal helper
+    double vReadIndex_;
+
+    uint64_t onPositionChangedCallbackId_ = 0; // 0 means no callback
+    int onPositionChangedInterval_;
+    int onPositionChangedTime_ = 0;
+
+    std::mutex &getBufferLock();
+    virtual double getCurrentPosition() const = 0;
+
+    void sendOnPositionChangedEvent();
+    void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                    int framesToProcess);
+    virtual void processWithoutInterpolation(
+            const std::shared_ptr<AudioBus>& processingBus,
+            size_t startOffset,
+            size_t offsetLength,
+            float playbackRate) = 0;
+};
+
+} // namespace audioapi

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

@@ -12,23 +12,10 @@ namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
     BaseAudioContext *context)
-    : AudioScheduledSourceNode(context), vReadIndex_(0.0) {
+    : AudioBufferBaseSourceNode(context) {
   buffers_ = {};
-
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
-  playbackRateParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
-
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
-
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
   stretch_->presetDefault(channelCount_, context_->getSampleRate(), true);
 
-  onPositionChangedInterval_ = static_cast<int>(context_->getSampleRate() / 10);
-
   isInitialized_ = true;
 }
 
@@ -38,23 +25,6 @@ AudioBufferQueueSourceNode::~AudioBufferQueueSourceNode() {
   buffers_ = {};
 }
 
-std::shared_ptr<AudioParam> AudioBufferQueueSourceNode::getDetuneParam() const {
-  return detuneParam_;
-}
-
-std::shared_ptr<AudioParam> AudioBufferQueueSourceNode::getPlaybackRateParam()
-    const {
-  return playbackRateParam_;
-}
-
-void AudioBufferQueueSourceNode::start(double when, double offset) {
-  AudioScheduledSourceNode::start(when);
-
-  if (offset >= 0.0) {
-    vReadIndex_ = static_cast<double>(context_->getSampleRate() * offset);
-  }
-}
-
 void AudioBufferQueueSourceNode::stop(double when) {
   AudioScheduledSourceNode::stop(when);
   isPaused_ = false;
@@ -67,10 +37,9 @@ void AudioBufferQueueSourceNode::pause() {
 
 void AudioBufferQueueSourceNode::enqueueBuffer(
     const std::shared_ptr<AudioBuffer> &buffer,
-    int bufferId,
     bool isLastBuffer) {
   auto locker = Locker(getBufferLock());
-  buffers_.emplace(bufferId, buffer);
+  buffers_.emplace(buffer);
 
   isLastBuffer_ = isLastBuffer;
 }
@@ -84,28 +53,10 @@ void AudioBufferQueueSourceNode::disable() {
     return;
   }
 
-  audioapi::AudioNode::disable();
-
-  std::string state = "stopped";
-
-  // if it has not been stopped, it is ended
-  if (stopTime_ < 0) {
-    state = "ended";
-  }
-
-  std::unordered_map<std::string, EventValue> body = {
-      {"value", getStopTime()}, {"state", state}, {"bufferId", bufferId_}};
-
-  context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-      "ended", onEndedCallbackId_, body);
-
+  AudioScheduledSourceNode::disable();
   buffers_ = {};
 }
 
-std::mutex &AudioBufferQueueSourceNode::getBufferLock() {
-  return bufferLock_;
-}
-
 void AudioBufferQueueSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -124,92 +75,25 @@ void AudioBufferQueueSourceNode::processNode(
   }
 }
 
-double AudioBufferQueueSourceNode::getStopTime() const {
+double AudioBufferQueueSourceNode::getCurrentPosition() const {
   return dsp::sampleFrameToTime(
-      static_cast<int>(vReadIndex_), context_->getSampleRate());
-}
-
-void AudioBufferQueueSourceNode::setOnPositionChangedCallbackId(
-    uint64_t callbackId) {
-  onPositionChangedCallbackId_ = callbackId;
-}
-
-void AudioBufferQueueSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedTime_ > onPositionChangedInterval_) {
-    std::unordered_map<std::string, EventValue> body = {
-        {"value", position_ + getStopTime()}};
-
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "positionChanged", onPositionChangedCallbackId_, body);
-
-    onPositionChangedTime_ = 0;
-  }
-
-  onPositionChangedTime_ += RENDER_QUANTUM_SIZE;
-}
-
-void AudioBufferQueueSourceNode::setOnPositionChangedInterval(int interval) {
-  onPositionChangedInterval_ = static_cast<int>(
-      context_->getSampleRate() * static_cast<float>(interval) / 1000);
+             static_cast<int>(vReadIndex_), context_->getSampleRate()) +
+      playedBuffersDuration_;
 }
 
 /**
  * Helper functions
  */
 
-void AudioBufferQueueSourceNode::processWithPitchCorrection(
-    const std::shared_ptr<AudioBus> &processingBus,
-    int framesToProcess) {
-  size_t startOffset = 0;
-  size_t offsetLength = 0;
-
-  auto time = context_->getCurrentTime();
-  auto playbackRate = std::clamp(
-      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
-  auto detune = std::clamp(
-      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
-      -12.0f,
-      12.0f);
-
-  playbackRateBus_->zero();
-
-  auto framesNeededToStretch =
-      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
-
-  updatePlaybackInfo(
-      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
-
-  if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
-    processingBus->zero();
-    return;
-  }
-
-  // Send position changed event
-  sendOnPositionChangedEvent();
-
-  processWithoutInterpolation(playbackRateBus_, startOffset, offsetLength);
-
-  stretch_->process(
-      playbackRateBus_.get()[0],
-      framesNeededToStretch,
-      processingBus.get()[0],
-      framesToProcess);
-
-  if (detune != 0.0f) {
-    stretch_->setTransposeSemitones(detune);
-  }
-}
-
 void AudioBufferQueueSourceNode::processWithoutInterpolation(
     const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
-    size_t offsetLength) {
+    size_t offsetLength,
+    float playbackRate) {
   auto readIndex = static_cast<size_t>(vReadIndex_);
   size_t writeIndex = startOffset;
 
-  auto queueData = buffers_.front();
-  bufferId_ = queueData.first;
-  auto buffer = queueData.second;
+  auto buffer = buffers_.front();
 
   size_t framesLeft = offsetLength;
 
@@ -230,7 +114,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
     framesLeft -= framesToCopy;
 
     if (readIndex >= buffer->getLength()) {
-      position_ += buffer->getDuration();
+      playedBuffersDuration_ += buffer->getDuration();
       buffers_.pop();
 
       if (buffers_.empty()) {
@@ -242,9 +126,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
         }
         break;
       } else {
-        queueData = buffers_.front();
-        bufferId_ = queueData.first;
-        buffer = queueData.second;
+        buffer = buffers_.front();
 
         readIndex = 0;
       }

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
 #include <memory>
@@ -15,63 +15,34 @@ namespace audioapi {
 class AudioBus;
 class AudioParam;
 
-class AudioBufferQueueSourceNode : public AudioScheduledSourceNode {
+class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
     explicit AudioBufferQueueSourceNode(BaseAudioContext *context);
     ~AudioBufferQueueSourceNode() override;
 
-    [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
-    [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
-
-    void start(double when, double offset);
     void stop(double when) override;
     void pause();
 
-    void enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer, int bufferId, bool isLastBuffer);
+    void enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer, bool isLastBuffer);
     void disable() override;
 
-    void setOnPositionChangedCallbackId(uint64_t callbackId);
-    void setOnPositionChangedInterval(int interval);
-    void sendOnPositionChangedEvent();
-
  protected:
-    std::mutex &getBufferLock();
     void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-    double getStopTime() const override;
+    double getCurrentPosition() const override;
 
  private:
-    std::mutex bufferLock_;
-
-    // pitch correction
-    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
-    std::shared_ptr<AudioBus> playbackRateBus_;
-
-    // k-rate params
-    std::shared_ptr<AudioParam> detuneParam_;
-    std::shared_ptr<AudioParam> playbackRateParam_;
-
-    // internal helper
-    double vReadIndex_;
-
     // User provided buffers
-    std::queue<std::pair<int, std::shared_ptr<AudioBuffer>>> buffers_;
-    int bufferId_ = 0;
+    std::queue<std::shared_ptr<AudioBuffer>> buffers_;
     bool isLastBuffer_ = false;
     bool isPaused_ = false;
 
-    // positionChanged event props: callbackId, update interval in frames, time since last update in frames
-    uint64_t onPositionChangedCallbackId_ = 0;
-    int onPositionChangedInterval_;
-    int onPositionChangedTime_ = 0;
-    double position_ = 0;
-
-    void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                    int framesToProcess);
+    double playedBuffersDuration_ = 0;
 
     void processWithoutInterpolation(
             const std::shared_ptr<AudioBus>& processingBus,
             size_t startOffset,
-            size_t offsetLength);
+            size_t offsetLength,
+            float playbackRate) override;
 };
 
 } // namespace audioapi