react-native-audio-api 0.12.0-nightly-37d6b7c-20260119 → 0.12.0-nightly-75589dc-20260121

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
@@ -11,23 +12,18 @@
 #include <vector>
 
 namespace audioapi {
-ConvolverNode::ConvolverNode(
-    std::shared_ptr<BaseAudioContext> context,
-    const std::shared_ptr<AudioBuffer> &buffer,
-    bool disableNormalization)
-    : AudioNode(context),
+ConvolverNode::ConvolverNode(std::shared_ptr<BaseAudioContext> context, const ConvolverOptions &options)
+    : AudioNode(context, options),
       gainCalibrationSampleRate_(context->getSampleRate()),
       remainingSegments_(0),
       internalBufferIndex_(0),
-      normalize_(!disableNormalization),
+      normalize_(!options.disableNormalization),
       signalledToStop_(false),
       scaleFactor_(1.0f),
       intermediateBus_(nullptr),
       buffer_(nullptr),
       internalBuffer_(nullptr) {
-  channelCount_ = 2;
-  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  setBuffer(buffer);
+  setBuffer(options.bus);
   audioBus_ =
       std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
   requiresTailProcessing_ = true;

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

@@ -17,13 +17,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioBuffer;
+class ConvolverOptions;
 
 class ConvolverNode : public AudioNode {
  public:
   explicit ConvolverNode(
       std::shared_ptr<BaseAudioContext> context,
-      const std::shared_ptr<AudioBuffer> &buffer,
-      bool disableNormalization);
+      const ConvolverOptions &options);
 
   [[nodiscard]] bool getNormalize_() const;
   [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/DelayNode.h>
 #include <audioapi/dsp/VectorMath.h>
@@ -7,13 +8,13 @@
 
 namespace audioapi {
 
-DelayNode::DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime)
-    : AudioNode(context),
-      delayTimeParam_(std::make_shared<AudioParam>(0, 0, maxDelayTime, context)),
+DelayNode::DelayNode(std::shared_ptr<BaseAudioContext> context, const DelayOptions &options)
+    : AudioNode(context, options),
+      delayTimeParam_(std::make_shared<AudioParam>(options.delayTime, 0, options.maxDelayTime, context)),
       delayBuffer_(
           std::make_shared<AudioBus>(
               static_cast<size_t>(
-                  maxDelayTime * context->getSampleRate() +
+                  options.maxDelayTime * context->getSampleRate() +
                   1), // +1 to enable delayTime equal to maxDelayTime
               channelCount_,
               context->getSampleRate())) {

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

@@ -9,10 +9,11 @@
 namespace audioapi {
 
 class AudioBus;
+class DelayOptions;
 
 class DelayNode : public AudioNode {
  public:
-  explicit DelayNode(std::shared_ptr<BaseAudioContext> context, float maxDelayTime);
+  explicit DelayNode(std::shared_ptr<BaseAudioContext> context, const DelayOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/dsp/VectorMath.h>
@@ -7,11 +8,11 @@
 
 namespace audioapi {
 
-GainNode::GainNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioNode(context),
+GainNode::GainNode(std::shared_ptr<BaseAudioContext> context, const GainOptions &options)
+    : AudioNode(context, options),
       gainParam_(
           std::make_shared<AudioParam>(
-              1.0,
+              options.gain,
               MOST_NEGATIVE_SINGLE_FLOAT,
               MOST_POSITIVE_SINGLE_FLOAT,
               context)) {

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

@@ -8,10 +8,11 @@
 namespace audioapi {
 
 class AudioBus;
+class GainOptions;
 
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(std::shared_ptr<BaseAudioContext> context);
+  explicit GainNode(std::shared_ptr<BaseAudioContext> context, const GainOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 

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

@@ -23,6 +23,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/IIRFilterNode.h>
 #include <audioapi/core/utils/Constants.h>
@@ -30,16 +31,15 @@
 #include <audioapi/utils/AudioBus.h>
 #include <algorithm>
 #include <memory>
+#include <utility>
 #include <vector>
 
 namespace audioapi {
 
-IIRFilterNode::IIRFilterNode(
-    std::shared_ptr<BaseAudioContext> context,
-    const std::vector<float> &feedforward,
-    const std::vector<float> &feedback)
-    : AudioNode(context), feedforward_(feedforward), feedback_(feedback) {
-  channelCountMode_ = ChannelCountMode::MAX;
+IIRFilterNode::IIRFilterNode(std::shared_ptr<BaseAudioContext> context, const IIRFilterOptions &options)
+    : AudioNode(context, options),
+    feedforward_(std::move(options.feedforward)),
+    feedback_(std::move(options.feedback)) {
 
   int maxChannels = MAX_CHANNEL_COUNT;
   xBuffers_.resize(maxChannels);

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

@@ -33,13 +33,14 @@
 
 namespace audioapi {
 
+class IIRFilterOptions;
+
 class IIRFilterNode : public AudioNode {
 
  public:
   explicit IIRFilterNode(
       std::shared_ptr<BaseAudioContext> context,
-      const std::vector<float> &feedforward,
-      const std::vector<float> &feedback);
+      const IIRFilterOptions &options);
 
   void getFrequencyResponse(
       const float *frequencyArray,

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/utils/Constants.h>
@@ -9,9 +10,8 @@
 
 namespace audioapi {
 
-StereoPannerNode::StereoPannerNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioNode(context), panParam_(std::make_shared<AudioParam>(0.0, -1.0f, 1.0f, context)) {
-  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+StereoPannerNode::StereoPannerNode(std::shared_ptr<BaseAudioContext> context, const StereoPannerOptions &options)
+    : AudioNode(context, options), panParam_(std::make_shared<AudioParam>(options.pan, -1.0f, 1.0f, context)) {
   isInitialized_ = true;
 }
 

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

@@ -10,10 +10,13 @@
 namespace audioapi {
 
 class AudioBus;
+class StereoPannerOptions;
 
 class StereoPannerNode : public AudioNode {
  public:
-  explicit StereoPannerNode(std::shared_ptr<BaseAudioContext> context);
+  explicit StereoPannerNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const StereoPannerOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 

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

@@ -3,6 +3,7 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 
 #include <algorithm>
 #include <memory>
@@ -10,14 +11,14 @@
 
 namespace audioapi {
 
-WaveShaperNode::WaveShaperNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioNode(context), oversample_(OverSampleType::OVERSAMPLE_NONE) {
+WaveShaperNode::WaveShaperNode(std::shared_ptr<BaseAudioContext> context, const WaveShaperOptions &options)
+    : AudioNode(context, options), oversample_(options.oversample) {
 
   waveShapers_.reserve(6);
   for (int i = 0; i < channelCount_; i++) {
     waveShapers_.emplace_back(std::make_unique<WaveShaper>(nullptr));
   }
-
+  setCurve(options.curve);
   // to change after graph processing improvement - should be max
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
   isInitialized_ = true;

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

@@ -16,10 +16,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioArray;
+class WaveShaperOptions;
 
 class WaveShaperNode : public AudioNode {
  public:
-  explicit WaveShaperNode(std::shared_ptr<BaseAudioContext> context);
+  explicit WaveShaperNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const WaveShaperOptions &options);
 
   [[nodiscard]] std::string getOversample() const;
   [[nodiscard]] std::shared_ptr<AudioArray> getCurve() const;

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

@@ -25,7 +25,7 @@ class AudioRecorder {
       : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::string, std::string> start(const std::string &fileNameOverride) = 0;
   virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
 
   virtual Result<std::string, std::string> enableFileOutput(

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -8,8 +9,8 @@
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(int numberOfChannels, size_t length, float sampleRate)
-    : bus_(std::make_shared<AudioBus>(length, numberOfChannels, sampleRate)) {}
+AudioBuffer::AudioBuffer(const AudioBufferOptions &options)
+    : bus_(std::make_shared<AudioBus>(options.length, options.numberOfChannels, options.sampleRate)) {}
 
 AudioBuffer::AudioBuffer(std::shared_ptr<AudioBus> bus) {
   bus_ = std::move(bus);

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

@@ -10,10 +10,11 @@
 namespace audioapi {
 
 class AudioBus;
+class AudioBufferOptions;
 
 class AudioBuffer {
  public:
-  explicit AudioBuffer(int numberOfChannels, size_t length, float sampleRate);
+  explicit AudioBuffer(const AudioBufferOptions &options);
   explicit AudioBuffer(std::shared_ptr<AudioBus> bus);
 
   [[nodiscard]] size_t getLength() const;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
@@ -12,29 +13,22 @@
 namespace audioapi {
 AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
     std::shared_ptr<BaseAudioContext> context,
-    bool pitchCorrection)
+    const BaseAudioBufferSourceOptions &options)
     : AudioScheduledSourceNode(context),
-      pitchCorrection_(pitchCorrection),
-      stretch_(std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>()),
-      playbackRateBus_(
-          std::make_shared<AudioBus>(
-              RENDER_QUANTUM_SIZE * 3,
-              channelCount_,
-              context->getSampleRate())),
-      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)),
-      vReadIndex_(0.0),
-      onPositionChangedInterval_(static_cast<int>(context->getSampleRate() * 0.1f)) {}
+      pitchCorrection_(options.pitchCorrection),
+      vReadIndex_(0.0) {
+  onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
+
+  detuneParam_ = std::make_shared<AudioParam>(
+      options.detune, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  playbackRateParam_ = std::make_shared<AudioParam>(
+      options.playbackRate, 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_;

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

@@ -11,12 +11,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
+class BaseAudioBufferSourceOptions;
 
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(
       std::shared_ptr<BaseAudioContext> context,
-      bool pitchCorrection);
+      const BaseAudioBufferSourceOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
@@ -18,19 +19,21 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    std::shared_ptr<BaseAudioContext> context,
-    bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection), buffers_() {
+std::shared_ptr<BaseAudioContext> context,
+    const BaseAudioBufferSourceOptions &options)
+    : AudioBufferBaseSourceNode(context, options) {
+  buffers_ = {};
   stretch_->presetDefault(channelCount_, context->getSampleRate());
 
-  if (pitchCorrection) {
+  if (options.pitchCorrection) {
     // If pitch correction is enabled, add extra frames at the end
     // to compensate for processing latency.
     addExtraTailFrames_ = true;
 
     int extraTailFrames = static_cast<int>(stretch_->inputLatency() + stretch_->outputLatency());
-    tailBuffer_ =
-        std::make_shared<AudioBuffer>(channelCount_, extraTailFrames, context->getSampleRate());
+    auto audioBufferOptions = AudioBufferOptions(
+        extraTailFrames, static_cast<size_t>(channelCount_), context->getSampleRate());
+    tailBuffer_ = std::make_shared<AudioBuffer>(audioBufferOptions);
 
     tailBuffer_->bus_->zero();
   }

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

@@ -14,12 +14,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
+class BaseAudioBufferSourceOptions;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
   explicit AudioBufferQueueSourceNode(
       std::shared_ptr<BaseAudioContext> context,
-      bool pitchCorrection);
+      const BaseAudioBufferSourceOptions &options);
   ~AudioBufferQueueSourceNode() override;
 
   void stop(double when) override;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
@@ -14,14 +15,15 @@ namespace audioapi {
 
 AudioBufferSourceNode::AudioBufferSourceNode(
     std::shared_ptr<BaseAudioContext> context,
-    bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection),
-      loop_(false),
+    const AudioBufferSourceOptions &options)
+    : AudioBufferBaseSourceNode(context, options),
+      loop_(options.loop),
       loopSkip_(false),
-      loopStart_(0),
-      loopEnd_(0),
-      buffer_(nullptr),
-      alignedBus_(nullptr) {
+      loopStart_(options.loopStart),
+      loopEnd_(options.loopEnd) {
+  buffer_ = std::shared_ptr<AudioBuffer>(options.buffer);
+  alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
+
   isInitialized_ = true;
 }
 

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

@@ -13,10 +13,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
+class AudioBufferSourceOptions;
 
 class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
  public:
-  explicit AudioBufferSourceNode(std::shared_ptr<BaseAudioContext> context, bool pitchCorrection);
+  explicit AudioBufferSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const AudioBufferSourceOptions &options);
   ~AudioBufferSourceNode() override;
 
   [[nodiscard]] bool getLoop() const;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/dsp/AudioUtils.h>
@@ -6,14 +7,10 @@
 #include <memory>
 
 namespace audioapi {
-ConstantSourceNode::ConstantSourceNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioScheduledSourceNode(context),
-      offsetParam_(
-          std::make_shared<AudioParam>(
-              1.0,
-              MOST_NEGATIVE_SINGLE_FLOAT,
-              MOST_POSITIVE_SINGLE_FLOAT,
-              context)) {
+ConstantSourceNode::ConstantSourceNode(std::shared_ptr<BaseAudioContext> context, const ConstantSourceOptions &options)
+    : AudioScheduledSourceNode(context) {
+  offsetParam_ = std::make_shared<AudioParam>(
+      options.offset, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   isInitialized_ = true;
 }
 

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

@@ -10,10 +10,13 @@
 namespace audioapi {
 
 class AudioBus;
+class ConstantSourceOptions;
 
 class ConstantSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit ConstantSourceNode(std::shared_ptr<BaseAudioContext> context);
+  explicit ConstantSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const ConstantSourceOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
 

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/dsp/AudioUtils.h>
@@ -8,23 +9,27 @@
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioScheduledSourceNode(context),
-      frequencyParam_(
-          std::make_shared<AudioParam>(
-              444.0,
-              -context->getNyquistFrequency(),
-              context->getNyquistFrequency(),
-              context)),
-      detuneParam_(
-          std::make_shared<AudioParam>(
-              0.0,
-              -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-              1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-              context)),
-      type_(OscillatorType::SINE),
-      periodicWave_(context->getBasicWaveForm(type_)) {
+OscillatorNode::OscillatorNode(std::shared_ptr<BaseAudioContext> context, const OscillatorOptions &options)
+    : AudioScheduledSourceNode(context) {
+  frequencyParam_ = std::make_shared<AudioParam>(
+      options.frequency,
+      -context->getNyquistFrequency(),
+      context->getNyquistFrequency(),
+      context);
+  detuneParam_ = std::make_shared<AudioParam>(
+      options.detune,
+      -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      context);
+  type_ = options.type;
+  if (options.periodicWave) {
+    periodicWave_ = options.periodicWave;
+  } else {
+    periodicWave_ = context->getBasicWaveForm(type_);
+  }
+
   audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate());
+
   isInitialized_ = true;
 }
 

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

@@ -13,10 +13,13 @@
 namespace audioapi {
 
 class AudioBus;
+class OscillatorOptions;
 
 class OscillatorNode : public AudioScheduledSourceNode {
  public:
-  explicit OscillatorNode(std::shared_ptr<BaseAudioContext> context);
+  explicit OscillatorNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const OscillatorOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;

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

@@ -8,6 +8,7 @@
  * FFmpeg, you must comply with the terms of the LGPL for FFmpeg itself.
  */
 
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/StreamerNode.h>
 #include <audioapi/core/utils/Locker.h>
@@ -22,7 +23,7 @@
 
 namespace audioapi {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context)
+StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options)
     : AudioScheduledSourceNode(context),
       fmtCtx_(nullptr),
       codecCtx_(nullptr),
@@ -37,7 +38,7 @@ StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context)
       maxResampledSamples_(0),
       processedSamples_(0) {}
 #else
-StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context) : AudioScheduledSourceNode(context) {}
+StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options) : AudioScheduledSourceNode(context) {}
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 StreamerNode::~StreamerNode() {
@@ -48,6 +49,7 @@ StreamerNode::~StreamerNode() {
 
 bool StreamerNode::initialize(const std::string &input_url) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
+  streamPath_ = input_url;
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
     return false;

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

@@ -59,10 +59,11 @@ struct StreamingData {
 namespace audioapi {
 
 class AudioBus;
+class StreamerOptions;
 
 class StreamerNode : public AudioScheduledSourceNode {
  public:
-  explicit StreamerNode(std::shared_ptr<BaseAudioContext> context);
+  explicit StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options);
   ~StreamerNode() override;
 
   /**
@@ -70,6 +71,14 @@ class StreamerNode : public AudioScheduledSourceNode {
   */
   bool initialize(const std::string &inputUrl);
 
+  std::string getStreamPath() const {
+#if !RN_AUDIO_API_TEST
+    return streamPath_;
+#else
+    return "";
+#endif // RN_AUDIO_API_TEST
+  }
+
  protected:
   std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
@@ -103,6 +112,7 @@ class StreamerNode : public AudioScheduledSourceNode {
       STREAMER_NODE_SPSC_OVERFLOW_STRATEGY,
       STREAMER_NODE_SPSC_WAIT_STRATEGY>
       receiver_;
+  std::string streamPath_;
 
   /**
    * @brief Setting up the resampler

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
@@ -26,7 +27,7 @@ class ConstantSourceTest : public ::testing::Test {
 class TestableConstantSourceNode : public ConstantSourceNode {
  public:
   explicit TestableConstantSourceNode(std::shared_ptr<BaseAudioContext> context)
-      : ConstantSourceNode(context) {}
+      : ConstantSourceNode(context, ConstantSourceOptions()) {}
 
   void setOffsetParam(float value) {
     getOffsetParam()->setValue(value);
@@ -40,7 +41,7 @@ class TestableConstantSourceNode : public ConstantSourceNode {
 };
 
 TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
-  auto constantSource = context->createConstantSource();
+  auto constantSource = context->createConstantSource(ConstantSourceOptions());
   ASSERT_NE(constantSource, nullptr);
 }