react-native-audio-api 0.3.0-rc2 → 0.3.2

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -4,9 +4,8 @@
 #include <memory>
 #include <vector>
 
-#include "AudioContextWrapper.h"
+#include "AudioContext.h"
 #include "BaseAudioContextHostObject.h"
-#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -14,26 +13,16 @@ using namespace facebook;
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper,
-      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
-
-  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<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper,
-      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
-    return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
+      const std::shared_ptr<AudioContext> &audioContext,
+      const std::shared_ptr<PromiseVendor> &promiseVendor)
+      : BaseAudioContextHostObject(audioContext, promiseVendor) {
+    addFunctions(JSI_EXPORT_FUNCTION(AudioContextHostObject, close));
   }
 
- private:
-  std::shared_ptr<AudioContextWrapper>
-  getAudioContextWrapperFromBaseAudioContextWrapper();
+  JSI_HOST_FUNCTION(close) {
+    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+    audioContext->close();
+    return jsi::Value::undefined();
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioDestinationNodeHostObject.h

@@ -3,7 +3,7 @@
 #include <memory>
 #include <vector>
 
-#include "AudioDestinationNodeWrapper.h"
+#include "AudioDestinationNode.h"
 #include "AudioNodeHostObject.h"
 
 namespace audioapi {
@@ -12,20 +12,7 @@ using namespace facebook;
 class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
-      const std::shared_ptr<AudioDestinationNodeWrapper> &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<AudioDestinationNodeHostObject> createFromWrapper(
-      const std::shared_ptr<AudioDestinationNodeWrapper> &wrapper) {
-    return std::make_shared<AudioDestinationNodeHostObject>(wrapper);
-  }
+      const std::shared_ptr<AudioDestinationNode> &node)
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

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,110 @@
 #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),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, setTargetAtTime),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueCurveAtTime),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelScheduledValues),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelAndHoldAtTime));
 
-  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()};
+  }
+
+  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();
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  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();
+  }
+
+  JSI_HOST_FUNCTION(setTargetAtTime) {
+    auto target = static_cast<float>(args[0].getNumber());
+    double startTime = args[1].getNumber();
+    double timeConstant = args[2].getNumber();
+    param_->setTargetAtTime(target, startTime, timeConstant);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(setValueCurveAtTime) {
+    auto values = args[0].getObject(runtime).asArray(runtime);
+    auto length = static_cast<int>(values.length(runtime));
+    auto valuesData = new float[length];
+    for (size_t i = 0; i < values.length(runtime); i++) {
+      valuesData[i] =
+          static_cast<float>(values.getValueAtIndex(runtime, i).getNumber());
+    }
+    double startTime = args[1].getNumber();
+    double duration = args[2].getNumber();
+    param_->setValueCurveAtTime(valuesData, length, startTime, duration);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(cancelScheduledValues) {
+    double cancelTime = args[0].getNumber();
+    param_->cancelScheduledValues(cancelTime);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(cancelAndHoldAtTime) {
+    double cancelTime = args[0].getNumber();
+    param_->cancelAndHoldAtTime(cancelTime);
+    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,13 +5,15 @@
 #include <utility>
 #include <vector>
 
+#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 "JsiPromise.h"
 #include "OscillatorNodeHostObject.h"
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
@@ -19,24 +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/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