react-native-audio-api 0.8.3-nightly-ea268f4-20251006 → 0.8.3

package/common/cpp/audioapi/HostObjects/BiquadFilterNodeHostObject.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class BiquadFilterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit BiquadFilterNodeHostObject(
+      const std::shared_ptr<BiquadFilterNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, frequency),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, detune),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, Q),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, gain),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, type));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
+
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(BiquadFilterNodeHostObject, type));
+  }
+
+  JSI_PROPERTY_GETTER(frequency) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getFrequencyParam());
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  JSI_PROPERTY_GETTER(detune) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto detuneParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getDetuneParam());
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  JSI_PROPERTY_GETTER(Q) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto QParam_ =
+        std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
+    return jsi::Object::createFromHostObject(runtime, QParam_);
+  }
+
+  JSI_PROPERTY_GETTER(gain) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto gainParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getGainParam());
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
+
+  JSI_PROPERTY_GETTER(type) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto type = biquadFilterNode->getType();
+    return jsi::String::createFromUtf8(runtime, type);
+  }
+
+  JSI_HOST_FUNCTION(getFrequencyResponse) {
+    auto arrayBufferFrequency = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto frequencyArray = reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+    auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
+
+    auto arrayBufferMag = args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
+
+    auto arrayBufferPhase = args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
+
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    biquadFilterNode->getFrequencyResponse(
+        frequencyArray, magResponseOut, phaseResponseOut, length);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_PROPERTY_SETTER(type) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    biquadFilterNode->setType(value.getString(runtime).utf8(runtime));
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/GainNodeHostObject.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/GainNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class GainNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit GainNodeHostObject(const std::shared_ptr<GainNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
+  }
+
+  JSI_PROPERTY_GETTER(gain) {
+    auto gainNode = std::static_pointer_cast<GainNode>(node_);
+    auto gainParam =
+        std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+    return jsi::Object::createFromHostObject(runtime, gainParam);
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
 #include <jsi/jsi.h>
@@ -10,17 +11,60 @@
 namespace audioapi {
 using namespace facebook;
 
-class OfflineAudioContext;
-
 class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit OfflineAudioContextHostObject(
           const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
           jsi::Runtime *runtime,
-          const std::shared_ptr<react::CallInvoker> &callInvoker);
+          const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
+    addFunctions(
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, startRendering));
+  }
+
+  JSI_HOST_FUNCTION(resume) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      audioContext->resume();
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(suspend) {
+    double when = args[0].getNumber();
+
+    auto promise = promiseVendor_->createPromise([this, when](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      OfflineAudioContextSuspendCallback callback = [promise]() {
+        promise->resolve([](jsi::Runtime &runtime) {
+          return jsi::Value::undefined();
+        });
+      };
+      audioContext->suspend(when, callback);
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(startRendering) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+
+      OfflineAudioContextResultCallback callback =
+          [promise](const std::shared_ptr<AudioBuffer>& audioBuffer) -> void {
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+        promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+          return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        });
+      };
+
+      audioContext->startRendering(callback);
+    });
 
-  JSI_HOST_FUNCTION_DECL(resume);
-  JSI_HOST_FUNCTION_DECL(suspend);
-  JSI_HOST_FUNCTION_DECL(startRendering);
+    return promise;
+  }
 };
 } // namespace audioapi

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

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/PeriodicWaveHostObject.h>
+#include <audioapi/core/sources/OscillatorNode.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit 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(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(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(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto waveType = oscillatorNode->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
+  }
+
+  JSI_HOST_FUNCTION(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(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    oscillatorNode->setType(value.getString(runtime).utf8(runtime));
+  }
+};
+} // namespace audioapi

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

@@ -16,7 +16,8 @@ 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/StereoPannerNodeHostObject.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/StereoPannerNode.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class StereoPannerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit StereoPannerNodeHostObject(
+      const std::shared_ptr<StereoPannerNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
+  }
+
+  JSI_PROPERTY_GETTER(pan) {
+    auto stereoPannerNode = std::static_pointer_cast<StereoPannerNode>(node_);
+    auto panParam_ =
+        std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
+    return jsi::Object::createFromHostObject(runtime, panParam_);
+  }
+};
+} // namespace audioapi

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/PeriodicWaveHostObject.h>
+#include <audioapi/core/sources/StreamerNode.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit StreamerNodeHostObject(
+          const std::shared_ptr<StreamerNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+    addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
+  }
+
+  JSI_HOST_FUNCTION(initialize) {
+    auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
+    auto path = args[0].getString(runtime).utf8(runtime);
+    auto result = streamerNode->initialize(path);
+    return jsi::Value(result);
+  }
+};
+} // namespace audioapi

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

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

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

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

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/utils/Constants.h>
+#include <audioapi/core/Constants.h>
 
 #include <memory>
 #include <string>

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) -
-            k);
+                (endTime - startTime));
         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/utils/AudioParamEventQueue.h>
