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

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -6,12 +6,10 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 #include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
-#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
+#include <audioapi/HostObjects/AudioRecorderHostObject.h>
 
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
-
-#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/events/AudioEventHandlerRegistryHostObject.h>
 
 #include <memory>
 
@@ -21,15 +19,10 @@ using namespace facebook;
 
 class AudioAPIModuleInstaller {
  public:
-  static void injectJSIBindings(
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
-
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
+  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
     auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
@@ -40,16 +33,12 @@ class AudioAPIModuleInstaller {
   }
 
  private:
-  static jsi::Function getCreateAudioContextFunction(
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
+  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
+        [jsCallInvoker, audioEventHandlerRegistry](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -57,17 +46,8 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
           auto initSuspended = args[1].getBool();
+          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry);
 
-          #if RN_AUDIO_API_ENABLE_WORKLETS
-              auto runtimeRegistry = RuntimeRegistry{
-                  .uiRuntime = uiRuntime,
-                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[2])
-              };
-          #else
-              auto runtimeRegistry = RuntimeRegistry{};
-          #endif
-
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, runtimeRegistry);
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
 
@@ -76,16 +56,12 @@ class AudioAPIModuleInstaller {
         });
   }
 
-  static jsi::Function getCreateOfflineAudioContextFunction(
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
+  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
+        [jsCallInvoker, audioEventHandlerRegistry](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -94,27 +70,16 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-            #if RN_AUDIO_API_ENABLE_WORKLETS
-                auto runtimeRegistry = RuntimeRegistry{
-                    .uiRuntime = uiRuntime,
-                    .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])
-                };
-            #else
-            auto runtimeRegistry = RuntimeRegistry{};
-            #endif
-
-            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
-            auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-                offlineAudioContext, &runtime, jsCallInvoker);
-
-            return jsi::Object::createFromHostObject(
-                runtime, audioContextHostObject);
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry);
+          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+              offlineAudioContext, &runtime, jsCallInvoker);
+
+          return jsi::Object::createFromHostObject(
+              runtime, audioContextHostObject);
         });
   }
 
