react-native-audio-api 0.0.1 → 0.1.0

package/common/cpp/HostObjects/AudioNodeHostObject.cpp

@@ -0,0 +1,108 @@
+#include "AudioNodeHostObject.h"
+#include "AudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioNodeHostObject::AudioNodeHostObject(
+    const std::shared_ptr<AudioNodeWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "connect"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "disconnect"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "numberOfInputs"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "numberOfOutputs"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "channelCount"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "channelCountMode"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "channelInterpretation"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "context"));
+  return propertyNames;
+}
+
+jsi::Value AudioNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "connect") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto node =
+              args[0].getObject(rt).getHostObject<AudioNodeHostObject>(rt);
+          wrapper_->connect(
+              std::shared_ptr<AudioNodeHostObject>(node)->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "disconnect") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto node =
+              args[0].getObject(rt).getHostObject<AudioNodeHostObject>(rt);
+          wrapper_->disconnect(
+              std::shared_ptr<AudioNodeHostObject>(node)->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "numberOfInputs") {
+    return {wrapper_->getNumberOfInputs()};
+  }
+
+  if (propName == "numberOfOutputs") {
+    return {wrapper_->getNumberOfOutputs()};
+  }
+
+  if (propName == "channelCount") {
+    return {wrapper_->getChannelCount()};
+  }
+
+  if (propName == "channelCountMode") {
+    return jsi::String::createFromUtf8(
+        runtime, wrapper_->getChannelCountMode());
+  }
+
+  if (propName == "channelInterpretation") {
+    return jsi::String::createFromUtf8(
+        runtime, wrapper_->getChannelInterpretation());
+  }
+
+  if (propName == "context") {
+    // TODO fix this
+    return jsi::Value::undefined();
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/AudioNodeHostObject.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioNodeHostObject : public jsi::HostObject {
+ public:
+  explicit AudioNodeHostObject(
+      const std::shared_ptr<AudioNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ protected:
+  std::shared_ptr<AudioNodeWrapper> wrapper_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.cpp

@@ -0,0 +1,115 @@
+#include "AudioParamHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioParamHostObject::AudioParamHostObject(
+    const std::shared_ptr<AudioParamWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioParamHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "value"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "defaultValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "minValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "maxValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "setValueAtTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "linearRampToValueAtTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "exponentialRampToValueAtTime"));
+  return propertyNames;
+}
+
+jsi::Value AudioParamHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "value") {
+    return {wrapper_->getValue()};
+  }
+
+  if (propName == "defaultValue") {
+    return {wrapper_->getDefaultValue()};
+  }
+
+  if (propName == "minValue") {
+    return {wrapper_->getMinValue()};
+  }
+
+  if (propName == "maxValue") {
+    return {wrapper_->getMaxValue()};
+  }
+
+  if (propName == "setValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double startTime = args[1].getNumber();
+          wrapper_->setValueAtTime(value, startTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "linearRampToValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double endTime = args[1].getNumber();
+          wrapper_->linearRampToValueAtTime(value, endTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "exponentialRampToValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double endTime = args[1].getNumber();
+          wrapper_->exponentialRampToValueAtTime(value, endTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioParamHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "value") {
+    double paramValue = value.getNumber();
+    wrapper_->setValue(paramValue);
+    return;
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "AudioParamWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioParamHostObject : public jsi::HostObject {
+ public:
+  explicit AudioParamHostObject(
+      const std::shared_ptr<AudioParamWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<AudioParamHostObject> createFromWrapper(
+      const std::shared_ptr<AudioParamWrapper> &wrapper) {
+    return std::make_shared<AudioParamHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamWrapper> wrapper_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.cpp

@@ -0,0 +1,73 @@
+#include "AudioScheduledSourceNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<AudioScheduledSourceNodeWrapper>
+AudioScheduledSourceNodeHostObject::
+    getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<AudioScheduledSourceNodeWrapper>(wrapper_);
+}
+
+std::vector<jsi::PropNameID>
+AudioScheduledSourceNodeHostObject::getPropertyNames(jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "start"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "stop"));
+  return propertyNames;
+}
+
+jsi::Value AudioScheduledSourceNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "start") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto time = args[0].getNumber();
+          auto wrapper =
+              getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+          wrapper->start(time);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "stop") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto time = args[0].getNumber();
+          auto wrapper =
+              getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+          wrapper->stop(time);
+          return jsi::Value::undefined();
+        });
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void AudioScheduledSourceNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AudioScheduledSourceNodeHostObject(
+      const std::shared_ptr<AudioScheduledSourceNodeWrapper> &wrapper)
+      : AudioNodeHostObject(wrapper) {}
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ private:
+  std::shared_ptr<AudioScheduledSourceNodeWrapper>
+  getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.cpp

