react-native-audio-api 0.3.0-rc1 → 0.3.1

package/common/cpp/HostObjects/AudioNodeHostObject.h

@@ -4,26 +4,63 @@
 #include <memory>
 #include <vector>
 
-#include "AudioNodeWrapper.h"
+#include <JsiHostObject.h>
+#include "AudioNode.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioNodeHostObject : public jsi::HostObject {
+class AudioNodeHostObject : public JsiHostObject {
  public:
-  explicit AudioNodeHostObject(
-      const std::shared_ptr<AudioNodeWrapper> &wrapper);
+  explicit AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
+      : node_(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCount),
+        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCountMode),
+        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelInterpretation));
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioNodeHostObject, connect),
+        JSI_EXPORT_FUNCTION(AudioNodeHostObject, disconnect));
+  }
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+  JSI_PROPERTY_GETTER(numberOfInputs) {
+    return {node_->getNumberOfInputs()};
+  }
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  JSI_PROPERTY_GETTER(numberOfOutputs) {
+    return {node_->getNumberOfOutputs()};
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(channelCount) {
+    return {node_->getChannelCount()};
+  }
+
+  JSI_PROPERTY_GETTER(channelCountMode) {
+    return jsi::String::createFromUtf8(runtime, node_->getChannelCountMode());
+  }
+
+  JSI_PROPERTY_GETTER(channelInterpretation) {
+    return jsi::String::createFromUtf8(
+        runtime, node_->getChannelInterpretation());
+  }
+
+  JSI_HOST_FUNCTION(connect) {
+    auto node =
+        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(disconnect) {
+    auto node =
+        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    return jsi::Value::undefined();
+  }
 
  protected:
-  std::shared_ptr<AudioNodeWrapper> wrapper_;
+  std::shared_ptr<AudioNode> node_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.h

@@ -4,31 +4,73 @@
 #include <memory>
 #include <vector>
 
-#include "AudioParamWrapper.h"
+#include <JsiHostObject.h>
+#include "AudioParam.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioParamHostObject : public jsi::HostObject {
+class AudioParamHostObject : public JsiHostObject {
  public:
-  explicit AudioParamHostObject(
-      const std::shared_ptr<AudioParamWrapper> &wrapper);
+  explicit AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
+      : param_(param) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
+        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
+        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, minValue),
+        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, maxValue));
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueAtTime),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, linearRampToValueAtTime),
+        JSI_EXPORT_FUNCTION(
+            AudioParamHostObject, exponentialRampToValueAtTime));
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
+  }
+
+  JSI_PROPERTY_GETTER(value) {
+    return {param_->getValue()};
+  }
+
+  JSI_PROPERTY_GETTER(defaultValue) {
+    return {param_->getDefaultValue()};
+  }
+
+  JSI_PROPERTY_GETTER(minValue) {
+    return {param_->getMinValue()};
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(maxValue) {
+    return {param_->getMaxValue()};
+  }
+
+  JSI_HOST_FUNCTION(setValueAtTime) {
+    auto value = static_cast<float>(args[0].getNumber());
+    double startTime = args[1].getNumber();
+    param_->setValueAtTime(value, startTime);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(linearRampToValueAtTime) {
+    auto value = static_cast<float>(args[0].getNumber());
+    double endTime = args[1].getNumber();
+    param_->linearRampToValueAtTime(value, endTime);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(exponentialRampToValueAtTime) {
+    auto value = static_cast<float>(args[0].getNumber());
+    double endTime = args[1].getNumber();
+    param_->exponentialRampToValueAtTime(value, endTime);
+    return jsi::Value::undefined();
+  }
 
-  static std::shared_ptr<AudioParamHostObject> createFromWrapper(
-      const std::shared_ptr<AudioParamWrapper> &wrapper) {
-    return std::make_shared<AudioParamHostObject>(wrapper);
+  JSI_PROPERTY_SETTER(value) {
+    param_->setValue(static_cast<float>(value.getNumber()));
   }
 
  private:
-  std::shared_ptr<AudioParamWrapper> wrapper_;
+  std::shared_ptr<AudioParam> param_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.h

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "AudioNodeHostObject.h"
-#include "AudioScheduledSourceNodeWrapper.h"
+#include "AudioScheduledSourceNode.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -12,20 +12,27 @@ 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();
+      const std::shared_ptr<AudioScheduledSourceNode> &node)
+      : AudioNodeHostObject(node) {
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, start),
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    auto time = args[0].getNumber();
+    auto audioScheduleSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+    audioScheduleSourceNode->start(time);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(stop) {
+    auto time = args[0].getNumber();
+    auto audioScheduleSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+    audioScheduleSourceNode->stop(time);
+    return jsi::Value::undefined();
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -5,11 +5,13 @@
 #include <utility>
 #include <vector>
 
-#include "JsiPromise.h"
+#include <JsiHostObject.h>
+#include <JsiPromise.h>
+
 #include "AudioBufferHostObject.h"
 #include "AudioBufferSourceNodeHostObject.h"
 #include "AudioDestinationNodeHostObject.h"
-#include "BaseAudioContextWrapper.h"
+#include "BaseAudioContext.h"
 #include "BiquadFilterNodeHostObject.h"
 #include "GainNodeHostObject.h"
 #include "OscillatorNodeHostObject.h"
@@ -19,23 +21,139 @@
 namespace audioapi {
 using namespace facebook;
 
-class BaseAudioContextHostObject : public jsi::HostObject {
+class BaseAudioContextHostObject : public JsiHostObject {
  public:
   explicit BaseAudioContextHostObject(
-      const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
+      const std::shared_ptr<BaseAudioContext> &context,
+      const std::shared_ptr<PromiseVendor> &promiseVendor)
+      : context_(context), promiseVendor_(promiseVendor) {
+    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, createOscillator),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource));
+  }
+
+  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(createOscillator) {
+    auto oscillator = context_->createOscillator();
+    auto oscillatorHostObject =
+        std::make_shared<OscillatorNodeHostObject>(oscillator);
+    return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
+  }
+
+  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 bufferSource = context_->createBufferSource();
+    auto bufferSourceHostObject =
+        std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
+    return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createBuffer) {
+    auto numberOfChannels = static_cast<int>(args[0].getNumber());
+    auto length = static_cast<int>(args[1].getNumber());
+    auto sampleRate = static_cast<int>(args[2].getNumber());
+    auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
+    auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+    return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  }
+
+  JSI_HOST_FUNCTION(createPeriodicWave) {
+    auto real = args[0].getObject(runtime).getArray(runtime);
+    auto imag = args[1].getObject(runtime).getArray(runtime);
+    auto disableNormalization = args[2].getBool();
+    auto length =
+        static_cast<int>(real.getProperty(runtime, "length").asNumber());
+
+    auto *realData = new float[length];
+    auto *imagData = new float[length];
+
+    for (size_t i = 0; i < real.length(runtime); i++) {
+      realData[i] =
+          static_cast<float>(real.getValueAtIndex(runtime, i).getNumber());
+    }
+    for (size_t i = 0; i < imag.length(runtime); i++) {
+      realData[i] =
+          static_cast<float>(imag.getValueAtIndex(runtime, i).getNumber());
+    }
+
+    auto periodicWave = context_->createPeriodicWave(
+        realData, imagData, disableNormalization, length);
+    auto periodicWaveHostObject =
+        std::make_shared<PeriodicWaveHostObject>(periodicWave);
+    return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
+  }
+
+  JSI_HOST_FUNCTION(decodeAudioDataSource) {
+    auto sourcePath = args[0].getString(runtime).utf8(runtime);
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    auto promise = promiseVendor_->createPromise(
+        [this, &runtime, sourcePath](std::shared_ptr<Promise> promise) {
+          std::thread([this,
+                       &runtime,
+                       sourcePath,
+                       promise = std::move(promise)]() {
+            auto results = context_->decodeAudioDataSource(sourcePath);
+            auto audioBufferHostObject =
+                std::make_shared<AudioBufferHostObject>(results);
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+            promise->resolve(jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject));
+          }).detach();
+        });
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    return promise;
+  }
 
  protected:
-  std::shared_ptr<BaseAudioContextWrapper> wrapper_;
-  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
-  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
+  std::shared_ptr<BaseAudioContext> context_;
+  std::shared_ptr<PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.h

@@ -6,7 +6,7 @@
 
 #include "AudioNodeHostObject.h"
 #include "AudioParamHostObject.h"
-#include "BiquadFilterNodeWrapper.h"
+#include "BiquadFilterNode.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -14,29 +14,87 @@ using namespace facebook;
 class BiquadFilterNodeHostObject : public AudioNodeHostObject {
  public:
   explicit BiquadFilterNodeHostObject(
-      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper);
+      const std::shared_ptr<BiquadFilterNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, frequency),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, detune),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, Q),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, gain),
+        JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, type));
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(BiquadFilterNodeHostObject, type));
+  }
+
+  JSI_PROPERTY_GETTER(frequency) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getFrequencyParam());
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
+
+  JSI_PROPERTY_GETTER(detune) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto detuneParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getDetuneParam());
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
+
+  JSI_PROPERTY_GETTER(Q) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto QParam_ =
+        std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
+    return jsi::Object::createFromHostObject(runtime, QParam_);
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(gain) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto gainParam_ = std::make_shared<AudioParamHostObject>(
+        biquadFilterNode->getGainParam());
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
+  }
 
-  static std::shared_ptr<BiquadFilterNodeHostObject> createFromWrapper(
-      const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper) {
-    return std::make_shared<BiquadFilterNodeHostObject>(wrapper);
+  JSI_PROPERTY_GETTER(type) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    auto type = biquadFilterNode->getType();
+    return jsi::String::createFromUtf8(runtime, type);
   }
 
- private:
-  std::shared_ptr<AudioParamHostObject> frequencyParam_;
-  std::shared_ptr<AudioParamHostObject> detuneParam_;
-  std::shared_ptr<AudioParamHostObject> QParam_;
-  std::shared_ptr<AudioParamHostObject> gainParam_;
+  JSI_HOST_FUNCTION(getFrequencyResponse) {
+    auto frequencyArray = args[0].getObject(runtime).asArray(runtime);
+    auto magResponseOut = args[1].getObject(runtime).asArray(runtime);
+    auto phaseResponseOut = args[2].getObject(runtime).asArray(runtime);
 
-  std::shared_ptr<BiquadFilterNodeWrapper>
-  getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+    std::vector<float> frequencyArrayVector(frequencyArray.length(runtime));
+    for (size_t i = 0; i < frequencyArray.length(runtime); i++) {
+      frequencyArrayVector[i] = static_cast<float>(
+          frequencyArray.getValueAtIndex(runtime, i).getNumber());
+    }
+
+    std::vector<float> magResponseOutVector(magResponseOut.length(runtime));
+    std::vector<float> phaseResponseOutVector(phaseResponseOut.length(runtime));
+
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    biquadFilterNode->getFrequencyResponse(
+        frequencyArrayVector, magResponseOutVector, phaseResponseOutVector);
+
+    for (size_t i = 0; i < magResponseOutVector.size(); i++) {
+      magResponseOut.setValueAtIndex(runtime, i, magResponseOutVector[i]);
+    }
+
+    for (size_t i = 0; i < phaseResponseOutVector.size(); i++) {
+      phaseResponseOut.setValueAtIndex(runtime, i, phaseResponseOutVector[i]);
+    }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_PROPERTY_SETTER(type) {
+    auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    biquadFilterNode->setType(value.getString(runtime).utf8(runtime));
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/Constants.h

@@ -10,6 +10,8 @@ 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 MOST_NEGATIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::lowest());
 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;

package/common/cpp/HostObjects/GainNodeHostObject.h

@@ -5,28 +5,23 @@
 
 #include "AudioNodeHostObject.h"
 #include "AudioParamHostObject.h"
-#include "GainNodeWrapper.h"
+#include "GainNode.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;
+  explicit GainNodeHostObject(const std::shared_ptr<GainNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
+  }
 
-  static std::shared_ptr<GainNodeHostObject> createFromWrapper(
-      const std::shared_ptr<GainNodeWrapper> &wrapper) {
-    return std::make_shared<GainNodeHostObject>(wrapper);
+  JSI_PROPERTY_GETTER(gain) {
+    auto gainNode = std::static_pointer_cast<GainNode>(node_);
+    auto gainParam_ =
+        std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+    return jsi::Object::createFromHostObject(runtime, gainParam_);
   }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -6,7 +6,7 @@
 
 #include "AudioParamHostObject.h"
 #include "AudioScheduledSourceNodeHostObject.h"
-#include "OscillatorNodeWrapper.h"
+#include "OscillatorNode.h"
 #include "PeriodicWaveHostObject.h"
 
 namespace audioapi {
@@ -14,28 +14,51 @@ using namespace facebook;
 
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit OscillatorNodeHostObject(
-      const std::shared_ptr<OscillatorNodeWrapper> &wrapper);
+  explicit OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, detune),
+        JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, type));
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(OscillatorNodeHostObject, setPeriodicWave));
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(OscillatorNodeHostObject, type));
+  }
+
+  JSI_PROPERTY_GETTER(frequency) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+        oscillatorNode->getFrequencyParam());
+    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(detune) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto detuneParam_ = std::make_shared<AudioParamHostObject>(
+        oscillatorNode->getDetuneParam());
+    return jsi::Object::createFromHostObject(runtime, detuneParam_);
+  }
 
-  static std::shared_ptr<OscillatorNodeHostObject> createFromWrapper(
-      const std::shared_ptr<OscillatorNodeWrapper> &wrapper) {
-    return std::make_shared<OscillatorNodeHostObject>(wrapper);
+  JSI_PROPERTY_GETTER(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto waveType = oscillatorNode->getType();
+    return jsi::String::createFromUtf8(runtime, waveType);
   }
 
- private:
-  std::shared_ptr<AudioParamHostObject> frequencyParam_;
-  std::shared_ptr<AudioParamHostObject> detuneParam_;
+  JSI_HOST_FUNCTION(setPeriodicWave) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    auto periodicWave =
+        args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(
+            runtime);
+    oscillatorNode->setPeriodicWave(periodicWave->periodicWave_);
+    return jsi::Value::undefined();
+  }
 
-  std::shared_ptr<OscillatorNodeWrapper>
-  getOscillatorNodeWrapperFromAudioNodeWrapper();
+  JSI_PROPERTY_SETTER(type) {
+    auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+    oscillatorNode->setType(value.getString(runtime).utf8(runtime));
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.h

@@ -4,30 +4,17 @@
 #include <memory>
 #include <vector>
 
-#include "PeriodicWaveWrapper.h"
+#include "PeriodicWave.h"
 
 namespace audioapi {
 using namespace facebook;
 
 class PeriodicWaveHostObject : public jsi::HostObject {
  public:
-  std::shared_ptr<PeriodicWaveWrapper> wrapper_;
+  std::shared_ptr<PeriodicWave> periodicWave_;
 
   explicit PeriodicWaveHostObject(
-      const std::shared_ptr<PeriodicWaveWrapper> &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<PeriodicWaveHostObject> createFromWrapper(
-      const std::shared_ptr<PeriodicWaveWrapper> &wrapper) {
-    return std::make_shared<PeriodicWaveHostObject>(wrapper);
-  }
+      const std::shared_ptr<PeriodicWave> &periodicWave)
+      : periodicWave_(periodicWave) {}
 };
 } // namespace audioapi