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

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

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

@@ -2,16 +2,15 @@
 
 #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 {
 
@@ -20,22 +19,25 @@ class GainNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
+class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
-class AudioDecoder;
 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 +47,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(
@@ -60,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();
@@ -77,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_;
 
@@ -89,10 +89,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,10 @@
 #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,13 +22,13 @@ 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) {
   sampleRate_ = sampleRate;
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }