react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-75589dc-20260121

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
@@ -71,7 +72,7 @@ double BaseAudioContext::getCurrentTime() const {
   return destination_->getCurrentTime();
 }
 
-std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
+std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() const {
   return destination_;
 }
 
@@ -116,21 +117,22 @@ std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
   return recorderAdapter;
 }
 
-std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
-  auto oscillator = std::make_shared<OscillatorNode>(shared_from_this());
+std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator(const OscillatorOptions &options) {
+  auto oscillator = std::make_shared<OscillatorNode>(shared_from_this(), options);
   nodeManager_->addSourceNode(oscillator);
   return oscillator;
 }
 
-std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
-  auto constantSource = std::make_shared<ConstantSourceNode>(shared_from_this());
+std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource(
+    const ConstantSourceOptions &options) {
+  auto constantSource = std::make_shared<ConstantSourceNode>(shared_from_this(), options);
   nodeManager_->addSourceNode(constantSource);
   return constantSource;
 }
 
-std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
+std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer(const StreamerOptions &options) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-  auto streamer = std::make_shared<StreamerNode>(shared_from_this());
+  auto streamer = std::make_shared<StreamerNode>(shared_from_this(), options);
   nodeManager_->addSourceNode(streamer);
   return streamer;
 #else
@@ -138,55 +140,54 @@ std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
-std::shared_ptr<GainNode> BaseAudioContext::createGain() {
-  auto gain = std::make_shared<GainNode>(shared_from_this());
+std::shared_ptr<GainNode> BaseAudioContext::createGain(const GainOptions &options) {
+  auto gain = std::make_shared<GainNode>(shared_from_this(), options);
   nodeManager_->addProcessingNode(gain);
   return gain;
 }
 
-std::shared_ptr<DelayNode> BaseAudioContext::createDelay(float maxDelayTime) {
-  auto delay = std::make_shared<DelayNode>(shared_from_this(), maxDelayTime);
-  nodeManager_->addProcessingNode(delay);
-  return delay;
-}
-
-std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
-  auto stereoPanner = std::make_shared<StereoPannerNode>(shared_from_this());
+std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner(
+    const StereoPannerOptions &options) {
+  auto stereoPanner = std::make_shared<StereoPannerNode>(shared_from_this(), options);
   nodeManager_->addProcessingNode(stereoPanner);
   return stereoPanner;
 }
 
-std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
-  auto biquadFilter = std::make_shared<BiquadFilterNode>(shared_from_this());
-  nodeManager_->addProcessingNode(biquadFilter);
-  return biquadFilter;
+std::shared_ptr<DelayNode> BaseAudioContext::createDelay(const DelayOptions &options) {
+  auto delay = std::make_shared<DelayNode>(shared_from_this(), options);
+  nodeManager_->addProcessingNode(delay);
+  return delay;
 }
 
-std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(
-    const std::vector<float> &feedforward,
-    const std::vector<float> &feedback) {
-  auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), feedforward, feedback);
-  nodeManager_->addProcessingNode(iirFilter);
-  return iirFilter;
+std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter(
+    const BiquadFilterOptions &options) {
+  auto biquadFilter = std::make_shared<BiquadFilterNode>(shared_from_this(), options);
+  nodeManager_->addProcessingNode(biquadFilter);
+  return biquadFilter;
 }
 
-std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(bool pitchCorrection) {
-  auto bufferSource = std::make_shared<AudioBufferSourceNode>(shared_from_this(), pitchCorrection);
+std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
+    const AudioBufferSourceOptions &options) {
+  auto bufferSource = std::make_shared<AudioBufferSourceNode>(shared_from_this(), options);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
+std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(const IIRFilterOptions &options) {
+  auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), options);
+  nodeManager_->addProcessingNode(iirFilter);
+  return iirFilter;
+}
+
 std::shared_ptr<AudioBufferQueueSourceNode> BaseAudioContext::createBufferQueueSource(
-    bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferQueueSourceNode>(shared_from_this(), pitchCorrection);
+    const BaseAudioBufferSourceOptions &options) {
+  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(shared_from_this(), options);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }
 
-std::shared_ptr<AudioBuffer>
-BaseAudioContext::createBuffer(int numberOfChannels, size_t length, float sampleRate) {
-  return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
+std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(const AudioBufferOptions &options) {
+  return std::make_shared<AudioBuffer>(options);
 }
 
 std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
@@ -196,23 +197,20 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
   return std::make_shared<PeriodicWave>(sampleRate_, complexData, length, disableNormalization);
 }
 
