react-native-audio-api 0.8.3-nightly-ea268f4-20251006 → 0.9.0-nightly-96a5bcd-20251007

package/common/cpp/audioapi/HostObjects/utils/AudioDecoderHostObject.cpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
+#include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+AudioDecoderHostObject::AudioDecoderHostObject(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithPCMInBase64),
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithFilePath),
+      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithMemoryBlock));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithMemoryBlock) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto data = arrayBuffer.data(runtime);
+  auto size = static_cast<int>(arrayBuffer.size(runtime));
+
+  auto sampleRate = args[1].getNumber();
+
+  return promiseVendor_->createAsyncPromise(
+      [data, size, sampleRate](
+          jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+        auto result =
+            AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
+
+        if (!result) {
+          return std::string("Failed to decode audio data.");
+        }
+
+        auto audioBufferHostObject =
+            std::make_shared<AudioBufferHostObject>(result);
+
+        auto jsiObject =
+            jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        jsiObject.setExternalMemoryPressure(
+            runtime, audioBufferHostObject->getSizeInBytes());
+        return jsiObject;
+      });
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithFilePath) {
+  auto sourcePath = args[0].getString(runtime).utf8(runtime);
+  auto sampleRate = args[1].getNumber();
+
+  return promiseVendor_->createAsyncPromise(
+      [sourcePath, sampleRate](
+          jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+        auto result = AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
+
+        if (!result) {
+          return std::string("Failed to decode audio data source.");
+        }
+
+        auto audioBufferHostObject =
+            std::make_shared<AudioBufferHostObject>(result);
+
+        auto jsiObject =
+            jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        jsiObject.setExternalMemoryPressure(
+            runtime, audioBufferHostObject->getSizeInBytes());
+        return jsiObject;
+      });
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithPCMInBase64) {
+  auto b64 = args[0].getString(runtime).utf8(runtime);
+  auto inputSampleRate = args[1].getNumber();
+  auto inputChannelCount = args[2].getNumber();
+  auto interleaved = args[3].getBool();
+
+  return promiseVendor_->createAsyncPromise(
+      [b64, inputSampleRate, inputChannelCount, interleaved](
+          jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+        auto result = AudioDecoder::decodeWithPCMInBase64(
+            b64, inputSampleRate, inputChannelCount, interleaved);
+
+        if (!result) {
+          return std::string("Failed to decode audio data source.");
+        }
+
+        auto audioBufferHostObject =
+            std::make_shared<AudioBufferHostObject>(result);
+
+        auto jsiObject =
+            jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        jsiObject.setExternalMemoryPressure(
+            runtime, audioBufferHostObject->getSizeInBytes());
+        return jsiObject;
+      });
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioDecoderHostObject : public JsiHostObject {
+ public:
+  explicit AudioDecoderHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  JSI_HOST_FUNCTION_DECL(decodeWithMemoryBlock);
+  JSI_HOST_FUNCTION_DECL(decodeWithFilePath);
+  JSI_HOST_FUNCTION_DECL(decodeWithPCMInBase64);
+
+ private:
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+};
+} // namespace audioapi

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

@@ -6,7 +6,6 @@
 
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
@@ -26,7 +25,6 @@ AudioContext::AudioContext(
 #endif
 
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
   if (initSuspended) {
     playerHasBeenStarted_ = false;

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

@@ -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/BaseAudioContext.cpp

@@ -176,41 +176,6 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
-std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &path) {
-  auto audioBus = audioDecoder_->decodeWithFilePath(path);
-
-  if (!audioBus) {
-    return nullptr;
-  }
-
-  return std::make_shared<AudioBuffer>(audioBus);
-}
-
-std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
-    const void *data,
-    size_t size) {
-  auto audioBus = audioDecoder_->decodeWithMemoryBlock(data, size);
-
-  if (!audioBus) {
-    return nullptr;
-  }
-
-  return std::make_shared<AudioBuffer>(audioBus);
-}
-
-std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
-    const std::string &data,
-    float playbackSpeed) {
-  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
-
-  if (!audioBus) {
-    return nullptr;
-  }
-
-  return std::make_shared<AudioBuffer>(audioBus);
-}
-
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

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

@@ -3,15 +3,14 @@
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
-
+#include <cassert>
+#include <complex>
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
-#include <complex>
-#include <cstddef>
-#include <cassert>
 
 namespace audioapi {
 
@@ -27,7 +26,6 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
-class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
@@ -68,10 +66,6 @@ class BaseAudioContext {
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
 
-  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
-  std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
-  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
-
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
@@ -85,9 +79,7 @@ class BaseAudioContext {
 
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
-  std::shared_ptr<AudioDecoder> audioDecoder_ {};
-  // init in AudioContext or OfflineContext constructor
-  float sampleRate_ {};
+  float sampleRate_{};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

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

@@ -3,7 +3,6 @@
 #include <audioapi/core/AudioContext.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>
@@ -30,7 +29,6 @@ OfflineAudioContext::OfflineAudioContext(
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }

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/StereoPannerNode.cpp

@@ -19,18 +19,20 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
 }
 
-void StereoPannerNode::processNode(
+std::shared_ptr<AudioBus> StereoPannerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
 
-  AudioArray *left = processingBus->getChannelByType(AudioBus::ChannelLeft);
-  AudioArray *right = processingBus->getChannelByType(AudioBus::ChannelRight);
+  auto *inputLeft = processingBus->getChannelByType(AudioBus::ChannelLeft);
   auto panParamValues = panParam_->processARateParam(framesToProcess, time)
                             ->getChannel(0)
                             ->getData();
 
+  auto *outputLeft = audioBus_->getChannelByType(AudioBus::ChannelLeft);
+  auto *outputRight = audioBus_->getChannelByType(AudioBus::ChannelRight);
+
   // Input is mono
   if (processingBus->getNumberOfChannels() == 1) {
     for (int i = 0; i < framesToProcess; i++) {
@@ -40,13 +42,14 @@ void StereoPannerNode::processNode(
       auto gainL = static_cast<float>(cos(x * PI / 2));
       auto gainR = static_cast<float>(sin(x * PI / 2));
 
-      float input = (*left)[i];
+      float input = (*inputLeft)[i];
 
-      (*left)[i] = input * gainL;
-      (*right)[i] = input * gainR;
+      (*outputLeft)[i] = input * gainL;
+      (*outputRight)[i] = input * gainR;
       time += deltaTime;
     }
   } else { // Input is stereo
+    auto *inputRight = processingBus->getChannelByType(AudioBus::ChannelRight);
     for (int i = 0; i < framesToProcess; i++) {
       auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
       auto x = (pan <= 0 ? pan + 1 : pan);
@@ -54,20 +57,22 @@ void StereoPannerNode::processNode(
       auto gainL = static_cast<float>(cos(x * PI / 2));
       auto gainR = static_cast<float>(sin(x * PI / 2));
 
-      float inputL = (*left)[i];
-      float inputR = (*right)[i];
+      float inputL = (*inputLeft)[i];
+      float inputR = (*inputRight)[i];
 
       if (pan <= 0) {
-        (*left)[i] = inputL + inputR * gainL;
-        (*right)[i] = inputR * gainR;
+        (*outputLeft)[i] = inputL + inputR * gainL;
+        (*outputRight)[i] = inputR * gainR;
       } else {
-        (*left)[i] = inputL * gainL;
-        (*right)[i] = inputR + inputL * gainR;
+        (*outputLeft)[i] = inputL * gainL;
+        (*outputRight)[i] = inputR + inputL * gainR;
       }
 
       time += deltaTime;
     }
   }
+
+  return audioBus_;
 }
 
 } // namespace audioapi

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

@@ -18,7 +18,7 @@ class StereoPannerNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() 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> panParam_;

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

@@ -28,7 +28,7 @@ WorkletNode::~WorkletNode() {
   }
 }
 
-void WorkletNode::processNode(
+std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t processed = 0;
@@ -82,6 +82,8 @@ void WorkletNode::processNode(
           });
     }
   }
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -26,7 +26,7 @@ class WorkletNode : public AudioNode {
   ) : AudioNode(context) {}
 
  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 { return processingBus; }
 };
 #else
 
@@ -45,7 +45,7 @@ class WorkletNode : public AudioNode {
   ~WorkletNode() 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;
 
 
  private:

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

@@ -26,7 +26,7 @@ WorkletProcessingNode::WorkletProcessingNode(
   }
 }
 
-void WorkletProcessingNode::processNode(
+std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t channelCount = std::min(
@@ -84,6 +84,8 @@ void WorkletProcessingNode::processNode(
       std::memset(channelData, 0, framesToProcess * sizeof(float));
     }
   }
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -23,7 +23,7 @@ class WorkletProcessingNode : public AudioNode {
   ) : AudioNode(context) {}
 
  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 { return processingBus; }
 };
 #else
 
@@ -38,7 +38,7 @@ class WorkletProcessingNode : public AudioNode {
   );
 
  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:
   WorkletsRunner workletRunner_;

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

@@ -87,14 +87,14 @@ 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.
     if (buffers_.empty()) {
       processingBus->zero();
-      return;
+      return processingBus;
     }
 
     if (!pitchCorrection_) {
@@ -107,6 +107,8 @@ void AudioBufferQueueSourceNode::processNode(
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferQueueSourceNode::getCurrentPosition() const {

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

@@ -29,7 +29,7 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
     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:

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

@@ -140,14 +140,14 @@ void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
   onLoopEndedCallbackId_ = callbackId;
 }
 
-void AudioBufferSourceNode::processNode(
+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_) {
@@ -160,6 +160,8 @@ void AudioBufferSourceNode::processNode(
   } else {
     processingBus->zero();
   }
+
+  return processingBus;
 }
 
 double AudioBufferSourceNode::getCurrentPosition() const {

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

@@ -38,7 +38,7 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   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:

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

@@ -16,7 +16,7 @@ std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
   return offsetParam_;
 }
 
-void ConstantSourceNode::processNode(
+std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
@@ -26,7 +26,7 @@ void ConstantSourceNode::processNode(
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   auto offsetBus = offsetParam_->processARateParam(
@@ -47,5 +47,7 @@ void ConstantSourceNode::processNode(
   if (isStopScheduled()) {
     handleStopScheduled();
   }
+
+  return processingBus;
 }
 } // namespace audioapi

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

@@ -18,7 +18,7 @@ class ConstantSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() 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> offsetParam_;