react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-6993a06-20260122

package/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h

@@ -0,0 +1,262 @@
+#pragma once
+
+#include <audioapi/jsi/RuntimeLifecycleMonitor.h>
+#include <jsi/jsi.h>
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+
+namespace audioapi::option_parser {
+AudioNodeOptions parseAudioNodeOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  AudioNodeOptions options;
+
+  options.channelCount =
+      static_cast<int>(optionsObject.getProperty(runtime, "channelCount").getNumber());
+
+  auto channelCountModeStr =
+      optionsObject.getProperty(runtime, "channelCountMode").asString(runtime).utf8(runtime);
+
+  if (channelCountModeStr == "max") {
+    options.channelCountMode = ChannelCountMode::MAX;
+  } else if (channelCountModeStr == "clamped-max") {
+    options.channelCountMode = ChannelCountMode::CLAMPED_MAX;
+  } else if (channelCountModeStr == "explicit") {
+    options.channelCountMode = ChannelCountMode::EXPLICIT;
+  }
+
+  auto channelInterpretationStr =
+      optionsObject.getProperty(runtime, "channelInterpretation").asString(runtime).utf8(runtime);
+
+  if (channelInterpretationStr == "speakers") {
+    options.channelInterpretation = ChannelInterpretation::SPEAKERS;
+  } else if (channelInterpretationStr == "discrete") {
+    options.channelInterpretation = ChannelInterpretation::DISCRETE;
+  }
+
+  return options;
+}
+
+GainOptions parseGainOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  GainOptions options(parseAudioNodeOptions(runtime, optionsObject));
+  options.gain = static_cast<float>(optionsObject.getProperty(runtime, "gain").getNumber());
+  return options;
+}
+
+StereoPannerOptions parseStereoPannerOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  StereoPannerOptions options(parseAudioNodeOptions(runtime, optionsObject));
+  options.pan = static_cast<float>(optionsObject.getProperty(runtime, "pan").getNumber());
+  return options;
+}
+
+ConvolverOptions parseConvolverOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  ConvolverOptions options(parseAudioNodeOptions(runtime, optionsObject));
+  options.disableNormalization =
+      optionsObject.getProperty(runtime, "disableNormalization").getBool();
+  if (optionsObject.hasProperty(runtime, "buffer")) {
+    auto bufferHostObject = optionsObject.getProperty(runtime, "buffer")
+                                .getObject(runtime)
+                                .asHostObject<AudioBufferHostObject>(runtime);
+    options.bus = bufferHostObject->audioBuffer_;
+  }
+  return options;
+}
+
+ConstantSourceOptions parseConstantSourceOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  ConstantSourceOptions options;
+  options.offset = static_cast<float>(optionsObject.getProperty(runtime, "offset").getNumber());
+  return options;
+}
+
+AnalyserOptions parseAnalyserOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  AnalyserOptions options(parseAudioNodeOptions(runtime, optionsObject));
+  options.fftSize = static_cast<int>(optionsObject.getProperty(runtime, "fftSize").getNumber());
+  options.minDecibels =
+      static_cast<float>(optionsObject.getProperty(runtime, "minDecibels").getNumber());
+  options.maxDecibels =
+      static_cast<float>(optionsObject.getProperty(runtime, "maxDecibels").getNumber());
+  options.smoothingTimeConstant =
+      static_cast<float>(optionsObject.getProperty(runtime, "smoothingTimeConstant").getNumber());
+  return options;
+}
+
+BiquadFilterOptions parseBiquadFilterOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  BiquadFilterOptions options(parseAudioNodeOptions(runtime, optionsObject));
+
+  auto typeStr = optionsObject.getProperty(runtime, "type").asString(runtime).utf8(runtime);
+
+  if (typeStr == "lowpass") {
+    options.type = BiquadFilterType::LOWPASS;
+  } else if (typeStr == "highpass") {
+    options.type = BiquadFilterType::HIGHPASS;
+  } else if (typeStr == "bandpass") {
+    options.type = BiquadFilterType::BANDPASS;
+  } else if (typeStr == "lowshelf") {
+    options.type = BiquadFilterType::LOWSHELF;
+  } else if (typeStr == "highshelf") {
+    options.type = BiquadFilterType::HIGHSHELF;
+  } else if (typeStr == "peaking") {
+    options.type = BiquadFilterType::PEAKING;
+  } else if (typeStr == "notch") {
+    options.type = BiquadFilterType::NOTCH;
+  } else if (typeStr == "allpass") {
+    options.type = BiquadFilterType::ALLPASS;
+  }
+
+  options.frequency =
+      static_cast<float>(optionsObject.getProperty(runtime, "frequency").getNumber());
+  options.detune = static_cast<float>(optionsObject.getProperty(runtime, "detune").getNumber());
+  options.Q = static_cast<float>(optionsObject.getProperty(runtime, "Q").getNumber());
+  options.gain = static_cast<float>(optionsObject.getProperty(runtime, "gain").getNumber());
+
+  return options;
+}
+
+OscillatorOptions parseOscillatorOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  OscillatorOptions options;
+
+  auto typeStr = optionsObject.getProperty(runtime, "type").asString(runtime).utf8(runtime);
+
+  if (typeStr == "sine") {
+    options.type = OscillatorType::SINE;
+  } else if (typeStr == "square") {
+    options.type = OscillatorType::SQUARE;
+  } else if (typeStr == "sawtooth") {
+    options.type = OscillatorType::SAWTOOTH;
+  } else if (typeStr == "triangle") {
+    options.type = OscillatorType::TRIANGLE;
+  } else if (typeStr == "custom") {
+    options.type = OscillatorType::CUSTOM;
+  }
+
+  options.frequency =
+      static_cast<float>(optionsObject.getProperty(runtime, "frequency").getNumber());
+  options.detune = static_cast<float>(optionsObject.getProperty(runtime, "detune").getNumber());
+
+  if (optionsObject.hasProperty(runtime, "periodicWave")) {
+    auto periodicWaveHostObject = optionsObject.getProperty(runtime, "periodicWave")
+                                      .getObject(runtime)
+                                      .asHostObject<PeriodicWaveHostObject>(runtime);
+    options.periodicWave = periodicWaveHostObject->periodicWave_;
+  }
+
+  return options;
+}
+
+BaseAudioBufferSourceOptions parseBaseAudioBufferSourceOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  BaseAudioBufferSourceOptions options;
+  options.detune = static_cast<float>(optionsObject.getProperty(runtime, "detune").getNumber());
+  options.playbackRate =
+      static_cast<float>(optionsObject.getProperty(runtime, "playbackRate").getNumber());
+  options.pitchCorrection =
+      static_cast<bool>(optionsObject.getProperty(runtime, "pitchCorrection").getBool());
+  return options;
+}
+
+AudioBufferSourceOptions parseAudioBufferSourceOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  AudioBufferSourceOptions options(parseBaseAudioBufferSourceOptions(runtime, optionsObject));
+  if (optionsObject.hasProperty(runtime, "buffer")) {
+    auto bufferHostObject = optionsObject.getProperty(runtime, "buffer")
+                                .getObject(runtime)
+                                .asHostObject<AudioBufferHostObject>(runtime);
+    options.buffer = bufferHostObject->audioBuffer_;
+  }
+  options.loop = static_cast<bool>(optionsObject.getProperty(runtime, "loop").getBool());
+  options.loopStart =
+      static_cast<float>(optionsObject.getProperty(runtime, "loopStart").getNumber());
+  options.loopEnd = static_cast<float>(optionsObject.getProperty(runtime, "loopEnd").getNumber());
+  return options;
+}
+
+StreamerOptions parseStreamerOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  auto options = StreamerOptions();
+  if (optionsObject.hasProperty(runtime, "streamPath")) {
+    options.streamPath =
+        optionsObject.getProperty(runtime, "streamPath").asString(runtime).utf8(runtime);
+  }
+  return options;
+}
+
+AudioBufferOptions parseAudioBufferOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject) {
+  AudioBufferOptions options;
+  options.numberOfChannels =
+      static_cast<int>(optionsObject.getProperty(runtime, "numberOfChannels").getNumber());
+  options.length = static_cast<size_t>(optionsObject.getProperty(runtime, "length").getNumber());
+  options.sampleRate =
+      static_cast<float>(optionsObject.getProperty(runtime, "sampleRate").getNumber());
+  return options;
+}
+
+DelayOptions parseDelayOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  DelayOptions options(parseAudioNodeOptions(runtime, optionsObject));
+  options.maxDelayTime =
+      static_cast<float>(optionsObject.getProperty(runtime, "maxDelayTime").getNumber());
+  options.delayTime =
+      static_cast<float>(optionsObject.getProperty(runtime, "delayTime").getNumber());
+  return options;
+}
+
+IIRFilterOptions parseIIRFilterOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  IIRFilterOptions options(parseAudioNodeOptions(runtime, optionsObject));
+
+  auto feedforwardArray =
+      optionsObject.getProperty(runtime, "feedforward").asObject(runtime).asArray(runtime);
+  size_t feedforwardLength = feedforwardArray.size(runtime);
+  options.feedforward.reserve(feedforwardLength);
+  for (size_t i = 0; i < feedforwardLength; ++i) {
+    options.feedforward.push_back(
+        static_cast<float>(feedforwardArray.getValueAtIndex(runtime, i).getNumber()));
+  }
+
+  auto feedbackArray =
+      optionsObject.getProperty(runtime, "feedback").asObject(runtime).asArray(runtime);
+  size_t feedbackLength = feedbackArray.size(runtime);
+  options.feedback.reserve(feedbackLength);
+  for (size_t i = 0; i < feedbackLength; ++i) {
+    options.feedback.push_back(
+        static_cast<float>(feedbackArray.getValueAtIndex(runtime, i).getNumber()));
+  }
+
+  return options;
+}
+
+WaveShaperOptions parseWaveShaperOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  WaveShaperOptions options(parseAudioNodeOptions(runtime, optionsObject));
+
+  auto oversampleStr =
+      optionsObject.getProperty(runtime, "oversample").asString(runtime).utf8(runtime);
+
+  if (oversampleStr == "none") {
+    options.oversample = OverSampleType::OVERSAMPLE_NONE;
+  } else if (oversampleStr == "2x") {
+    options.oversample = OverSampleType::OVERSAMPLE_2X;
+  } else if (oversampleStr == "4x") {
+    options.oversample = OverSampleType::OVERSAMPLE_4X;
+  }
+
+  if (optionsObject.hasProperty(runtime, "buffer")) {
+    auto arrayBuffer = optionsObject.getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+
+    options.curve = std::make_shared<AudioArray>(
+        reinterpret_cast<float *>(arrayBuffer.data(runtime)),
+        static_cast<size_t>(arrayBuffer.size(runtime) / sizeof(float)));
+  }
+  return options;
+}
+} // namespace audioapi::option_parser

package/common/cpp/audioapi/core/AudioNode.cpp

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
@@ -10,13 +11,19 @@
 
 namespace audioapi {
 
-AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context)
+AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context) : context_(context) {
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+}
+
+AudioNode::AudioNode(std::shared_ptr<BaseAudioContext> context, const AudioNodeOptions &options)
     : context_(context),
-      audioBus_(
-          std::make_shared<AudioBus>(
-              RENDER_QUANTUM_SIZE,
-              channelCount_,
-              context->getSampleRate())) {}
+      channelCount_(options.channelCount),
+      channelCountMode_(options.channelCountMode),
+      channelInterpretation_(options.channelInterpretation) {
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+}
 
 AudioNode::~AudioNode() {
   if (isInitialized_) {

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

@@ -16,10 +16,12 @@ namespace audioapi {
 class AudioBus;
 class BaseAudioContext;
 class AudioParam;
+class AudioNodeOptions;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
   explicit AudioNode(std::shared_ptr<BaseAudioContext> context);
+  explicit AudioNode(std::shared_ptr<BaseAudioContext> context, const AudioNodeOptions &options);
   virtual ~AudioNode();
 
   int getNumberOfInputs() const;

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