-std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
-  auto analyser = std::make_shared<AnalyserNode>(shared_from_this());
+std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser(const AnalyserOptions &options) {
+  auto analyser = std::make_shared<AnalyserNode>(shared_from_this(), options);
   nodeManager_->addProcessingNode(analyser);
   return analyser;
 }
 
-std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
-    std::shared_ptr<AudioBuffer> buffer,
-    bool disableNormalization) {
-  auto convolver =
-      std::make_shared<ConvolverNode>(shared_from_this(), buffer, disableNormalization);
+std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(const ConvolverOptions &options) {
+  auto convolver = std::make_shared<ConvolverNode>(shared_from_this(), options);
   nodeManager_->addProcessingNode(convolver);
   return convolver;
 }
 
-std::shared_ptr<WaveShaperNode> BaseAudioContext::createWaveShaper() {
-  auto waveShaper = std::make_shared<WaveShaperNode>(shared_from_this());
+std::shared_ptr<WaveShaperNode> BaseAudioContext::createWaveShaper(const WaveShaperOptions &options) {
+  auto waveShaper = std::make_shared<WaveShaperNode>(shared_from_this(), options);
   nodeManager_->addProcessingNode(waveShaper);
   return waveShaper;
 }

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

@@ -33,11 +33,25 @@ class AudioEventHandlerRegistry;
 class ConvolverNode;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
+class WaveShaperNode;
 class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
-class WaveShaperNode;
+class GainOptions;
+class StereoPannerOptions;
+class ConvolverOptions;
+class ConstantSourceOptions;
+class AnalyserOptions;
+class BiquadFilterOptions;
+class OscillatorOptions;
+class BaseAudioBufferSourceOptions;
+class AudioBufferSourceOptions;
+class StreamerOptions;
+class AudioBufferOptions;
+class DelayOptions;
+class IIRFilterOptions;
+class WaveShaperOptions;
 
 class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  public:
@@ -52,7 +66,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   [[nodiscard]] float getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
-  std::shared_ptr<AudioDestinationNode> getDestination();
+  std::shared_ptr<AudioDestinationNode> getDestination() const;
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
   std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(
@@ -69,29 +83,26 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
       std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
       std::weak_ptr<worklets::WorkletRuntime> runtime,
       bool shouldLockRuntime = true);
-  std::shared_ptr<OscillatorNode> createOscillator();
-  std::shared_ptr<ConstantSourceNode> createConstantSource();
-  std::shared_ptr<StreamerNode> createStreamer();
-  std::shared_ptr<GainNode> createGain();
-  std::shared_ptr<DelayNode> createDelay(float maxDelayTime);
-  std::shared_ptr<StereoPannerNode> createStereoPanner();
-  std::shared_ptr<BiquadFilterNode> createBiquadFilter();
-  std::shared_ptr<IIRFilterNode> createIIRFilter(
-      const std::vector<float> &feedforward,
-      const std::vector<float> &feedback);
-  std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
-  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
-  static std::shared_ptr<AudioBuffer>
-  createBuffer(int numberOfChannels, size_t length, float sampleRate);
+  std::shared_ptr<DelayNode> createDelay(const DelayOptions &options);
+  std::shared_ptr<IIRFilterNode> createIIRFilter(const IIRFilterOptions &options);
+  std::shared_ptr<OscillatorNode> createOscillator(const OscillatorOptions &options);
+  std::shared_ptr<ConstantSourceNode> createConstantSource(const ConstantSourceOptions &options);
+  std::shared_ptr<StreamerNode> createStreamer(const StreamerOptions &options);
+  std::shared_ptr<GainNode> createGain(const GainOptions &options);
+  std::shared_ptr<StereoPannerNode> createStereoPanner(const StereoPannerOptions &options);
+  std::shared_ptr<BiquadFilterNode> createBiquadFilter(const BiquadFilterOptions &options);
+  std::shared_ptr<AudioBufferSourceNode> createBufferSource(
+      const AudioBufferSourceOptions &options);
+  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(
+      const BaseAudioBufferSourceOptions &options);
+  static std::shared_ptr<AudioBuffer> createBuffer(const AudioBufferOptions &options);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
       const std::vector<std::complex<float>> &complexData,
       bool disableNormalization,
       int length);
-  std::shared_ptr<AnalyserNode> createAnalyser();
-  std::shared_ptr<ConvolverNode> createConvolver(
-      std::shared_ptr<AudioBuffer> buffer,
-      bool disableNormalization);
-  std::shared_ptr<WaveShaperNode> createWaveShaper();
+  std::shared_ptr<AnalyserNode> createAnalyser(const AnalyserOptions &options);
+  std::shared_ptr<ConvolverNode> createConvolver(const ConvolverOptions &options);
+  std::shared_ptr<WaveShaperNode> createWaveShaper(const WaveShaperOptions &options);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/dsp/AudioUtils.h>
@@ -12,12 +13,13 @@
 #include <vector>
 
 namespace audioapi {
-AnalyserNode::AnalyserNode(std::shared_ptr<BaseAudioContext> context)
-    : AudioNode(context),
-      fftSize_(2048),
-      minDecibels_(-100),
-      maxDecibels_(-30),
-      smoothingTimeConstant_(0.8),
+
+AnalyserNode::AnalyserNode(std::shared_ptr<BaseAudioContext> context, const AnalyserOptions &options)
+    : AudioNode(context, options),
+      fftSize_(options.fftSize),
+      minDecibels_(options.minDecibels),
+      maxDecibels_(options.maxDecibels),
+      smoothingTimeConstant_(options.smoothingTimeConstant),
       windowType_(WindowType::BLACKMAN),
       inputBuffer_(std::make_unique<CircularAudioArray>(MAX_FFT_SIZE * 2)),
       downMixBus_(std::make_unique<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())),

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -15,11 +15,12 @@ namespace audioapi {
 class AudioBus;
 class AudioArray;
 class CircularAudioArray;
+class AnalyserOptions;
 
 class AnalyserNode : public AudioNode {
  public:
   enum class WindowType { BLACKMAN, HANN };
-  explicit AnalyserNode(std::shared_ptr<BaseAudioContext> context);
+  explicit AnalyserNode(std::shared_ptr<BaseAudioContext> context, const AnalyserOptions &options);
 
   int getFftSize() const;
   int getFrequencyBinCount() const;

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

@@ -26,6 +26,7 @@
  * THIS 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/BiquadFilterNode.h>
 #include <audioapi/utils/AudioArray.h>
@@ -38,26 +39,24 @@
 
 namespace audioapi {
 
-BiquadFilterNode::BiquadFilterNode(std::shared_ptr<BaseAudioContext> context) : AudioNode(context) {
+BiquadFilterNode::BiquadFilterNode(std::shared_ptr<BaseAudioContext> context, const BiquadFilterOptions &options) : AudioNode(context, options) {
   frequencyParam_ =
-      std::make_shared<AudioParam>(350.0, 0.0f, context->getNyquistFrequency(), context);
+      std::make_shared<AudioParam>(options.frequency, 0.0f, context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
-      0.0f,
+      options.detune,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
       1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
       context);
   QParam_ = std::make_shared<AudioParam>(
-      1.0f, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+      options.Q, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   gainParam_ = std::make_shared<AudioParam>(
-      0.0f, MOST_NEGATIVE_SINGLE_FLOAT, 40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT, context);
-  type_ = BiquadFilterType::LOWPASS;
+      options.gain, MOST_NEGATIVE_SINGLE_FLOAT, 40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT, context);
+  type_ = options.type;
   x1_.resize(MAX_CHANNEL_COUNT, 0.0f);
   x2_.resize(MAX_CHANNEL_COUNT, 0.0f);
   y1_.resize(MAX_CHANNEL_COUNT, 0.0f);
   y2_.resize(MAX_CHANNEL_COUNT, 0.0f);
   isInitialized_ = true;
-  channelCountMode_ = ChannelCountMode::MAX;
-  isInitialized_ = true;
 }
 
 std::string BiquadFilterNode::getType() {

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

@@ -46,6 +46,7 @@
 namespace audioapi {
 
 class AudioBus;
+class BiquadFilterOptions;
 
 class BiquadFilterNode : public AudioNode {
 #if RN_AUDIO_API_TEST
@@ -54,7 +55,9 @@ class BiquadFilterNode : public AudioNode {
 #endif // RN_AUDIO_API_TEST
 
  public:
-  explicit BiquadFilterNode(std::shared_ptr<BaseAudioContext> context);
+  explicit BiquadFilterNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const BiquadFilterOptions &options);
 
   [[nodiscard]] std::string getType();
   void setType(const std::string &type);

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/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;