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

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -22,7 +22,9 @@
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 
+#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
 #include <memory>
+#include <utility>
 #include <vector>
 
 namespace audioapi {
@@ -165,14 +167,21 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
-  auto oscillator = context_->createOscillator();
+  const auto options = args[0].asObject(runtime);
+  const auto oscillatorOptions = audioapi::option_parser::parseOscillatorOptions(runtime, options);
+  auto oscillator = context_->createOscillator(oscillatorOptions);
   auto oscillatorHostObject = std::make_shared<OscillatorNodeHostObject>(oscillator);
   return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-  auto streamer = context_->createStreamer();
+  auto streamerOptions = StreamerOptions();
+  if (!args[0].isUndefined()) {
+    const auto options = args[0].asObject(runtime);
+    streamerOptions = audioapi::option_parser::parseStreamerOptions(runtime, options);
+  }
+  auto streamer = context_->createStreamer(streamerOptions);
   auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
   auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
   object.setExternalMemoryPressure(runtime, StreamerNodeHostObject::getSizeInBytes());
@@ -183,20 +192,26 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
-  auto constantSource = context_->createConstantSource();
+  const auto options = args[0].asObject(runtime);
+  const auto constantSourceOptions =
+      audioapi::option_parser::parseConstantSourceOptions(runtime, options);
+  auto constantSource = context_->createConstantSource(constantSourceOptions);
   auto constantSourceHostObject = std::make_shared<ConstantSourceNodeHostObject>(constantSource);
   return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
-  auto gain = context_->createGain();
+  const auto options = args[0].asObject(runtime);
+  const auto gainOptions = audioapi::option_parser::parseGainOptions(runtime, options);
+  auto gain = context_->createGain(std::move(gainOptions));
   auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
   return jsi::Object::createFromHostObject(runtime, gainHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
-  auto maxDelayTime = static_cast<float>(args[0].getNumber());
-  auto delayNode = context_->createDelay(maxDelayTime);
+  const auto options = args[0].asObject(runtime);
+  const auto delayOptions = audioapi::option_parser::parseDelayOptions(runtime, options);
+  auto delayNode = context_->createDelay(delayOptions);
   auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(delayNode);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, delayNodeHostObject);
   jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getSizeInBytes());
@@ -204,63 +219,52 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
-  auto stereoPanner = context_->createStereoPanner();
+  const auto options = args[0].asObject(runtime);
+  const auto stereoPannerOptions = audioapi::option_parser::parseStereoPannerOptions(runtime, options);
+  auto stereoPanner = context_->createStereoPanner(stereoPannerOptions);
   auto stereoPannerHostObject = std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
   return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
-  auto biquadFilter = context_->createBiquadFilter();
+  const auto options = args[0].asObject(runtime);
+  const auto biquadFilterOptions = audioapi::option_parser::parseBiquadFilterOptions(runtime, options);
+  auto biquadFilter = context_->createBiquadFilter(biquadFilterOptions);
   auto biquadFilterHostObject = std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createIIRFilter) {
-  auto feedforwardArray = args[0].asObject(runtime).asArray(runtime);
-  auto feedbackArray = args[1].asObject(runtime).asArray(runtime);
-
-  size_t feedforwardLength = feedforwardArray.length(runtime);
-  size_t feedbackLength = feedbackArray.length(runtime);
-
-  std::vector<float> feedforward;
-  std::vector<float> feedback;
-
-  feedforward.reserve(feedforwardLength);
-  feedback.reserve(feedbackLength);
-
-  for (size_t i = 0; i < feedforwardLength; ++i) {
-    feedforward.push_back(feedforwardArray.getValueAtIndex(runtime, i).asNumber());
-  }
-
-  for (size_t i = 0; i < feedbackLength; ++i) {
-    feedback.push_back(feedbackArray.getValueAtIndex(runtime, i).asNumber());
-  }
-
-  auto iirFilter = context_->createIIRFilter(feedforward, feedback);
+  const auto options = args[0].asObject(runtime);
+  const auto iirFilterOptions = audioapi::option_parser::parseIIRFilterOptions(runtime, options);
+  auto iirFilter = context_->createIIRFilter(iirFilterOptions);
   auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(iirFilter);
   return jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferSource(pitchCorrection);
+  const auto options = args[0].asObject(runtime);
+  const auto audioBufferSourceOptions =
+      audioapi::option_parser::parseAudioBufferSourceOptions(runtime, options);
+  auto bufferSource = context_->createBufferSource(audioBufferSourceOptions);
   auto bufferSourceHostObject = std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferQueueSource(pitchCorrection);
+  const auto options = args[0].asObject(runtime);
+  const auto baseAudioBufferSourceOptions =
+      audioapi::option_parser::parseBaseAudioBufferSourceOptions(runtime, options);
+  auto bufferSource = context_->createBufferQueueSource(baseAudioBufferSourceOptions);
   auto bufferStreamSourceHostObject =
       std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
-  auto numberOfChannels = static_cast<int>(args[0].getNumber());
-  auto length = static_cast<size_t>(args[1].getNumber());
-  auto sampleRate = static_cast<float>(args[2].getNumber());
-  auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
+  const auto options = args[0].asObject(runtime);
+  const auto audioBufferOptions = audioapi::option_parser::parseAudioBufferOptions(runtime, options);
+  auto buffer = BaseAudioContext::createBuffer(audioBufferOptions);
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
 
   auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
@@ -294,31 +298,30 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
-  auto analyser = context_->createAnalyser();
+  const auto options = args[0].asObject(runtime);
+  const auto analyserOptions = audioapi::option_parser::parseAnalyserOptions(runtime, options);
+  auto analyser = context_->createAnalyser(analyserOptions);
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
-  auto disableNormalization = args[1].getBool();
-  std::shared_ptr<ConvolverNode> convolver;
-  if (args[0].isUndefined()) {
-    convolver = context_->createConvolver(nullptr, disableNormalization);
-  } else {
-    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    convolver = context_->createConvolver(bufferHostObject->audioBuffer_, disableNormalization);
-  }
+  const auto options = args[0].asObject(runtime);
+  const auto convolverOptions = audioapi::option_parser::parseConvolverOptions(runtime, options);
+  auto convolver = context_->createConvolver(convolverOptions);
   auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(convolver);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, convolverHostObject);