-  static jsi::Function getCreateAudioRecorderFunction(
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -129,7 +94,7 @@ class AudioAPIModuleInstaller {
           auto sampleRate = static_cast<float>(options.getProperty(runtime, "sampleRate").getNumber());
           auto bufferLength = static_cast<int>(options.getProperty(runtime, "bufferLengthInSamples").getNumber());
 
-          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry, sampleRate, bufferLength);
+          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(&runtime, audioEventHandlerRegistry, sampleRate, bufferLength);
 
           return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
         });

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

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AnalyserNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant),
+        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, window));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getFloatFrequencyData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getByteFrequencyData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getFloatTimeDomainData),
+        JSI_EXPORT_FUNCTION(
+            AnalyserNodeHostObject, getByteTimeDomainData));
+
+    addSetters(
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, fftSize),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, minDecibels),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, maxDecibels),
+        JSI_EXPORT_PROPERTY_SETTER(
+            AnalyserNodeHostObject, smoothingTimeConstant),
+        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, window));
+  }
+
+  JSI_PROPERTY_GETTER(fftSize) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {static_cast<int>(analyserNode->getFftSize())};
+  }
+
+  JSI_PROPERTY_GETTER(frequencyBinCount) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {static_cast<int>(analyserNode->getFrequencyBinCount())};
+  }
+
+  JSI_PROPERTY_GETTER(minDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getMinDecibels()};
+  }
+
+  JSI_PROPERTY_GETTER(maxDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getMaxDecibels()};
+  }
+
+  JSI_PROPERTY_GETTER(smoothingTimeConstant) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    return {analyserNode->getSmoothingTimeConstant()};
+  }
+
+  JSI_PROPERTY_GETTER(window) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto windowType = analyserNode->getWindowType();
+    return jsi::String::createFromUtf8(runtime, windowType);
+  }
+
+  JSI_HOST_FUNCTION(getFloatFrequencyData) {
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getFloatFrequencyData(data, length);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getByteFrequencyData) {
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = arrayBuffer.data(runtime);
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getByteFrequencyData(data, length);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getFloatTimeDomainData) {
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getFloatTimeDomainData(data, length);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getByteTimeDomainData) {
+    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+    auto data = arrayBuffer.data(runtime);
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->getByteTimeDomainData(data, length);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_PROPERTY_SETTER(fftSize) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto fftSize = static_cast<int>(value.getNumber());
+    analyserNode->setFftSize(fftSize);
+  }
+
+  JSI_PROPERTY_SETTER(minDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto minDecibels = static_cast<float>(value.getNumber());
+    analyserNode->setMinDecibels(minDecibels);
+  }
+
+  JSI_PROPERTY_SETTER(maxDecibels) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+      auto maxDecibels = static_cast<float>(value.getNumber());
+      analyserNode->setMaxDecibels(maxDecibels);
+  }
+
+  JSI_PROPERTY_SETTER(smoothingTimeConstant) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    auto smoothingTimeConstant = static_cast<float>(value.getNumber());
+    analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
+  }
+
+  JSI_PROPERTY_SETTER(window) {
+    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+    analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
+  }
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferBaseSourceNodeHostObject
+        : public AudioScheduledSourceNodeHostObject {
+ public:
+    explicit AudioBufferBaseSourceNodeHostObject(
+            const std::shared_ptr<AudioBufferBaseSourceNode> &node)
+            : AudioScheduledSourceNodeHostObject(node) {
+        addGetters(
+                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, detune),
+                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, playbackRate),
+                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval));
+
+        addSetters(
+                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChanged),
+                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval));
+    }
+
+    ~AudioBufferBaseSourceNodeHostObject() {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+      // When JSI object is garbage collected (together with the eventual callback),
+      // underlying source node might still be active and try to call the non-existing callback.
+      sourceNode->clearOnPositionChangedCallback();
+    }
+
+    JSI_PROPERTY_GETTER(detune) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+        auto detune = sourceNode->getDetuneParam();
+        auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
+        return jsi::Object::createFromHostObject(runtime, detuneHostObject);
+    }
+
+    JSI_PROPERTY_GETTER(playbackRate) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+        auto playbackRate = sourceNode->getPlaybackRateParam();
+        auto playbackRateHostObject =
+                std::make_shared<AudioParamHostObject>(playbackRate);
+        return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
+    }
+
+    JSI_PROPERTY_SETTER(onPositionChanged) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+        sourceNode->setOnPositionChangedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+    }
+
+    JSI_PROPERTY_GETTER(onPositionChangedInterval) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+        return jsi::Value(sourceNode->getOnPositionChangedInterval());
+    }
+
+    JSI_PROPERTY_SETTER(onPositionChangedInterval) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+        sourceNode->setOnPositionChangedInterval(static_cast<int>(value.getNumber()));
+    }
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/jsi/JsiHostObject.h>
+
+#include <jsi/jsi.h>
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferHostObject : public JsiHostObject {
+ public:
+  std::shared_ptr<AudioBuffer> audioBuffer_;
+
+  explicit AudioBufferHostObject(
+      const std::shared_ptr<AudioBuffer> &audioBuffer)
+      : audioBuffer_(audioBuffer) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, sampleRate),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, length),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, duration),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, numberOfChannels));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, getChannelData),
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, copyFromChannel),
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, copyToChannel));
+  }
+  AudioBufferHostObject(const AudioBufferHostObject &) = delete;
+  AudioBufferHostObject &operator=(const AudioBufferHostObject &) = delete;
+  AudioBufferHostObject(AudioBufferHostObject &&other) noexcept
+      : JsiHostObject(std::move(other)),
+        audioBuffer_(std::move(other.audioBuffer_)) {}
+  AudioBufferHostObject &operator=(AudioBufferHostObject &&other) noexcept {
+    if (this != &other) {
+      JsiHostObject::operator=(std::move(other));
+      audioBuffer_ = std::move(other.audioBuffer_);
+    }
+    return *this;
+  }
+
+  [[nodiscard]] size_t getSizeInBytes() const {
+    return audioBuffer_->getLength() * audioBuffer_->getNumberOfChannels() *
+        sizeof(float);
+  }
+
+  JSI_PROPERTY_GETTER(sampleRate) {
+    return {audioBuffer_->getSampleRate()};
+  }
+
+  JSI_PROPERTY_GETTER(length) {
+    return {static_cast<double>(audioBuffer_->getLength())};
+  }
+
+  JSI_PROPERTY_GETTER(duration) {
+    return {audioBuffer_->getDuration()};
+  }
+
+  JSI_PROPERTY_GETTER(numberOfChannels) {
+    return {audioBuffer_->getNumberOfChannels()};
+  }
+
+  JSI_HOST_FUNCTION(getChannelData) {
+    auto channel = static_cast<int>(args[0].getNumber());
+    auto channelData =
+        reinterpret_cast<uint8_t *>(audioBuffer_->getChannelData(channel));
+    auto length = static_cast<int>(audioBuffer_->getLength());
+    auto size = static_cast<int>(length * sizeof(float));
+
+    // reading or writing from this ArrayBuffer could cause a crash
+    // if underlying channelData is deallocated
+    auto audioArrayBuffer =
+        std::make_shared<AudioArrayBuffer>(channelData, size);
+    auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
+
+    auto float32ArrayCtor =
+        runtime.global().getPropertyAsFunction(runtime, "Float32Array");
+    auto float32Array = float32ArrayCtor.callAsConstructor(runtime, arrayBuffer)
+                            .getObject(runtime);
+
+    return float32Array;
+  }
+
+  JSI_HOST_FUNCTION(copyFromChannel) {
+    auto arrayBuffer = args[0]
+                           .getObject(runtime)
+                           .getPropertyAsObject(runtime, "buffer")
+                           .getArrayBuffer(runtime);
+    auto destination = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+    auto channelNumber = static_cast<int>(args[1].getNumber());
+    auto startInChannel = static_cast<size_t>(args[2].getNumber());
+
+    audioBuffer_->copyFromChannel(
+        destination, length, channelNumber, startInChannel);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(copyToChannel) {
+    auto arrayBuffer = args[0]
+                           .getObject(runtime)
+                           .getPropertyAsObject(runtime, "buffer")
+                           .getArrayBuffer(runtime);
+    auto source = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+    auto length = static_cast<int>(arrayBuffer.size(runtime));
+    auto channelNumber = static_cast<int>(args[1].getNumber());
+    auto startInChannel = static_cast<size_t>(args[2].getNumber());
+
+    audioBuffer_->copyToChannel(source, length, channelNumber, startInChannel);
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace audioapi

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

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+#include <audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferQueueSourceNodeHostObject
+            : public AudioBufferBaseSourceNodeHostObject {
+ public:
+    explicit AudioBufferQueueSourceNodeHostObject(
+            const std::shared_ptr<AudioBufferQueueSourceNode> &node)
+            : AudioBufferBaseSourceNodeHostObject(node) {
+        addFunctions(
+                JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
+                JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause));
+    }
+
+    JSI_HOST_FUNCTION(pause) {
+        auto audioBufferQueueSourceNode =
+                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+        audioBufferQueueSourceNode->pause();
+
+        return jsi::Value::undefined();
+    }
+
+    JSI_HOST_FUNCTION(enqueueBuffer) {
+        auto audioBufferQueueSourceNode =
+                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+        auto audioBufferHostObject =
+                args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+
+        auto bufferId = audioBufferQueueSourceNode->enqueueBuffer(audioBufferHostObject->audioBuffer_);
+
+        return jsi::String::createFromUtf8(runtime, bufferId);
+    }
+
+    JSI_HOST_FUNCTION(dequeueBuffer) {
+        auto audioBufferQueueSourceNode =
+                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+        auto bufferId =
+                args[0].getNumber();
+
+        audioBufferQueueSourceNode->dequeueBuffer(bufferId);
+
+        return jsi::Value::undefined();
+    }
+
+    JSI_HOST_FUNCTION(clearBuffers) {
+        auto audioBufferQueueSourceNode =
+                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+        audioBufferQueueSourceNode->clearBuffers();
+
+        return jsi::Value::undefined();
+    }
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferSourceNodeHostObject
+    : public AudioBufferBaseSourceNodeHostObject {
+ public:
+  explicit AudioBufferSourceNodeHostObject(
+      const std::shared_ptr<AudioBufferSourceNode> &node)
+      : AudioBufferBaseSourceNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loop),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopSkip),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, buffer),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd));
+
+    addSetters(
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopSkip),
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopStart),
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd));
+
+    // start method is overridden in this class
+    functions_->erase("start");
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, start),
+        JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, setBuffer));
+    }
+
+  JSI_PROPERTY_GETTER(loop) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loop = audioBufferSourceNode->getLoop();
+    return {loop};
+  }
+
+  JSI_PROPERTY_GETTER(loopSkip) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loopSkip = audioBufferSourceNode->getLoopSkip();
+    return {loopSkip};
+  }
+
+  JSI_PROPERTY_GETTER(buffer) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto buffer = audioBufferSourceNode->getBuffer();
+
+    if (!buffer) {
+      return jsi::Value::null();
+    }
+
+    auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+    return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  }
+
+  JSI_PROPERTY_GETTER(loopStart) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loopStart = audioBufferSourceNode->getLoopStart();
+    return {loopStart};
+  }
+
+  JSI_PROPERTY_GETTER(loopEnd) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loopEnd = audioBufferSourceNode->getLoopEnd();
+    return {loopEnd};
+  }
+
+  JSI_PROPERTY_SETTER(loop) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoop(value.getBool());
+  }
+
+  JSI_PROPERTY_SETTER(loopSkip) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoopSkip(value.getBool());
+  }
+
+  JSI_PROPERTY_SETTER(loopStart) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoopStart(value.getNumber());
+  }
+
+  JSI_PROPERTY_SETTER(loopEnd) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoopEnd(value.getNumber());
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    auto when = args[0].getNumber();
+    auto offset = args[1].getNumber();
+
+    auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+    if (args[2].isUndefined()) {
+        audioBufferSourceNode->start(when, offset);
+
+        return jsi::Value::undefined();
+    }
+
+    auto duration = args[2].getNumber();
+    audioBufferSourceNode->start(when, offset, duration);
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(setBuffer) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+    if (args[0].isNull()) {
+      audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+      return jsi::Value::undefined();
+    }
+
+    auto bufferHostObject =
+        args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    thisValue.asObject(runtime).setExternalMemoryPressure(runtime,
+        bufferHostObject->getSizeInBytes() + 16);
+    audioBufferSourceNode->setBuffer(bufferHostObject->audioBuffer_);
+    return jsi::Value::undefined();
+  }
+};
+
+} // namespace audioapi