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

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -102,7 +102,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
 /// RN side requires their "file://" prefix, but sometimes it returned raw path.
 /// Most likely this was due to alpha version mistakes, but in case of problems leaving this here. (ㆆ _ ㆆ)
 /// @returns On success, returns the file URI where the recording is being saved (if file output is enabled).
-Result<std::string, std::string> AndroidAudioRecorder::start() {
+Result<std::string, std::string> AndroidAudioRecorder::start(const std::string &fileNameOverride) {
   std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
 
   if (!isIdle()) {
@@ -120,9 +120,12 @@ Result<std::string, std::string> AndroidAudioRecorder::start() {
   }
 
   if (usesFileOutput()) {
-    auto fileResult =
-        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
-            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+    auto fileResult = std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+                          ->openFile(
+                              streamSampleRate_,
+                              streamChannelCount_,
+                              streamMaxBufferSizeInFrames_,
+                              fileNameOverride);
 
     if (!fileResult.is_ok()) {
       return Result<std::string, std::string>::Err(
@@ -228,7 +231,7 @@ Result<std::string, std::string> AndroidAudioRecorder::enableFileOutput(
   if (!isIdle()) {
     auto fileResult =
         std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
-            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_, "");
 
     if (!fileResult.is_ok()) {
       return Result<std::string, std::string>::Err(

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -26,7 +26,7 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecor
   ~AndroidAudioRecorder() override;
   void cleanup();
 
-  Result<std::string, std::string> start() override;
+  Result<std::string, std::string> start(const std::string &fileNameOverride) override;
   Result<std::tuple<std::string, double, double>, std::string> stop() override;
 
   Result<std::string, std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) override;

package/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -17,7 +17,7 @@ class AndroidFileWriterBackend : public AudioFileWriter {
     const std::shared_ptr<AudioFileProperties> &fileProperties)
       : AudioFileWriter(audioEventHandlerRegistry, fileProperties) {}
 
-  virtual OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
+  virtual OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize, const std::string &fileNameOverride) = 0;
   virtual bool writeAudioData(void *data, int numFrames) = 0;
 
   std::string getFilePath() const override { return filePath_; }

package/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp

@@ -63,7 +63,8 @@ std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &propert
 }
 
 Result<std::string, std::string> getFilePath(
-    const std::shared_ptr<AudioFileProperties> &properties) {
+    const std::shared_ptr<AudioFileProperties> &properties,
+    const std::string &fileNameOverride) {
   std::string directory = getDirectory(properties);
   std::string subDirectory = std::format("{}/{}", directory, properties->subDirectory);
   std::string fileTimestamp = getTimestampString();
@@ -75,8 +76,11 @@ Result<std::string, std::string> getFilePath(
     return Result<std::string, std::string>::Err(result.unwrap_err());
   }
 
-  auto filePath = std::format(
-      "{}/{}_{}.{}", subDirectory, properties->fileNamePrefix, fileTimestamp, extension);
+  auto filePath = fileNameOverride.length() > 0
+      ? std::format("{}/{}.{}", subDirectory, fileNameOverride, extension)
+      : std::format(
+            "{}/{}_{}.{}", subDirectory, properties->fileNamePrefix, fileTimestamp, extension);
+
   return Result<std::string, std::string>::Ok(filePath);
 }
 

package/android/src/main/cpp/audioapi/android/core/utils/FileOptions.h

@@ -15,7 +15,7 @@ std::string getTimestampString();
 
 std::string getDirectory(const std::shared_ptr<AudioFileProperties> &properties);
 std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &properties);
-Result<std::string, std::string> getFilePath(const std::shared_ptr<AudioFileProperties> &properties);
+Result<std::string, std::string> getFilePath(const std::shared_ptr<AudioFileProperties> &properties, const std::string &fileNameOverride);
 
 } // namespace android::fileoptions
 

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -53,14 +53,16 @@ FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
 OpenFileResult FFmpegAudioFileWriter::openFile(
     float streamSampleRate,
     int32_t streamChannelCount,
-    int32_t streamMaxBufferSize) {
+    int32_t streamMaxBufferSize,
+    const std::string &fileNameOverride) {
   streamSampleRate_ = streamSampleRate;
   streamChannelCount_ = streamChannelCount;
   streamMaxBufferSize_ = streamMaxBufferSize;
   framesWritten_.store(0, std::memory_order_release);
   nextPts_ = 0;
   Result<NoneType, std::string> result = Result<NoneType, std::string>::Ok(None);
-  Result<std::string, std::string> filePathResult = fileoptions::getFilePath(fileProperties_);
+  Result<std::string, std::string> filePathResult =
+      fileoptions::getFilePath(fileProperties_, fileNameOverride);
 
   if (!filePathResult.is_ok()) {
     return OpenFileResult::Err(filePathResult.unwrap_err());

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h

@@ -29,7 +29,7 @@ class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
       const std::shared_ptr<AudioFileProperties> &fileProperties);
   ~FFmpegAudioFileWriter();
 
-  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize, const std::string &fileNameOverride) override;
   CloseFileResult closeFile() override;
 
   bool writeAudioData(void *data, int numFrames) override;

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp

@@ -75,7 +75,8 @@ MiniAudioFileWriter::~MiniAudioFileWriter() {
 OpenFileResult MiniAudioFileWriter::openFile(
     float streamSampleRate,
     int32_t streamChannelCount,
-    int32_t streamMaxBufferSize) {
+    int32_t streamMaxBufferSize,
+    const std::string &fileNameOverride) {
   streamSampleRate_ = streamSampleRate;
   streamChannelCount_ = streamChannelCount;
   streamMaxBufferSize_ = streamMaxBufferSize;
@@ -95,7 +96,7 @@ OpenFileResult MiniAudioFileWriter::openFile(
         "Failed to initialize converter" + std::string(ma_result_description(result)));
   }
 
-  result = initializeEncoder();
+  result = initializeEncoder(fileNameOverride);
 
   if (result != MA_SUCCESS) {
     return OpenFileResult ::Err(
@@ -266,10 +267,10 @@ ma_result MiniAudioFileWriter::initializeConverterIfNeeded() {
 /// This method sets up the audio encoder for writing to the file,
 /// it should be called only on the JS thread. (during file opening)
 /// @return MA_SUCCESS if initialization was successful, otherwise an error code.
-ma_result MiniAudioFileWriter::initializeEncoder() {
+ma_result MiniAudioFileWriter::initializeEncoder(const std::string &fileNameOverride) {
   ma_result result;
   Result<std::string, std::string> filePathResult =
-      android::fileoptions::getFilePath(fileProperties_);
+      android::fileoptions::getFilePath(fileProperties_, fileNameOverride);
 
   if (!filePathResult.is_ok()) {
     return MA_ERROR;

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h

@@ -17,7 +17,7 @@ class MiniAudioFileWriter : public AndroidFileWriterBackend {
       const std::shared_ptr<AudioFileProperties> &fileProperties);
   ~MiniAudioFileWriter();
 
-  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize, const std::string &fileNameOverride) override;
   CloseFileResult closeFile() override;
 
   bool writeAudioData(void *data, int numFrames) override;
@@ -31,7 +31,7 @@ class MiniAudioFileWriter : public AndroidFileWriterBackend {
   ma_uint64 processingBufferLength_{0};
 
   ma_result initializeConverterIfNeeded();
-  ma_result initializeEncoder();
+  ma_result initializeEncoder(const std::string &fileNameOverride);
   ma_uint64 convertBuffer(void *data, int numFrames);
 
   bool isConverterRequired();

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/inputs/AudioRecorderHostObject.cpp

@@ -41,7 +41,8 @@ AudioRecorderHostObject::AudioRecorderHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
-  auto result = audioRecorder_->start();
+  auto fileNameOverride = count > 0 ? args[0].getString(runtime).utf8(runtime) : "";
+  auto result = audioRecorder_->start(fileNameOverride);
   auto jsResult = jsi::Object(runtime);
 
   jsResult.setProperty(

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