-  if (!args[0].isUndefined()) {
-    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  if (convolverOptions.bus != nullptr) {
+    auto bufferHostObject = options.getProperty(runtime, "buffer").getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
     jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
   }
   return jsiObject;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
-  auto waveShaper = context_->createWaveShaper();
+  const auto options = args[0].asObject(runtime);
+  const auto waveShaperOptions = audioapi::option_parser::parseWaveShaperOptions(runtime, options);
+  auto waveShaper = context_->createWaveShaper(waveShaperOptions);
   auto waveShaperHostObject = std::make_shared<WaveShaperNodeHostObject>(waveShaper);
   return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
 }

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.cpp

@@ -10,6 +10,12 @@ namespace audioapi {
 StreamerNodeHostObject::StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node)
     : AudioScheduledSourceNodeHostObject(node) {
   addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(StreamerNodeHostObject, streamPath));
+}
+
+JSI_PROPERTY_GETTER_IMPL(StreamerNodeHostObject, streamPath) {
+  auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
+  return jsi::String::createFromUtf8(runtime, streamerNode->getStreamPath());
 }
 
 JSI_HOST_FUNCTION_IMPL(StreamerNodeHostObject, initialize) {

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h

@@ -19,6 +19,7 @@ class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
     return SIZE;
   }
 
+  JSI_PROPERTY_GETTER_DECL(streamPath);
   JSI_HOST_FUNCTION_DECL(initialize);
 
  private:

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

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/types/BiquadFilterType.h>
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/utils/AudioArray.h>
+
+namespace audioapi {
+struct AudioNodeOptions {
+  int channelCount = 2;
+  ChannelCountMode channelCountMode;
+  ChannelInterpretation channelInterpretation;
+};
+
+struct GainOptions : AudioNodeOptions {
+  float gain;
+};
+
+struct StereoPannerOptions : AudioNodeOptions {
+  float pan;
+};
+
+struct ConvolverOptions : AudioNodeOptions {
+  std::shared_ptr<AudioBuffer> bus;
+  bool disableNormalization;
+};
+
+struct ConstantSourceOptions {
+  float offset;
+};
+
+struct AnalyserOptions : AudioNodeOptions {
+  int fftSize;
+  float minDecibels;
+  float maxDecibels;
+  float smoothingTimeConstant;
+};
+
+struct BiquadFilterOptions : AudioNodeOptions {
+  BiquadFilterType type;
+  float frequency;
+  float detune;
+  float Q;
+  float gain;
+};
+
+struct OscillatorOptions {
+  std::shared_ptr<PeriodicWave> periodicWave;
+  float frequency;
+  float detune;
+  OscillatorType type;
+};
+
+struct BaseAudioBufferSourceOptions {
+  float detune;
+  bool pitchCorrection;
+  float playbackRate;
+};
+
+struct AudioBufferSourceOptions : BaseAudioBufferSourceOptions {
+  std::shared_ptr<AudioBuffer> buffer;
+  bool loop;
+  float loopStart;
+  float loopEnd;
+};
+
+struct StreamerOptions {
+  std::string streamPath;
+};
+
+struct AudioBufferOptions {
+  int numberOfChannels;
+  size_t length;
+  float sampleRate;
+};
+
+struct DelayOptions : AudioNodeOptions {
+  float maxDelayTime;
+  float delayTime;
+};
+
+struct IIRFilterOptions : AudioNodeOptions {
+  std::vector<float> feedforward;
+  std::vector<float> feedback;
+
+  IIRFilterOptions() = default;
+
+  explicit IIRFilterOptions(const AudioNodeOptions options) : AudioNodeOptions(options) {}
+
+  IIRFilterOptions(const std::vector<float> &ff, const std::vector<float> &fb)
+      : feedforward(ff), feedback(fb) {}
+
+  IIRFilterOptions(std::vector<float> &&ff, std::vector<float> &&fb)
+      : feedforward(std::move(ff)), feedback(std::move(fb)) {}
+};
+
+struct WaveShaperOptions : AudioNodeOptions {
+  std::shared_ptr<AudioArray> curve;
+  OverSampleType oversample;
+};
+
+} // namespace audioapi

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;