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

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,365 +1,9 @@
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
-#include <audioapi/HostObjects/WorkletNodeHostObject.h>
-#include <audioapi/HostObjects/WorkletProcessingNodeHostObject.h>
-#include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
-#include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
-#include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
-#include <audioapi/HostObjects/effects/GainNodeHostObject.h>
-#include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
-#include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
-#include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
-#include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
-#include <audioapi/HostObjects/sources/OscillatorNodeHostObject.h>
-#include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
-#include <audioapi/HostObjects/sources/StreamerNodeHostObject.h>
-#include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
-#include <audioapi/core/BaseAudioContext.h>
-
+// Explicitly define destructors here, as they to exist in order to act as a
+// "key function" for the audio classes - this allow for RTTI to work
+// properly across dynamic library boundaries (i.e. dynamic_cast that is used by
+// isHostObject method), android specific issue
 namespace audioapi {
-
-BaseAudioContextHostObject::BaseAudioContextHostObject(
-    const std::shared_ptr<BaseAudioContext> &context,
-    jsi::Runtime *runtime,
-    const std::shared_ptr<react::CallInvoker> &callInvoker)
-    : context_(context), callInvoker_(callInvoker) {
-  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
-
-  addGetters(
-      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
-      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, state),
-      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, sampleRate),
-      JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime));
-
-  addFunctions(
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletSourceNode),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletNode),
-      JSI_EXPORT_FUNCTION(
-          BaseAudioContextHostObject, createWorkletProcessingNode),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStreamer),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConstantSource),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioData),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource),
-      JSI_EXPORT_FUNCTION(
-          BaseAudioContextHostObject, decodePCMAudioDataInBase64));
-}
-
-JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
-  auto destination = std::make_shared<AudioDestinationNodeHostObject>(
-      context_->getDestination());
-  return jsi::Object::createFromHostObject(runtime, destination);
-}
-
-JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, state) {
-  return jsi::String::createFromUtf8(runtime, context_->getState());
-}
-
-JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, sampleRate) {
-  return {context_->getSampleRate()};
-}
-
-JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, currentTime) {
-  return {context_->getCurrentTime()};
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
-#if RN_AUDIO_API_ENABLE_WORKLETS
-  auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
-  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
-  auto shouldUseUiRuntime = args[1].getBool();
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->runtimeRegistry_.uiRuntime;
-  } else {
-    workletRuntime = context_->runtimeRegistry_.audioRuntime;
-  }
-
-  auto workletSourceNode =
-      context_->createWorkletSourceNode(shareableWorklet, workletRuntime);
-  auto workletSourceNodeHostObject =
-      std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletSourceNodeHostObject);
-#endif
-  return jsi::Value::undefined();
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
-#if RN_AUDIO_API_ENABLE_WORKLETS
-  auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
-
-  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
-  auto shouldUseUiRuntime = args[1].getBool();
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->runtimeRegistry_.uiRuntime;
-  } else {
-    workletRuntime = context_->runtimeRegistry_.audioRuntime;
-  }
-  auto bufferLength = static_cast<size_t>(args[2].getNumber());
-  auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
-
-  auto workletNode = context_->createWorkletNode(
-      shareableWorklet, workletRuntime, bufferLength, inputChannelCount);
-  auto workletNodeHostObject =
-      std::make_shared<WorkletNodeHostObject>(workletNode);
-  return jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
-#endif
-  return jsi::Value::undefined();
-}
-
-JSI_HOST_FUNCTION_IMPL(
-    BaseAudioContextHostObject,
-    createWorkletProcessingNode) {
-#if RN_AUDIO_API_ENABLE_WORKLETS
-  auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
-
-  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
-  auto shouldUseUiRuntime = args[1].getBool();
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->runtimeRegistry_.uiRuntime;
-  } else {
-    workletRuntime = context_->runtimeRegistry_.audioRuntime;
-  }
-
-  auto workletProcessingNode =
-      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime);
-  auto workletProcessingNodeHostObject =
-      std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletProcessingNodeHostObject);
-#endif
-  return jsi::Value::undefined();
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
-  auto recorderAdapter = context_->createRecorderAdapter();
-  auto recorderAdapterHostObject =
-      std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
-  return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
-  auto oscillator = context_->createOscillator();
-  auto oscillatorHostObject =
-      std::make_shared<OscillatorNodeHostObject>(oscillator);
-  return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
-  auto streamer = context_->createStreamer();
-  auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
-  auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
-  object.setExternalMemoryPressure(
-      runtime, StreamerNodeHostObject::getSizeInBytes());
-  return object;
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
-  auto constantSource = context_->createConstantSource();
-  auto constantSourceHostObject =
-      std::make_shared<ConstantSourceNodeHostObject>(constantSource);
-  return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
-  auto gain = context_->createGain();
-  auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
-  return jsi::Object::createFromHostObject(runtime, gainHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
-  auto stereoPanner = context_->createStereoPanner();
-  auto stereoPannerHostObject =
-      std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
-  return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
-  auto biquadFilter = context_->createBiquadFilter();
-  auto biquadFilterHostObject =
-      std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
-  return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferSource(pitchCorrection);
-  auto bufferSourceHostObject =
-      std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
-  return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferQueueSource(pitchCorrection);
-  auto bufferStreamSourceHostObject =
-      std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
-  return jsi::Object::createFromHostObject(
-      runtime, bufferStreamSourceHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
-  auto numberOfChannels = static_cast<int>(args[0].getNumber());
-  auto length = static_cast<size_t>(args[1].getNumber());
-  auto sampleRate = static_cast<float>(args[2].getNumber());
-  auto buffer =
-      BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
-  auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
-
-  auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
-  jsiObject.setExternalMemoryPressure(
-      runtime, bufferHostObject->getSizeInBytes());
-
-  return jsiObject;
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
-  auto arrayBufferReal = args[0]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
-  auto real = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
-  auto length = static_cast<int>(arrayBufferReal.size(runtime));
-
-  auto arrayBufferImag = args[1]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
-  auto imag = reinterpret_cast<float *>(arrayBufferImag.data(runtime));
-
-  auto disableNormalization = args[2].getBool();
-
-  auto complexData = std::vector<std::complex<float>>(length);
-
-  for (size_t i = 0; i < length; i++) {
-    complexData[i] = std::complex<float>(
-        static_cast<float>(real[i]), static_cast<float>(imag[i]));
-  }
-
-  auto periodicWave =
-      context_->createPeriodicWave(complexData, disableNormalization, length);
-  auto periodicWaveHostObject =
-      std::make_shared<PeriodicWaveHostObject>(periodicWave);
-
-  return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
-  auto analyser = context_->createAnalyser();
-  auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
-  return jsi::Object::createFromHostObject(runtime, analyserHostObject);
-}
-
-JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, decodeAudioDataSource) {
-  auto sourcePath = args[0].getString(runtime).utf8(runtime);
-
-  auto promise = promiseVendor_->createPromise(
-      [this, sourcePath](std::shared_ptr<Promise> promise) {
-        std::thread([this, sourcePath, promise = std::move(promise)]() {
-          auto results = context_->decodeAudioDataSource(sourcePath);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          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(BaseAudioContextHostObject, decodeAudioData) {
-  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 promise = promiseVendor_->createPromise(
-      [this, data, size](std::shared_ptr<Promise> promise) {
-        std::thread([this, data, size, promise = std::move(promise)]() {
-          auto results = context_->decodeAudioData(data, size);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          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(BaseAudioContextHostObject, decodePCMAudioDataInBase64) {
-  auto b64 = args[0].getString(runtime).utf8(runtime);
-  auto playbackSpeed = static_cast<float>(args[1].getNumber());
-
-  auto promise = promiseVendor_->createPromise(
-      [this, b64, playbackSpeed](std::shared_ptr<Promise> promise) {
-        std::thread([this, b64, playbackSpeed, promise = std::move(promise)]() {
-          auto results = context_->decodeWithPCMInBase64(b64, playbackSpeed);
-
-          if (!results) {
-            promise->reject("Failed to decode audio data source.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(results);
-
-          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
+BaseAudioContextHostObject::~BaseAudioContextHostObject() = default;
+}

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

@@ -2,6 +2,19 @@
 
 #include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/jsi/JsiPromise.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/AudioBufferSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioBufferQueueSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioDestinationNodeHostObject.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/HostObjects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/GainNodeHostObject.h>
+#include <audioapi/HostObjects/OscillatorNodeHostObject.h>
+#include <audioapi/HostObjects/PeriodicWaveHostObject.h>
+#include <audioapi/HostObjects/StereoPannerNodeHostObject.h>
+#include <audioapi/HostObjects/AnalyserNodeHostObject.h>
+#include <audioapi/HostObjects/RecorderAdapterNodeHostObject.h>
+#include <audioapi/HostObjects/StreamerNodeHostObject.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -12,40 +25,239 @@
 namespace audioapi {
 using namespace facebook;
 
-class BaseAudioContext;
-
 class BaseAudioContextHostObject : public JsiHostObject {
  public:
   explicit BaseAudioContextHostObject(
       const std::shared_ptr<BaseAudioContext> &context,
       jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &callInvoker);
-
-  JSI_PROPERTY_GETTER_DECL(destination);
-  JSI_PROPERTY_GETTER_DECL(state);
-  JSI_PROPERTY_GETTER_DECL(sampleRate);
-  JSI_PROPERTY_GETTER_DECL(currentTime);
-
-  JSI_HOST_FUNCTION_DECL(createWorkletSourceNode);
-  JSI_HOST_FUNCTION_DECL(createWorkletNode);
-  JSI_HOST_FUNCTION_DECL(createWorkletProcessingNode);
-  JSI_HOST_FUNCTION_DECL(createRecorderAdapter);
-  JSI_HOST_FUNCTION_DECL(createOscillator);
-  JSI_HOST_FUNCTION_DECL(createStreamer);
-  JSI_HOST_FUNCTION_DECL(createConstantSource);
-  JSI_HOST_FUNCTION_DECL(createGain);
-  JSI_HOST_FUNCTION_DECL(createStereoPanner);
-  JSI_HOST_FUNCTION_DECL(createBiquadFilter);
-  JSI_HOST_FUNCTION_DECL(createBufferSource);
-  JSI_HOST_FUNCTION_DECL(createBufferQueueSource);
-  JSI_HOST_FUNCTION_DECL(createBuffer);
-  JSI_HOST_FUNCTION_DECL(createPeriodicWave);
-  JSI_HOST_FUNCTION_DECL(createAnalyser);
-  JSI_HOST_FUNCTION_DECL(decodeAudioDataSource);
-  JSI_HOST_FUNCTION_DECL(decodeAudioData);
-  JSI_HOST_FUNCTION_DECL(decodePCMAudioDataInBase64);
-
-  std::shared_ptr<BaseAudioContext> context_;
+      const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : context_(context), callInvoker_(callInvoker) {
+      promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
+        JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, state),
+        JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, sampleRate),
+        JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStreamer),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioData),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodePCMAudioDataInBase64));
+  }
+
+  ~BaseAudioContextHostObject() override;
+
+  JSI_PROPERTY_GETTER(destination) {
+    auto destination = std::make_shared<AudioDestinationNodeHostObject>(
+        context_->getDestination());
+    return jsi::Object::createFromHostObject(runtime, destination);
+  }
+
+  JSI_PROPERTY_GETTER(state) {
+    return jsi::String::createFromUtf8(runtime, context_->getState());
+  }
+
+  JSI_PROPERTY_GETTER(sampleRate) {
+    return {context_->getSampleRate()};
+  }
+
+  JSI_PROPERTY_GETTER(currentTime) {
+    return {context_->getCurrentTime()};
+  }
+
+  JSI_HOST_FUNCTION(createRecorderAdapter) {
+    auto recorderAdapter = context_->createRecorderAdapter();
+    auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
+    return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createOscillator) {
+    auto oscillator = context_->createOscillator();
+    auto oscillatorHostObject =
+        std::make_shared<OscillatorNodeHostObject>(oscillator);
+    return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createStreamer) {
+    auto streamer = context_->createStreamer();
+    auto streamerHostObject =
+        std::make_shared<StreamerNodeHostObject>(streamer);
+    auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
+    object.setExternalMemoryPressure(runtime, StreamerNode::getEstimatedSize());
+    return object;
+  }
+
+  JSI_HOST_FUNCTION(createGain) {
+    auto gain = context_->createGain();
+    auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
+    return jsi::Object::createFromHostObject(runtime, gainHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createStereoPanner) {
+    auto stereoPanner = context_->createStereoPanner();
+    auto stereoPannerHostObject =
+        std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
+    return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createBiquadFilter) {
+    auto biquadFilter = context_->createBiquadFilter();
+    auto biquadFilterHostObject =
+        std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
+    return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createBufferSource) {
+    auto pitchCorrection = args[0].asBool();
+    auto bufferSource = context_->createBufferSource(pitchCorrection);
+    auto bufferSourceHostObject =
+        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
+    return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createBufferQueueSource) {
+      auto bufferSource = context_->createBufferQueueSource();
+      auto bufferStreamSourceHostObject =
+              std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
+      return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createBuffer) {
+    auto numberOfChannels = static_cast<int>(args[0].getNumber());
+    auto length = static_cast<size_t>(args[1].getNumber());
+    auto sampleRate = static_cast<float>(args[2].getNumber());
+    auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
+    auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+
+    auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
+    jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
+
+    return jsiObject;
+  }
+
+  JSI_HOST_FUNCTION(createPeriodicWave) {
+    auto arrayBufferReal = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto real = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
+    auto length = static_cast<int>(arrayBufferReal.size(runtime));
+
+    auto arrayBufferImag = args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto imag = reinterpret_cast<float *>(arrayBufferImag.data(runtime));
+
+    auto disableNormalization = args[2].getBool();
+
+    auto complexData = std::vector<std::complex<float>>(length);
+
+    for (size_t i = 0; i < length; i++) {
+        complexData[i] = std::complex<float>(
+            static_cast<float>(real[i]),
+            static_cast<float>(imag[i]));
+    }
+
+    auto periodicWave = context_->createPeriodicWave(
+        complexData, disableNormalization, length);
+    auto periodicWaveHostObject =
+        std::make_shared<PeriodicWaveHostObject>(periodicWave);
+
+    return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createAnalyser) {
+    auto analyser = context_->createAnalyser();
+    auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
+    return jsi::Object::createFromHostObject(runtime, analyserHostObject);
+  }
+
+  JSI_HOST_FUNCTION(decodeAudioDataSource) {
+    auto sourcePath = args[0].getString(runtime).utf8(runtime);
+
+    auto promise = promiseVendor_->createPromise([this, sourcePath](std::shared_ptr<Promise> promise) {
+      std::thread([this, sourcePath, promise = std::move(promise)]() {
+        auto results = context_->decodeAudioDataSource(sourcePath);
+
+        if (!results) {
+          promise->reject("Failed to decode audio data source.");
+          return;
+        }
+
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+        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(decodeAudioData) {
+      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 promise = promiseVendor_->createPromise([this, data, size](std::shared_ptr<Promise> promise) {
+        std::thread([this, data, size, promise = std::move(promise)]() {
+          auto results = context_->decodeAudioData(data, size);
+
+          if (!results) {
+            promise->reject("Failed to decode audio data source.");
+            return;
+          }
+
+          auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+          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(decodePCMAudioDataInBase64) {
+        auto b64 = args[0].getString(runtime).utf8(runtime);
+        auto playbackSpeed = static_cast<float>(args[1].getNumber());
+
+        auto promise = promiseVendor_->createPromise([this, b64, playbackSpeed](std::shared_ptr<Promise> promise) {
+            std::thread([this, b64, playbackSpeed, promise = std::move(promise)]() {
+                auto results = context_->decodeWithPCMInBase64(b64, playbackSpeed);
+
+                if (!results) {
+                    promise->reject("Failed to decode audio data source.");
+                    return;
+                }
+
+                auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+                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;
+    }
+
+    std::shared_ptr<BaseAudioContext> context_;
 
  protected:
   std::shared_ptr<PromiseVendor> promiseVendor_;