react-native-audio-api 0.8.3 → 0.9.0-nightly-7ecb495-20251008

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

@@ -1,14 +1,18 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
-AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context), vReadIndex_(0.0) {
+AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
+    BaseAudioContext *context,
+    bool pitchCorrection)
+    : AudioScheduledSourceNode(context),
+      pitchCorrection_(pitchCorrection),
+      vReadIndex_(0.0) {
   onPositionChangedInterval_ = static_cast<int>(context->getSampleRate() * 0.1);
 
   detuneParam_ = std::make_shared<AudioParam>(
@@ -24,12 +28,7 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(BaseAudioContext *context)
 }
 
 AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->unregisterHandler(
-        "positionChanged", onPositionChangedCallbackId_);
-    onPositionChangedCallbackId_ = 0;
-  }
+  clearOnPositionChangedCallback();
 }
 
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
@@ -62,7 +61,7 @@ void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
       context_->getSampleRate() * static_cast<float>(interval) / 1000);
 }
 
-int AudioBufferBaseSourceNode::getOnPositionChangedInterval() {
+int AudioBufferBaseSourceNode::getOnPositionChangedInterval() const {
   return onPositionChangedInterval_;
 }
 
@@ -125,7 +124,45 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
   if (detune != 0.0f) {
     stretch_->setTransposeSemitones(detune);
   }
+
   sendOnPositionChangedEvent();
 }
 
+void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
+    processingBus->zero();
+    return;
+  }
+
+  if (std::fabs(computedPlaybackRate) == 1.0) {
+    processWithoutInterpolation(
+        processingBus, startOffset, offsetLength, computedPlaybackRate);
+  } else {
+    processWithInterpolation(
+        processingBus, startOffset, offsetLength, computedPlaybackRate);
+  }
+
+  sendOnPositionChangedEvent();
+}
+
+float AudioBufferBaseSourceNode::getComputedPlaybackRateValue(
+    int framesToProcess) {
+  auto time = context_->getCurrentTime();
+
+  auto playbackRate =
+      playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto detune = std::pow(
+      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
+
+  return playbackRate * detune;
+}
+
 } // namespace audioapi

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

@@ -14,8 +14,8 @@ class AudioParam;
 
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit AudioBufferBaseSourceNode(BaseAudioContext *context);
-  virtual ~AudioBufferBaseSourceNode();
+  explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
+  ~AudioBufferBaseSourceNode() override;
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
@@ -23,9 +23,12 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
-  [[nodiscard]] int getOnPositionChangedInterval();
+  [[nodiscard]] int getOnPositionChangedInterval() const;
 
  protected:
+    // pitch correction
+    bool pitchCorrection_;
+
     std::mutex bufferLock_;
 
     // pitch correction
@@ -47,13 +50,25 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
     virtual double getCurrentPosition() const = 0;
 
     void sendOnPositionChangedEvent();
+
     void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
                                     int framesToProcess);
+    void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                       int framesToProcess);
+
+    float getComputedPlaybackRateValue(int framesToProcess);
+
     virtual void processWithoutInterpolation(
             const std::shared_ptr<AudioBus>& processingBus,
             size_t startOffset,
             size_t offsetLength,
             float playbackRate) = 0;
