react-native-audio-api 0.8.3 → 0.9.0

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp

@@ -0,0 +1,69 @@
+#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#ifdef ANDROID
+#include <audioapi/android/core/AndroidAudioRecorder.h>
+#else
+#include <audioapi/ios/core/IOSAudioRecorder.h>
+#endif
+
+namespace audioapi {
+
+AudioRecorderHostObject::AudioRecorderHostObject(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    int bufferLength) {
+#ifdef ANDROID
+  audioRecorder_ = std::make_shared<AndroidAudioRecorder>(
+      sampleRate, bufferLength, audioEventHandlerRegistry);
+#else
+  audioRecorder_ = std::make_shared<IOSAudioRecorder>(
+      sampleRate, bufferLength, audioEventHandlerRegistry);
+#endif
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioRecorderHostObject, onAudioReady));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect));
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioRecorderHostObject, onAudioReady) {
+  audioRecorder_->setOnAudioReadyCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
+  auto adapterNodeHostObject =
+      args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(
+          runtime);
+  audioRecorder_->connect(
+      std::static_pointer_cast<RecorderAdapterNode>(
+          adapterNodeHostObject->node_));
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, disconnect) {
+  audioRecorder_->disconnect();
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
+  audioRecorder_->start();
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
+  audioRecorder_->stop();
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+
+#include <memory>
+#include <utility>
+#include <vector>
+#include <cstdio>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioRecorder;
+class AudioEventHandlerRegistry;
+
+class AudioRecorderHostObject : public JsiHostObject {
+ public:
+  explicit AudioRecorderHostObject(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      int bufferLength);
+
+  JSI_PROPERTY_SETTER_DECL(onAudioReady);
+
+  JSI_HOST_FUNCTION_DECL(connect);
+  JSI_HOST_FUNCTION_DECL(disconnect);
+  JSI_HOST_FUNCTION_DECL(start);
+  JSI_HOST_FUNCTION_DECL(stop);
+
+ private:
+  std::shared_ptr<AudioRecorder> audioRecorder_;
+};
+} // namespace audioapi

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

@@ -0,0 +1,73 @@
+#include <audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+
+namespace audioapi {
+
+AudioBufferBaseSourceNodeHostObject::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::~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_IMPL(AudioBufferBaseSourceNodeHostObject, 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_IMPL(AudioBufferBaseSourceNodeHostObject, 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_GETTER_IMPL(
+    AudioBufferBaseSourceNodeHostObject,
+    onPositionChangedInterval) {
+  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+  return {sourceNode->getOnPositionChangedInterval()};
+}
+
+JSI_PROPERTY_SETTER_IMPL(
+    AudioBufferBaseSourceNodeHostObject,
+    onPositionChanged) {
+  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+  sourceNode->setOnPositionChangedCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
+JSI_PROPERTY_SETTER_IMPL(
+    AudioBufferBaseSourceNodeHostObject,
+    onPositionChangedInterval) {
+  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+  sourceNode->setOnPositionChangedInterval(static_cast<int>(value.getNumber()));
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferBaseSourceNode;
+
+class AudioBufferBaseSourceNodeHostObject
+        : public AudioScheduledSourceNodeHostObject {
+ public:
+    explicit AudioBufferBaseSourceNodeHostObject(
+            const std::shared_ptr<AudioBufferBaseSourceNode> &node);
+
+    ~AudioBufferBaseSourceNodeHostObject() override;
+
+    JSI_PROPERTY_GETTER_DECL(detune);
+    JSI_PROPERTY_GETTER_DECL(playbackRate);
+    JSI_PROPERTY_GETTER_DECL(onPositionChangedInterval);
+
+    JSI_PROPERTY_SETTER_DECL(onPositionChanged);
+    JSI_PROPERTY_SETTER_DECL(onPositionChangedInterval);
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,94 @@
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+namespace audioapi {
+
+AudioBufferHostObject::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::AudioBufferHostObject(
+    AudioBufferHostObject &&other) noexcept
+    : JsiHostObject(std::move(other)),
+      audioBuffer_(std::move(other.audioBuffer_)) {}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, sampleRate) {
+  return {audioBuffer_->getSampleRate()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, length) {
+  return {static_cast<double>(audioBuffer_->getLength())};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, duration) {
+  return {audioBuffer_->getDuration()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, numberOfChannels) {
+  return {audioBuffer_->getNumberOfChannels()};
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, 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_IMPL(AudioBufferHostObject, 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_IMPL(AudioBufferHostObject, 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/sources/AudioBufferHostObject.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/core/sources/AudioBuffer.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);
+  AudioBufferHostObject(const AudioBufferHostObject &) = delete;
+  AudioBufferHostObject &operator=(const AudioBufferHostObject &) = delete;
+  AudioBufferHostObject(AudioBufferHostObject &&other) noexcept;
+  AudioBufferHostObject &operator=(AudioBufferHostObject &&other) noexcept {
+    if (this != &other) {
+        JsiHostObject::operator=(std::move(other));
+        audioBuffer_ = std::move(other.audioBuffer_);
+    }
+    return *this;
+  }
+
+  [[nodiscard]] inline size_t getSizeInBytes() const {
+    return audioBuffer_->getLength() * audioBuffer_->getNumberOfChannels() *
+           sizeof(float);
+  }
+
+  JSI_PROPERTY_GETTER_DECL(sampleRate);
+  JSI_PROPERTY_GETTER_DECL(length);
+  JSI_PROPERTY_GETTER_DECL(duration);
+  JSI_PROPERTY_GETTER_DECL(numberOfChannels);
+
+  JSI_HOST_FUNCTION_DECL(getChannelData);
+  JSI_HOST_FUNCTION_DECL(copyFromChannel);
+  JSI_HOST_FUNCTION_DECL(copyToChannel);
+};
+} // namespace audioapi

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

@@ -0,0 +1,60 @@
+#include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+
+namespace audioapi {
+
+AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
+    const std::shared_ptr<AudioBufferQueueSourceNode> &node)
+    : AudioBufferBaseSourceNodeHostObject(node) {
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
+      JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, dequeueBuffer),
+      JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, clearBuffers),
+      JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, pause) {
+  auto audioBufferQueueSourceNode =
+      std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+  audioBufferQueueSourceNode->pause();
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, 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_IMPL(AudioBufferQueueSourceNodeHostObject, dequeueBuffer) {
+  auto audioBufferQueueSourceNode =
+      std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+  auto bufferId = args[0].getNumber();
+
+  audioBufferQueueSourceNode->dequeueBuffer(bufferId);
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, clearBuffers) {
+  auto audioBufferQueueSourceNode =
+      std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+  audioBufferQueueSourceNode->clearBuffers();
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferQueueSourceNode;
+
+class AudioBufferQueueSourceNodeHostObject
+            : public AudioBufferBaseSourceNodeHostObject {
+ public:
+    explicit AudioBufferQueueSourceNodeHostObject(
+            const std::shared_ptr<AudioBufferQueueSourceNode> &node);
+
+    JSI_HOST_FUNCTION_DECL(pause);
+    JSI_HOST_FUNCTION_DECL(enqueueBuffer);
+    JSI_HOST_FUNCTION_DECL(dequeueBuffer);
+    JSI_HOST_FUNCTION_DECL(clearBuffers);
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,152 @@
+#include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/sources/AudioBufferSourceNode.h>
+
+namespace audioapi {
+
+AudioBufferSourceNodeHostObject::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),
+      JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, onLoopEnded));
+
+  // start method is overridden in this class
+  functions_->erase("start");
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, start),
+      JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, setBuffer));
+}
+
+AudioBufferSourceNodeHostObject::~AudioBufferSourceNodeHostObject() {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(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.
+  audioBufferSourceNode->clearOnLoopEndedCallback();
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto loop = audioBufferSourceNode->getLoop();
+  return {loop};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loopSkip) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto loopSkip = audioBufferSourceNode->getLoopSkip();
+  return {loopSkip};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, 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_IMPL(AudioBufferSourceNodeHostObject, loopStart) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto loopStart = audioBufferSourceNode->getLoopStart();
+  return {loopStart};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loopEnd) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto loopEnd = audioBufferSourceNode->getLoopEnd();
+  return {loopEnd};
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  audioBufferSourceNode->setLoop(value.getBool());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopSkip) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  audioBufferSourceNode->setLoopSkip(value.getBool());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopStart) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  audioBufferSourceNode->setLoopStart(value.getNumber());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopEnd) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  audioBufferSourceNode->setLoopEnd(value.getNumber());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, onLoopEnded) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+  audioBufferSourceNode->setOnLoopEndedCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, 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_IMPL(AudioBufferSourceNodeHostObject, 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

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferSourceNode;
+
+class AudioBufferSourceNodeHostObject
+    : public AudioBufferBaseSourceNodeHostObject {
+ public:
+  explicit AudioBufferSourceNodeHostObject(
+      const std::shared_ptr<AudioBufferSourceNode> &node);
+
+  ~AudioBufferSourceNodeHostObject() override;
+
+  JSI_PROPERTY_GETTER_DECL(loop);
+  JSI_PROPERTY_GETTER_DECL(loopSkip);
+  JSI_PROPERTY_GETTER_DECL(buffer);
+  JSI_PROPERTY_GETTER_DECL(loopStart);
+  JSI_PROPERTY_GETTER_DECL(loopEnd);
+
+  JSI_PROPERTY_SETTER_DECL(loop);
+  JSI_PROPERTY_SETTER_DECL(loopSkip);
+  JSI_PROPERTY_SETTER_DECL(loopStart);
+  JSI_PROPERTY_SETTER_DECL(loopEnd);
+  JSI_PROPERTY_SETTER_DECL(onLoopEnded);
+
+  JSI_HOST_FUNCTION_DECL(start);
+  JSI_HOST_FUNCTION_DECL(setBuffer);
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp

@@ -0,0 +1,52 @@
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+
+namespace audioapi {
+
+AudioScheduledSourceNodeHostObject::AudioScheduledSourceNodeHostObject(
+    const std::shared_ptr<AudioScheduledSourceNode> &node)
+    : AudioNodeHostObject(node) {
+  addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onEnded));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, start),
+      JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
+}
+
+AudioScheduledSourceNodeHostObject::~AudioScheduledSourceNodeHostObject() {
+  auto audioScheduledSourceNode =
+      std::static_pointer_cast<AudioScheduledSourceNode>(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.
+  audioScheduledSourceNode->clearOnEndedCallback();
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioScheduledSourceNodeHostObject, onEnded) {
+  auto audioScheduleSourceNode =
+      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+
+  audioScheduleSourceNode->setOnEndedCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, start) {
+  auto when = args[0].getNumber();
+  auto audioScheduleSourceNode =
+      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  audioScheduleSourceNode->start(when);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, stop) {
+  auto time = args[0].getNumber();
+  auto audioScheduleSourceNode =
+      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  audioScheduleSourceNode->stop(time);
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi