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

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/HostObjects/utils/AudioDecoderHostObject.cpp

@@ -0,0 +1,133 @@
+#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();
+
+  auto promise = promiseVendor_->createPromise(
+      [data, size, sampleRate](std::shared_ptr<Promise> promise) {
+        std::thread([data, size, sampleRate, promise = std::move(promise)]() {
+          auto result =
+              AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          promise->resolve([audioBufferHostObject = std::move(
+                                audioBufferHostObject)](jsi::Runtime &runtime) {
+            auto jsiObject = jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject);
+            jsiObject.setExternalMemoryPressure(
+                runtime, audioBufferHostObject->getSizeInBytes());
+            return jsiObject;
+          });
+        }).detach();
+      });
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithFilePath) {
+  auto sourcePath = args[0].getString(runtime).utf8(runtime);
+  auto sampleRate = args[1].getNumber();
+
+  auto promise = promiseVendor_->createPromise(
+      [sourcePath, sampleRate](std::shared_ptr<Promise> promise) {
+        std::thread([sourcePath, sampleRate, promise = std::move(promise)]() {
+          auto result =
+              AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          promise->resolve([audioBufferHostObject = std::move(
+                                audioBufferHostObject)](jsi::Runtime &runtime) {
+            auto jsiObject = jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject);
+            jsiObject.setExternalMemoryPressure(
+                runtime, audioBufferHostObject->getSizeInBytes());
+            return jsiObject;
+          });
+        }).detach();
+      });
+
+  return promise;
+}
+
+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();
+
+  auto promise = promiseVendor_->createPromise(
+      [b64, inputSampleRate, inputChannelCount, interleaved](
+          std::shared_ptr<Promise> promise) {
+        std::thread([b64,
+                     inputSampleRate,
+                     inputChannelCount,
+                     interleaved,
+                     promise = std::move(promise)]() {
+          auto result = AudioDecoder::decodeWithPCMInBase64(
+              b64, inputSampleRate, inputChannelCount, interleaved);
+
+          if (!result) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          promise->resolve([audioBufferHostObject = std::move(
+                                audioBufferHostObject)](jsi::Runtime &runtime) {
+            auto jsiObject = jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject);
+            jsiObject.setExternalMemoryPressure(
+                runtime, audioBufferHostObject->getSizeInBytes());
+            return jsiObject;
+          });
+        }).detach();
+      });
+
+  return promise;
+}
+
+} // 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/HostObjects/utils/AudioStretcherHostObject.cpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/AudioStretcherHostObject.h>
+#include <audioapi/core/utils/AudioStretcher.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+
+AudioStretcherHostObject::AudioStretcherHostObject(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioStretcherHostObject, changePlaybackSpeed));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioStretcherHostObject, changePlaybackSpeed) {
+  auto audioBuffer =
+      args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  auto playbackSpeed = static_cast<float>(args[1].asNumber());
+
+  auto promise = promiseVendor_->createPromise(
+      [audioBuffer, playbackSpeed](std::shared_ptr<Promise> promise) {
+        std::thread([audioBuffer,
+                     playbackSpeed,
+                     promise = std::move(promise)]() {
+          auto result = AudioStretcher::changePlaybackSpeed(
+              *audioBuffer->audioBuffer_, playbackSpeed);
+
+          if (!result) {
+            promise->reject("Failed to change audio playback speed.");
+            return;
+          }
+
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(result);
+
+          promise->resolve([audioBufferHostObject = std::move(
+                                audioBufferHostObject)](jsi::Runtime &runtime) {
+            auto jsiObject = jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject);
+            jsiObject.setExternalMemoryPressure(
+                runtime, audioBufferHostObject->getSizeInBytes());
+            return jsiObject;
+          });
+        }).detach();
+      });
+  return promise;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/AudioStretcher.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioStretcherHostObject : public JsiHostObject {
+ public:
+  explicit AudioStretcherHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  JSI_HOST_FUNCTION_DECL(changePlaybackSpeed);
+
+ 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 {
@@ -14,8 +13,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());
@@ -25,7 +25,6 @@ AudioContext::AudioContext(
 #endif
 
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
   if (initSuspended) {
     playerHasBeenStarted_ = false;

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;
 }
@@ -132,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();
 }