+
+    virtual void processWithInterpolation(
+            const std::shared_ptr<AudioBus>& processingBus,
+            size_t startOffset,
+            size_t offsetLength,
+            float playbackRate) = 0;
 };
 
 } // namespace audioapi

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
@@ -11,8 +11,9 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-    BaseAudioContext *context)
-    : AudioBufferBaseSourceNode(context) {
+    BaseAudioContext *context,
+    bool pitchCorrection)
+    : AudioBufferBaseSourceNode(context, pitchCorrection) {
   buffers_ = {};
   stretch_->presetDefault(channelCount_, context_->getSampleRate());
 
@@ -86,22 +87,28 @@ void AudioBufferQueueSourceNode::disable() {
   buffers_ = {};
 }
 
-void AudioBufferQueueSourceNode::processNode(
+std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   if (auto locker = Locker::tryLock(getBufferLock())) {
-    // No audio data to fill, zero the output and return.
+    // no audio data to fill, zero the output and return.
     if (buffers_.empty()) {
       processingBus->zero();
-      return;
+      return processingBus;
     }
 
-    processWithPitchCorrection(processingBus, framesToProcess);
+    if (!pitchCorrection_) {
+      processWithoutPitchCorrection(processingBus, framesToProcess);
+    } else {
+      processWithPitchCorrection(processingBus, framesToProcess);
+    }
 
     handleStopScheduled();
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferQueueSourceNode::getCurrentPosition() const {
@@ -135,6 +142,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
 
     assert(readIndex >= 0);
     assert(writeIndex >= 0);
+    assert(readIndex + framesToCopy <= buffer->getLength());
     assert(writeIndex + framesToCopy <= processingBus->getSize());
 
     processingBus->copy(
@@ -149,7 +157,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
       buffers_.pop();
 
       std::unordered_map<std::string, EventValue> body = {
-          {"bufferId", std::to_string(bufferId)}};
+          {"bufferId", std::to_string(bufferId)}, {"isLast", buffers_.empty()}};
       context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
           "ended", onEndedCallbackId_, body);
 
@@ -158,13 +166,12 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
         readIndex = 0;
 
         break;
-      } else {
-        data = buffers_.front();
-        bufferId = data.first;
-        buffer = data.second;
-
-        readIndex = 0;
       }
+
+      data = buffers_.front();
+      bufferId = data.first;
+      buffer = data.second;
+      readIndex = 0;
     }
   }
 
@@ -172,4 +179,81 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
   vReadIndex_ = static_cast<double>(readIndex);
 }
 
+void AudioBufferQueueSourceNode::processWithInterpolation(
+    const std::shared_ptr<AudioBus> &processingBus,
+    size_t startOffset,
+    size_t offsetLength,
+    float playbackRate) {
+  size_t writeIndex = startOffset;
+  size_t framesLeft = offsetLength;
+
+  auto data = buffers_.front();
+  auto bufferId = data.first;
+  auto buffer = data.second;
+
+  while (framesLeft > 0) {
+    auto readIndex = static_cast<size_t>(vReadIndex_);
+    size_t nextReadIndex = readIndex + 1;
+    auto factor =
+        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
+
+    bool crossBufferInterpolation = false;
+    std::shared_ptr<AudioBuffer> nextBuffer = nullptr;
+
+    if (nextReadIndex >= buffer->getLength()) {
+      if (buffers_.size() > 1) {
+        auto tempQueue = buffers_;
+        tempQueue.pop();
+        nextBuffer = tempQueue.front().second;
+        nextReadIndex = 0;
+        crossBufferInterpolation = true;
+      } else {
+        nextReadIndex = readIndex;
+      }
+    }
+
+    for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
+      float *destination = processingBus->getChannel(i)->getData();
+      const float *currentSource = buffer->bus_->getChannel(i)->getData();
+
+      if (crossBufferInterpolation) {
+        const float *nextSource = nextBuffer->bus_->getChannel(i)->getData();
+        float currentSample = currentSource[readIndex];
+        float nextSample = nextSource[nextReadIndex];
+        destination[writeIndex] =
+            currentSample + factor * (nextSample - currentSample);
+      } else {
+        destination[writeIndex] = dsp::linearInterpolate(
+            currentSource, readIndex, nextReadIndex, factor);
+      }
+    }
+
+    writeIndex += 1;
+    // queue source node always use positive playbackRate
+    vReadIndex_ += std::abs(playbackRate);
+    framesLeft -= 1;
+
+    if (vReadIndex_ >= static_cast<double>(buffer->getLength())) {
+      playedBuffersDuration_ += buffer->getDuration();
+      buffers_.pop();
+
+      std::unordered_map<std::string, EventValue> body = {
+          {"bufferId", std::to_string(bufferId)}};
+      context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+          "ended", onEndedCallbackId_, body);
+
+      if (buffers_.empty()) {
+        processingBus->zero(writeIndex, framesLeft);
+        vReadIndex_ = 0.0;
+        break;
+      }
+
+      vReadIndex_ = vReadIndex_ - buffer->getLength();
+      data = buffers_.front();
+      bufferId = data.first;
+      buffer = data.second;
+    }
+  }
+}
+
 } // namespace audioapi

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

