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

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;

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

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

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

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

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
@@ -18,19 +19,21 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    std::shared_ptr<BaseAudioContext> context,
-    bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context, pitchCorrection), buffers_() {
+std::shared_ptr<BaseAudioContext> context,
+    const BaseAudioBufferSourceOptions &options)
+    : AudioBufferBaseSourceNode(context, options) {
+  buffers_ = {};
   stretch_->presetDefault(channelCount_, context->getSampleRate());
 
-  if (pitchCorrection) {
+  if (options.pitchCorrection) {
     // If pitch correction is enabled, add extra frames at the end
     // to compensate for processing latency.
     addExtraTailFrames_ = true;
 
     int extraTailFrames = static_cast<int>(stretch_->inputLatency() + stretch_->outputLatency());
-    tailBuffer_ =
-        std::make_shared<AudioBuffer>(channelCount_, extraTailFrames, context->getSampleRate());
+    auto audioBufferOptions = AudioBufferOptions(
+        extraTailFrames, static_cast<size_t>(channelCount_), context->getSampleRate());
+    tailBuffer_ = std::make_shared<AudioBuffer>(audioBufferOptions);
 
     tailBuffer_->bus_->zero();
   }
@@ -75,6 +78,10 @@ std::string AudioBufferQueueSourceNode::enqueueBuffer(const std::shared_ptr<Audi
   auto locker = Locker(getBufferLock());
   buffers_.emplace(bufferId_, buffer);
 
+  if (tailBuffer_ != nullptr) {
+    addExtraTailFrames_ = true;
+  }
+
   return std::to_string(bufferId_++);
 }
 
@@ -122,6 +129,14 @@ void AudioBufferQueueSourceNode::disable() {
   buffers_ = {};
 }
 
+void AudioBufferQueueSourceNode::setOnBufferEndedCallbackId(uint64_t callbackId) {
+    auto oldCallbackId = onBufferEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+    if (oldCallbackId != 0) {
+        audioEventHandlerRegistry_->unregisterHandler("bufferEnded", oldCallbackId);
+    }
+}
+
 std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -155,6 +170,18 @@ double AudioBufferQueueSourceNode::getCurrentPosition() const {
   }
 }
 
+void AudioBufferQueueSourceNode::sendOnBufferEndedEvent(size_t bufferId, bool isLastBufferInQueue) {
+    auto onBufferEndedCallbackId = onBufferEndedCallbackId_.load(std::memory_order_acquire);
+
+    if (onBufferEndedCallbackId != 0) {
+        std::unordered_map<std::string, EventValue> body =
+                {{"bufferId", std::to_string(bufferId)}, {"isLastBufferInQueue", isLastBufferInQueue}};
+
+        audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+                "bufferEnded", onBufferEndedCallbackId, body);
+    }
+}
+
 /**
  * Helper functions
  */
@@ -193,20 +220,15 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
       playedBuffersDuration_ += buffer->getDuration();
       buffers_.pop();
 
-      std::unordered_map<std::string, EventValue> body = {
-          {"bufferId", std::to_string(bufferId)}, {"isLast", buffers_.empty()}};
-      if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-        context->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-            "ended", onEndedCallbackId_, body);
+      if (!(buffers_.empty() && addExtraTailFrames_)) {
+          sendOnBufferEndedEvent(bufferId, buffers_.empty());
       }
 
       if (buffers_.empty()) {
         if (addExtraTailFrames_) {
-          buffers_.emplace(bufferId_, tailBuffer_);
-          bufferId_++;
-
+          buffers_.emplace(bufferId, tailBuffer_);
           addExtraTailFrames_ = false;
-        } else if (buffers_.empty()) {
+        } else {
           processingBus->zero(writeIndex, framesLeft);
           readIndex = 0;
 
@@ -281,11 +303,7 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
       playedBuffersDuration_ += buffer->getDuration();
       buffers_.pop();
 
-      std::unordered_map<std::string, EventValue> body = {{"bufferId", std::to_string(bufferId)}};
-      if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-        context->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-            "ended", onEndedCallbackId_, body);
-      }
+      sendOnBufferEndedEvent(bufferId, buffers_.empty());
 
       if (buffers_.empty()) {
         processingBus->zero(writeIndex, framesLeft);

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

@@ -14,12 +14,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
+class BaseAudioBufferSourceOptions;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
   explicit AudioBufferQueueSourceNode(
       std::shared_ptr<BaseAudioContext> context,
-      bool pitchCorrection);
+      const BaseAudioBufferSourceOptions &options);
   ~AudioBufferQueueSourceNode() override;
 
   void stop(double when) override;
@@ -33,12 +34,17 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
   void clearBuffers();
   void disable() override;
 
+  void setOnBufferEndedCallbackId(uint64_t callbackId);
+
  protected:
   std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override;
+
   double getCurrentPosition() const override;
 
+  void sendOnBufferEndedEvent(size_t bufferId, bool isLastBufferInQueue);
+
  private:
   // User provided buffers
   std::queue<std::pair<size_t, std::shared_ptr<AudioBuffer>>> buffers_;
@@ -50,6 +56,8 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
 
   double playedBuffersDuration_ = 0;
 
+  std::atomic<uint64_t> onBufferEndedCallbackId_ = 0; // 0 means no callback
+
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus> &processingBus,
       size_t startOffset,

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

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

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

@@ -13,10 +13,13 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
+class AudioBufferSourceOptions;
 
 class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
  public:
-  explicit AudioBufferSourceNode(std::shared_ptr<BaseAudioContext> context, bool pitchCorrection);
+  explicit AudioBufferSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      const AudioBufferSourceOptions &options);
   ~AudioBufferSourceNode() override;
 
   [[nodiscard]] bool getLoop() const;
@@ -69,7 +72,7 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
       size_t offsetLength,
       float playbackRate) override;
 
-  double getVirtualStartFrame(float sampleRate);
+  double getVirtualStartFrame(float sampleRate) const;
   double getVirtualEndFrame(float sampleRate);
 };
 

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

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

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

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

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

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