@@ -0,0 +1,81 @@
+#include "BiquadFilterNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<BiquadFilterNodeWrapper>
+BiquadFilterNodeHostObject::getBiquadFilterNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<BiquadFilterNodeWrapper>(wrapper_);
+}
+
+BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
+    const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto frequencyParam = wrapper->getFrequencyParam();
+  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
+  auto detuneParam = wrapper->getDetuneParam();
+  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
+  auto QParam = wrapper->getQParam();
+  QParam_ = AudioParamHostObject::createFromWrapper(QParam);
+  auto gainParam = wrapper->getGainParam();
+  gainParam_ = AudioParamHostObject::createFromWrapper(gainParam);
+}
+
+std::vector<jsi::PropNameID> BiquadFilterNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "Q"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  return propertyNames;
+}
+
+jsi::Value BiquadFilterNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "frequency") {
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  if (propName == "detune") {
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  if (propName == "Q") {
+    return jsi::Object::createFromHostObject(runtime, QParam_);
+  }
+
+  if (propName == "gain") {
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
+
+  if (propName == "type") {
+    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+    auto waveType = wrapper->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void BiquadFilterNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "type") {
+    std::string filterType = value.getString(runtime).utf8(runtime);
+    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+    wrapper->setType(filterType);
+    return;
+  }
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "BiquadFilterNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class BiquadFilterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit BiquadFilterNodeHostObject(
+      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<BiquadFilterNodeHostObject> createFromWrapper(
+      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper) {
+    return std::make_shared<BiquadFilterNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> frequencyParam_;
+  std::shared_ptr<AudioParamHostObject> detuneParam_;
+  std::shared_ptr<AudioParamHostObject> QParam_;
+  std::shared_ptr<AudioParamHostObject> gainParam_;
+
+  std::shared_ptr<BiquadFilterNodeWrapper>
+  getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/Constants.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cmath>
+#include <limits>
+
+// https://webaudio.github.io/web-audio-api/
+
+namespace audioapi {
+constexpr int SAMPLE_RATE = 44100;
+constexpr int CHANNEL_COUNT = 2;
+constexpr float MOST_POSITIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::max());
+constexpr float NYQUIST_FREQUENCY = SAMPLE_RATE / 2.0;
+static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
+constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;
+constexpr float MAX_PAN = 1.0;
+constexpr float MAX_FILTER_Q = MOST_POSITIVE_SINGLE_FLOAT;
+constexpr float MAX_FILTER_FREQUENCY = NYQUIST_FREQUENCY;
+constexpr float MIN_FILTER_FREQUENCY = 0.0;
+static float MAX_FILTER_GAIN = 40 * std::log10(MOST_POSITIVE_SINGLE_FLOAT);
+constexpr float MIN_FILTER_GAIN = -MAX_GAIN;
+} // namespace audioapi

package/common/cpp/HostObjects/GainNodeHostObject.cpp

@@ -0,0 +1,41 @@
+#include "GainNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+GainNodeHostObject::GainNodeHostObject(
+    const std::shared_ptr<GainNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto gainParamWrapper = wrapper->getGainParam();
+  gainParam_ = AudioParamHostObject::createFromWrapper(gainParamWrapper);
+}
+
+std::vector<jsi::PropNameID> GainNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
+  return propertyNames;
+}
+
+jsi::Value GainNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "gain") {
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void GainNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/GainNodeHostObject.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "GainNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class GainNodeHostObject : public AudioNodeHostObject {
+ protected:
+  std::shared_ptr<AudioParamHostObject> gainParam_;
+
+ public:
+  explicit GainNodeHostObject(const std::shared_ptr<GainNodeWrapper> &wrapper);
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<GainNodeHostObject> createFromWrapper(
+      const std::shared_ptr<GainNodeWrapper> &wrapper) {
+    return std::make_shared<GainNodeHostObject>(wrapper);
+  }
+};
+} // namespace audioapi

package/common/cpp/HostObjects/OscillatorNodeHostObject.cpp

@@ -0,0 +1,67 @@
+#include "OscillatorNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<OscillatorNodeWrapper>
+OscillatorNodeHostObject::getOscillatorNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<OscillatorNodeWrapper>(wrapper_);
+}
+
+OscillatorNodeHostObject::OscillatorNodeHostObject(
+    const std::shared_ptr<OscillatorNodeWrapper> &wrapper)
+    : AudioScheduledSourceNodeHostObject(wrapper) {
+  auto frequencyParam = wrapper->getFrequencyParam();
+  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
+  auto detuneParam = wrapper->getDetuneParam();
+  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
+}
+
+std::vector<jsi::PropNameID> OscillatorNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioScheduledSourceNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  return propertyNames;
+}
+
+jsi::Value OscillatorNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "frequency") {
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  if (propName == "detune") {
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  if (propName == "type") {
+    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+    auto waveType = wrapper->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
+  }
+
+  return AudioScheduledSourceNodeHostObject::get(runtime, propNameId);
+}
+
+void OscillatorNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "type") {
+    std::string waveType = value.getString(runtime).utf8(runtime);
+    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+    wrapper->setType(waveType);
+    return;
+  }
+
+  return AudioScheduledSourceNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi