react-native-audio-api 0.8.3 → 0.9.0

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioScheduledSourceNode;
+
+class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AudioScheduledSourceNodeHostObject(
+      const std::shared_ptr<AudioScheduledSourceNode> &node);
+
+  ~AudioScheduledSourceNodeHostObject() override;
+
+  JSI_PROPERTY_SETTER_DECL(onEnded);
+
+  JSI_HOST_FUNCTION_DECL(start);
+  JSI_HOST_FUNCTION_DECL(stop);
+};
+} // namespace audioapi

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

@@ -0,0 +1,19 @@
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+
+namespace audioapi {
+
+ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
+    const std::shared_ptr<ConstantSourceNode> &node)
+    : AudioScheduledSourceNodeHostObject(node) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(ConstantSourceNodeHostObject, offset));
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConstantSourceNodeHostObject, offset) {
+  auto constantSourceNode = std::static_pointer_cast<ConstantSourceNode>(node_);
+  auto offsetParam_ = std::make_shared<AudioParamHostObject>(
+      constantSourceNode->getOffsetParam());
+  return jsi::Object::createFromHostObject(runtime, offsetParam_);
+}
+} // namespace audioapi

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConstantSourceNode;
+
+class ConstantSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit ConstantSourceNodeHostObject(
+        const std::shared_ptr<ConstantSourceNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(offset);
+};
+} // namespace audioapi

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

@@ -0,0 +1,55 @@
+#include <audioapi/HostObjects/sources/OscillatorNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
+#include <audioapi/core/sources/OscillatorNode.h>
+
+namespace audioapi {
+
+OscillatorNodeHostObject::OscillatorNodeHostObject(
+    const std::shared_ptr<OscillatorNode> &node)
+    : AudioScheduledSourceNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
+      JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),
+      JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, type));
+
+  addFunctions(JSI_EXPORT_FUNCTION(OscillatorNodeHostObject, setPeriodicWave));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(OscillatorNodeHostObject, type));
+}
+
+JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, frequency) {
+  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+      oscillatorNode->getFrequencyParam());
+  return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, detune) {
+  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto detuneParam_ =
+      std::make_shared<AudioParamHostObject>(oscillatorNode->getDetuneParam());
+  return jsi::Object::createFromHostObject(runtime, detuneParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, type) {
+  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto waveType = oscillatorNode->getType();
+  return jsi::String::createFromUtf8(runtime, waveType);
+}
+
+JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
+  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto periodicWave =
+      args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(runtime);
+  oscillatorNode->setPeriodicWave(periodicWave->periodicWave_);
+  return jsi::Value::undefined();
+}
+
+JSI_PROPERTY_SETTER_IMPL(OscillatorNodeHostObject, type) {
+  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  oscillatorNode->setType(value.getString(runtime).utf8(runtime));
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class OscillatorNode;
+
+class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit OscillatorNodeHostObject(
+          const std::shared_ptr<OscillatorNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(frequency);
+  JSI_PROPERTY_GETTER_DECL(detune);
+  JSI_PROPERTY_GETTER_DECL(type);
+
+  JSI_HOST_FUNCTION_DECL(setPeriodicWave);
+
+  JSI_PROPERTY_SETTER_DECL(type);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/{RecorderAdapterNodeHostObject.h → sources/RecorderAdapterNodeHostObject.h}

@@ -16,8 +16,7 @@ class RecorderAdapterNodeHostObject : public AudioNodeHostObject {
  public:
     explicit RecorderAdapterNodeHostObject(
         const std::shared_ptr<RecorderAdapterNode> &node)
-        : AudioNodeHostObject(node) {
-        }
+        : AudioNodeHostObject(node) {}
 
  private:
     friend class AudioRecorderHostObject;

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

@@ -0,0 +1,22 @@
+#include <audioapi/HostObjects/sources/StreamerNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
+#include <audioapi/core/sources/StreamerNode.h>
+
+namespace audioapi {
+
+StreamerNodeHostObject::StreamerNodeHostObject(
+    const std::shared_ptr<StreamerNode> &node)
+    : AudioScheduledSourceNodeHostObject(node) {
+  addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
+}
+
+JSI_HOST_FUNCTION_IMPL(StreamerNodeHostObject, initialize) {
+  auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
+  auto path = args[0].getString(runtime).utf8(runtime);
+  auto result = streamerNode->initialize(path);
+  return {result};
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class StreamerNode;
+
+class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit StreamerNodeHostObject(
+          const std::shared_ptr<StreamerNode> &node);
+
+    [[nodiscard]] static inline size_t getSizeInBytes() {
+        return SIZE;
+    }
+
+  JSI_HOST_FUNCTION_DECL(initialize);
+
+ private:
+    static constexpr size_t SIZE = 4'000'000; // 4MB
+};
+} // namespace audioapi

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/core/sources/WorkletSourceNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WorkletSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit WorkletSourceNodeHostObject(const std::shared_ptr<WorkletSourceNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -14,8 +14,9 @@ AudioContext::AudioContext(
     float sampleRate,
     bool initSuspended,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry) {
+        &audioEventHandlerRegistry,
+    const RuntimeRegistry &runtimeRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry) {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(
       this->renderAudio(), sampleRate, destination_->getChannelCount());

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
 #include <functional>
@@ -14,7 +15,7 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   ~AudioContext() override;
 
   void close();

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

@@ -142,10 +142,10 @@ std::shared_ptr<AudioBus> AudioNode::processAudio(
   mixInputsBuses(processingBus);
 
   assert(processingBus != nullptr);
-  // Finally, process the node itself.
-  processNode(processingBus, framesToProcess);
 
-  return processingBus;
+  // Finally, process the node itself.
+  return processNode(processingBus, framesToProcess);
+  ;
 }
 
 bool AudioNode::isAlreadyProcessed() {

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

@@ -2,7 +2,7 @@
 
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 
 #include <memory>
 #include <string>
@@ -68,7 +68,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  virtual void processNode(const std::shared_ptr<AudioBus>&, int) = 0;
+  virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>&, int) = 0;
 
   bool isAlreadyProcessed();
   std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -219,9 +219,9 @@ void AudioParam::setValueCurveAtTime(
             (time - startTime)));
         // Calculate interpolation factor between adjacent array elements
         auto factor = static_cast<float>(
-            k -
             (time - startTime) * static_cast<double>(length - 1) /
-                (endTime - startTime));
+                (endTime - startTime) -
+            k);
         return dsp::linearInterpolate(values->data(), k, k + 1, factor);
       }
 

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

@@ -4,7 +4,7 @@
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/core/AudioParamEventQueue.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
 
 #include <cstddef>
 #include <utility>

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -4,14 +4,19 @@
 #include <audioapi/core/effects/BiquadFilterNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/effects/WorkletNode.h>
+#include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/sources/StreamerNode.h>
+#include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -21,11 +26,13 @@ namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry) {
+        &audioEventHandlerRegistry,
+    const RuntimeRegistry &runtimeRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 
   audioEventHandlerRegistry_ = audioEventHandlerRegistry;
+  runtimeRegistry_ = runtimeRegistry;
 }
 
 std::string BaseAudioContext::getState() {
@@ -58,6 +65,36 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
   return destination_;
 }
 
+std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+  auto workletSourceNode =
+      std::make_shared<WorkletSourceNode>(this, shareableWorklet, runtime);
+  nodeManager_->addSourceNode(workletSourceNode);
+  return workletSourceNode;
+}
+
+std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    size_t bufferLength,
+    size_t inputChannelCount) {
+  auto workletNode = std::make_shared<WorkletNode>(
+      this, shareableWorklet, runtime, bufferLength, inputChannelCount);
+  nodeManager_->addProcessingNode(workletNode);
+  return workletNode;
+}
+
+std::shared_ptr<WorkletProcessingNode>
+BaseAudioContext::createWorkletProcessingNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+  auto workletProcessingNode =
+      std::make_shared<WorkletProcessingNode>(this, shareableWorklet, runtime);
+  nodeManager_->addProcessingNode(workletProcessingNode);
+  return workletProcessingNode;
+}
+
 std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
   auto recorderAdapter = std::make_shared<RecorderAdapterNode>(this);
   nodeManager_->addProcessingNode(recorderAdapter);
@@ -70,6 +107,12 @@ std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
   return oscillator;
 }
 
+std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
+  auto constantSource = std::make_shared<ConstantSourceNode>(this);
+  nodeManager_->addSourceNode(constantSource);
+  return constantSource;
+}
+
 #ifndef AUDIO_API_TEST_SUITE
 std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
   auto streamer = std::make_shared<StreamerNode>(this);
@@ -105,8 +148,9 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
 }
 
 std::shared_ptr<AudioBufferQueueSourceNode>
-BaseAudioContext::createBufferQueueSource() {
-  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this);
+BaseAudioContext::createBufferQueueSource(bool pitchCorrection) {
+  auto bufferSource =
+      std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);
   return bufferSource;
 }

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

@@ -2,7 +2,7 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
-
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <functional>
 #include <memory>
@@ -20,6 +20,7 @@ class GainNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
+class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
@@ -31,11 +32,14 @@ class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
+class WorkletSourceNode;
+class WorkletNode;
+class WorkletProcessingNode;
 class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -45,13 +49,17 @@ class BaseAudioContext {
   std::shared_ptr<AudioDestinationNode> getDestination();
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
+  std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
+  std::shared_ptr<WorkletNode> createWorkletNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime, size_t bufferLength, size_t inputChannelCount);
+  std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
   std::shared_ptr<OscillatorNode> createOscillator();
+  std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
-  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource();
+  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
   static std::shared_ptr<AudioBuffer>
   createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
@@ -89,10 +97,11 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
-  virtual bool isDriverRunning() const = 0;
+  [[nodiscard]] virtual bool isDriverRunning() const = 0;
 
  public:
     std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
+    RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -1,11 +1,11 @@
 #include "OfflineAudioContext.h"
 
 #include <audioapi/core/AudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -23,8 +23,9 @@ OfflineAudioContext::OfflineAudioContext(
     size_t length,
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry),
+        &audioEventHandlerRegistry,
+    const RuntimeRegistry &runtimeRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "BaseAudioContext.h"
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <mutex>
 #include <map>
@@ -14,7 +15,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   ~OfflineAudioContext() override;
 
   void resume();

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -143,7 +143,7 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   }
 }
 
-void AnalyserNode::processNode(
+std::shared_ptr<AudioBus> AnalyserNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // Analyser should behave like a sniffer node, it should not modify the
@@ -156,6 +156,8 @@ void AnalyserNode::processNode(
       downMixBus_->getChannel(0)->getData(), framesToProcess, true);
 
   shouldDoFFTAnalysis_ = true;
+
+  return processingBus;
 }
 
 void AnalyserNode::doFFTAnalysis() {

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -39,7 +39,7 @@ class AnalyserNode : public AudioNode {
   void getByteTimeDomainData(uint8_t *data, int length);
 
  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:
   int fftSize_;

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.h

@@ -24,7 +24,7 @@ class AudioDestinationNode : public AudioNode {
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int) final {};
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int) final { return processingBus; };
 
  private:
   std::size_t currentSampleFrame_;

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -353,7 +353,7 @@ void BiquadFilterNode::applyFilter() {
   }
 }
 
-void BiquadFilterNode::processNode(
+std::shared_ptr<AudioBus> BiquadFilterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   int numChannels = processingBus->getNumberOfChannels();
@@ -393,6 +393,8 @@ void BiquadFilterNode::processNode(
   x2_ = x2;
   y1_ = y1;
   y2_ = y2;
+
+  return processingBus;
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/effects/BiquadFilterNode.h

@@ -33,7 +33,7 @@ class BiquadFilterNode : public AudioNode {
       int length);
 
  protected:
-  void processNode(
+  std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override;
 

package/common/cpp/audioapi/core/effects/GainNode.cpp

@@ -16,7 +16,7 @@ std::shared_ptr<AudioParam> GainNode::getGainParam() const {
   return gainParam_;
 }
 
-void GainNode::processNode(
+std::shared_ptr<AudioBus> GainNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   double time = context_->getCurrentTime();
@@ -28,6 +28,8 @@ void GainNode::processNode(
         processingBus->getChannel(i)->getData(),
         framesToProcess);
   }
+
+  return processingBus;
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/effects/GainNode.h

@@ -16,7 +16,7 @@ class GainNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 
  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> gainParam_;

package/common/cpp/audioapi/core/effects/PeriodicWave.cpp

@@ -26,8 +26,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 
 constexpr unsigned NumberOfOctaveBands = 3;