@@ -17,19 +17,19 @@ class AudioParam;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
-    explicit AudioBufferQueueSourceNode(BaseAudioContext *context);
+    explicit AudioBufferQueueSourceNode(BaseAudioContext *context, bool pitchCorrection);
     ~AudioBufferQueueSourceNode() override;
 
     void stop(double when) override;
     void pause();
 
     std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-    void dequeueBuffer(const size_t bufferId);
+    void dequeueBuffer(size_t bufferId);
     void clearBuffers();
     void disable() override;
 
  protected:
-    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
     double getCurrentPosition() const override;
 
  private:
@@ -46,6 +46,12 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
             size_t startOffset,
             size_t offsetLength,
             float playbackRate) override;
+
+    void processWithInterpolation(
+            const std::shared_ptr<AudioBus>& processingBus,
+            size_t startOffset,
+            size_t offsetLength,
+            float playbackRate) override;
 };
 
 } // namespace audioapi

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
@@ -13,12 +13,11 @@ namespace audioapi {
 AudioBufferSourceNode::AudioBufferSourceNode(
     BaseAudioContext *context,
     bool pitchCorrection)
-    : AudioBufferBaseSourceNode(context),
+    : AudioBufferBaseSourceNode(context, pitchCorrection),
       loop_(false),
       loopSkip_(false),
       loopStart_(0),
-      loopEnd_(0),
-      pitchCorrection_(pitchCorrection) {
+      loopEnd_(0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
   alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
@@ -30,6 +29,8 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
+
+  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {
@@ -124,14 +125,29 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::processNode(
+void AudioBufferSourceNode::clearOnLoopEndedCallback() {
+  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "loopEnded", onLoopEndedCallbackId_);
+  onLoopEndedCallbackId_ = 0;
+}
+
+void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
+  onLoopEndedCallbackId_ = callbackId;
+}
+
+std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   if (auto locker = Locker::tryLock(getBufferLock())) {
     // No audio data to fill, zero the output and return.
     if (!alignedBus_) {
       processingBus->zero();
-      return;
+      return processingBus;
     }
 
     if (!pitchCorrection_) {
@@ -144,6 +160,8 @@ void AudioBufferSourceNode::processNode(
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferSourceNode::getCurrentPosition() const {
@@ -151,35 +169,19 @@ double AudioBufferSourceNode::getCurrentPosition() const {
       static_cast<int>(vReadIndex_), buffer_->getSampleRate());
 }
 
+void AudioBufferSourceNode::sendOnLoopEndedEvent() {
+  auto onLoopEndedCallbackId =
+      onLoopEndedCallbackId_.load(std::memory_order_acquire);
+  if (onLoopEndedCallbackId != 0) {
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId_, {});
+  }
+}
+
 /**
  * Helper functions
  */
 
-void AudioBufferSourceNode::processWithoutPitchCorrection(
-    const std::shared_ptr<AudioBus> &processingBus,
-    int framesToProcess) {
-  size_t startOffset = 0;
-  size_t offsetLength = 0;
-
-  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-
-  if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
-    processingBus->zero();
-    return;
-  }
-
-  if (std::fabs(computedPlaybackRate) == 1.0) {
-    processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
-  } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, computedPlaybackRate);
-  }
-
-  sendOnPositionChangedEvent();
-}
-
 void AudioBufferSourceNode::processWithoutInterpolation(
     const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
@@ -243,6 +245,8 @@ void AudioBufferSourceNode::processWithoutInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 
@@ -304,23 +308,12 @@ void AudioBufferSourceNode::processWithInterpolation(
         playbackState_ = PlaybackState::STOP_SCHEDULED;
         break;
       }
+
+      sendOnLoopEndedEvent();
     }
   }
 }
 
-float AudioBufferSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
-  auto time = context_->getCurrentTime();
-
-  auto sampleRateFactor =
-      alignedBus_->getSampleRate() / context_->getSampleRate();
-  auto playbackRate =
-      playbackRateParam_->processKRateParam(framesToProcess, time);
-  auto detune = std::pow(
-      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
-
-  return playbackRate * sampleRateFactor * detune;
-}
-
 double AudioBufferSourceNode::getVirtualStartFrame() {
   auto loopStartFrame = loopStart_ * context_->getSampleRate();
 

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

@@ -34,8 +34,11 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
+  void clearOnLoopEndedCallback();
+  void setOnLoopEndedCallbackId(uint64_t callbackId);
+
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
   double getCurrentPosition() const override;
 
  private:
@@ -45,15 +48,12 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   double loopStart_;
   double loopEnd_;
 
-  // pitch correction
-  bool pitchCorrection_;
-
   // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
   std::shared_ptr<AudioBus> alignedBus_;
 
-  void processWithoutPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
-                                     int framesToProcess);
+  std::atomic<uint64_t> onLoopEndedCallbackId_ = 0; // 0 means no callback
+  void sendOnLoopEndedEvent();
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
@@ -65,9 +65,7 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
       const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,
       size_t offsetLength,
-      float playbackRate);
-
-  float getComputedPlaybackRateValue(int framesToProcess);
+      float playbackRate) override;
 
   double getVirtualStartFrame();
   double getVirtualEndFrame();

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

@@ -17,12 +17,7 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
 }
 
 AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  if (onEndedCallbackId_ != 0 &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->unregisterHandler(
-        "ended", onEndedCallbackId_);
-    onEndedCallbackId_ = 0;
-  }
+  clearOnEndedCallback();
 }
 
 void AudioScheduledSourceNode::start(double when) {

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

@@ -27,7 +27,7 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  virtual ~AudioScheduledSourceNode();
+  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

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

@@ -0,0 +1,53 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context) {
+  offsetParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
+  return offsetParam_;
+}
+
+std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  auto offsetBus = offsetParam_->processARateParam(
+      framesToProcess, context_->getCurrentTime());
+
+  auto offsetChannelData = offsetBus->getChannel(0)->getData();
+
+  for (int channel = 0; channel < processingBus->getNumberOfChannels();
+       ++channel) {
+    auto outputChannelData = processingBus->getChannel(channel)->getData();
+
+    std::copy(
+        offsetChannelData + startOffset,
+        offsetChannelData + startOffset + offsetLength,
+        outputChannelData + startOffset);
+  }
+
+  if (isStopScheduled()) {
+    handleStopScheduled();
+  }
+
+  return processingBus;
+}
+} // namespace audioapi

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+
+#include <cmath>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class ConstantSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit ConstantSourceNode(BaseAudioContext *context);
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioParam> offsetParam_;
+};
+} // namespace audioapi

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

@@ -21,6 +21,9 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+
   isInitialized_ = true;
 }
 
@@ -47,7 +50,7 @@ void OscillatorNode::setPeriodicWave(
   type_ = OscillatorType::CUSTOM;
 }
 
-void OscillatorNode::processNode(
+std::shared_ptr<AudioBus> OscillatorNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
@@ -57,7 +60,7 @@ void OscillatorNode::processNode(
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   auto time = context_->getCurrentTime() +
@@ -89,6 +92,8 @@ void OscillatorNode::processNode(
   }
 
   handleStopScheduled();
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -24,7 +24,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;