+#include <audioapi/core/AudioParamEventQueue.h>
 
 #include <cstddef>
 #include <utility>

package/common/cpp/audioapi/core/{utils/AudioParamEventQueue.cpp → AudioParamEventQueue.cpp}

@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/AudioParamEventQueue.h>
+#include <audioapi/core/AudioParamEventQueue.h>
 
 namespace audioapi {
 
@@ -31,12 +31,12 @@ bool AudioParamEventQueue::popFront(ParamChangeEvent &event) {
 
 void AudioParamEventQueue::cancelScheduledValues(double cancelTime) {
   while (!eventQueue_.isEmpty()) {
-    auto &back = eventQueue_.peekBack();
-    if (back.getEndTime() < cancelTime) {
+    auto &front = eventQueue_.peekBack();
+    if (front.getEndTime() < cancelTime) {
       break;
     }
-    if (back.getStartTime() >= cancelTime ||
-        back.getType() == ParamChangeEventType::SET_VALUE_CURVE) {
+    if (front.getStartTime() >= cancelTime ||
+        front.getType() == ParamChangeEventType::SET_VALUE_CURVE) {
       eventQueue_.popBack();
     }
   }
@@ -46,8 +46,8 @@ void AudioParamEventQueue::cancelAndHoldAtTime(
     double cancelTime,
     double &endTimeCache) {
   while (!eventQueue_.isEmpty()) {
-    auto &back = eventQueue_.peekBack();
-    if (back.getEndTime() < cancelTime || back.getStartTime() <= cancelTime) {
+    auto &front = eventQueue_.peekBack();
+    if (front.getEndTime() < cancelTime || front.getStartTime() <= cancelTime) {
       break;
     }
     eventQueue_.popBack();
@@ -59,12 +59,6 @@ void AudioParamEventQueue::cancelAndHoldAtTime(
   }
 
   auto &back = eventQueue_.peekBackMut();
-  back.setEndValue(back.getCalculateValue()(
-      back.getStartTime(),
-      back.getEndTime(),
-      back.getStartValue(),
-      back.getEndValue(),
-      cancelTime));
   back.setEndTime(std::min(cancelTime, back.getEndTime()));
 }
 

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

@@ -4,19 +4,14 @@
 #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>
@@ -26,13 +21,11 @@ namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
-    const RuntimeRegistry &runtimeRegistry) {
+        &audioEventHandlerRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 
   audioEventHandlerRegistry_ = audioEventHandlerRegistry;
-  runtimeRegistry_ = runtimeRegistry;
 }
 
 std::string BaseAudioContext::getState() {
@@ -65,36 +58,6 @@ 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);
@@ -107,12 +70,6 @@ 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);
@@ -148,9 +105,8 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
 }
 
 std::shared_ptr<AudioBufferQueueSourceNode>
-BaseAudioContext::createBufferQueueSource(bool pitchCorrection) {
-  auto bufferSource =
-      std::make_shared<AudioBufferQueueSourceNode>(this, pitchCorrection);
+BaseAudioContext::createBufferQueueSource() {
+  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this);
   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,7 +20,6 @@ class GainNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
-class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
@@ -32,14 +31,11 @@ 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, const RuntimeRegistry &runtimeRegistry);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -49,17 +45,13 @@ 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(bool pitchCorrection);
+  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource();
   static std::shared_ptr<AudioBuffer>
   createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
@@ -97,11 +89,10 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
-  [[nodiscard]] virtual bool isDriverRunning() const = 0;
+  virtual bool isDriverRunning() const = 0;
 
  public:
     std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
-    RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/{utils/Constants.h → Constants.h}

@@ -16,9 +16,4 @@ static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 static constexpr float PI = static_cast<float>(M_PI);
-
-// buffer sizes
-static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
-static constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;
-static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE = 32;
 } // 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,9 +23,8 @@ OfflineAudioContext::OfflineAudioContext(
     size_t length,
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
-    const RuntimeRegistry &runtimeRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
+        &audioEventHandlerRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

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

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

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;