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

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -1,12 +1,15 @@
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
 #include <vector>
 
+
 #include "AudioAPIInstallerWrapper.h"
 #include "AudioContextHostObject.h"
+#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -16,7 +19,7 @@ class AudioAPIInstallerWrapper;
 class AudioAPIInstallerHostObject : public jsi::HostObject {
  public:
   explicit AudioAPIInstallerHostObject(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper);
+      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper, jsi::Runtime* runtime, const std::shared_ptr<react::CallInvoker> &jsInvoker);
 
 #ifdef ANDROID
   static void createAndInstallFromWrapper(
@@ -41,5 +44,6 @@ class AudioAPIInstallerHostObject : public jsi::HostObject {
 
  private:
   std::shared_ptr<AudioAPIInstallerWrapper> wrapper_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioBufferHostObject.cpp

@@ -128,6 +128,12 @@ jsi::Value AudioBufferHostObject::get(
         });
   }
 
+  // `decodeAudioData` is a method that returns a promise to AudioBufferHostObject
+  // It seems that async/await checks for the presence of `then` method on the object
+  if (propName == "then") {
+    return jsi::Value::undefined();
+  }
+
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.cpp

@@ -18,6 +18,7 @@ std::vector<jsi::PropNameID> AudioBufferSourceNodeHostObject::getPropertyNames(
       AudioScheduledSourceNodeHostObject::getPropertyNames(runtime);
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "loop"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "buffer"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "resetBuffer"));
   return propertyNames;
 }
 
@@ -35,6 +36,11 @@ jsi::Value AudioBufferSourceNodeHostObject::get(
   if (propName == "buffer") {
     auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
     auto buffer = wrapper->getBuffer();
+
+    if (!buffer) {
+      return jsi::Value::null();
+    }
+
     auto bufferHostObject = AudioBufferHostObject::createFromWrapper(buffer);
     return jsi::Object::createFromHostObject(runtime, bufferHostObject);
   }
@@ -55,9 +61,15 @@ void AudioBufferSourceNodeHostObject::set(
   }
 
   if (propName == "buffer") {
+    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+
+    if (value.isNull()) {
+      wrapper->setBuffer(std::shared_ptr<AudioBufferWrapper>(nullptr));
+      return;
+    }
+
     auto bufferHostObject =
         value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
     wrapper->setBuffer(bufferHostObject->wrapper_);
     return;
   }

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -4,30 +4,13 @@ namespace audioapi {
 using namespace facebook;
 
 AudioContextHostObject::AudioContextHostObject(
-    const std::shared_ptr<AudioContextWrapper> &wrapper)
-    : wrapper_(wrapper) {
-  auto destinationNodeWrapper = wrapper_->getDestination();
-  destination_ =
-      AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
-}
+    const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : BaseAudioContextHostObject(wrapper, promiseVendor) {}
 
 std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(
     jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames;
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "destination"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "state"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "sampleRate"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "currentTime"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createOscillator"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createGain"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createStereoPanner"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createBiquadFilter"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createBufferSource"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
+  std::vector<jsi::PropNameID> propertyNames =
+      BaseAudioContextHostObject::getPropertyNames(runtime);
   propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "close"));
   return propertyNames;
 }
@@ -37,131 +20,6 @@ jsi::Value AudioContextHostObject::get(
     const jsi::PropNameID &propNameId) {
   auto propName = propNameId.utf8(runtime);
 
-  if (propName == "destination") {
-    return jsi::Object::createFromHostObject(runtime, destination_);
-  }
-
-  if (propName == "state") {
-    return jsi::String::createFromUtf8(runtime, wrapper_->getState());
-  }
-
-  if (propName == "sampleRate") {
-    return {wrapper_->getSampleRate()};
-  }
-
-  if (propName == "currentTime") {
-    return {wrapper_->getCurrentTime()};
-  }
-
-  if (propName == "createOscillator") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto oscillator = wrapper_->createOscillator();
-          auto oscillatorHostObject =
-              OscillatorNodeHostObject::createFromWrapper(oscillator);
-          return jsi::Object::createFromHostObject(
-              runtime, oscillatorHostObject);
-        });
-  }
-
-  if (propName == "createGain") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto gain = wrapper_->createGain();
-          auto gainHostObject = GainNodeHostObject::createFromWrapper(gain);
-          return jsi::Object::createFromHostObject(runtime, gainHostObject);
-        });
-  }
-
-  if (propName == "createStereoPanner") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto stereoPanner = wrapper_->createStereoPanner();
-          auto stereoPannerHostObject =
-              StereoPannerNodeHostObject::createFromWrapper(stereoPanner);
-          return jsi::Object::createFromHostObject(
-              runtime, stereoPannerHostObject);
-        });
-  }
-
-  if (propName == "createBiquadFilter") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto biquadFilter = wrapper_->createBiquadFilter();
-          auto biquadFilterHostObject =
-              BiquadFilterNodeHostObject::createFromWrapper(biquadFilter);
-          return jsi::Object::createFromHostObject(
-              runtime, biquadFilterHostObject);
-        });
-  }
-
-  if (propName == "createBufferSource") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto bufferSource = wrapper_->createBufferSource();
-          auto bufferSourceHostObject =
-              AudioBufferSourceNodeHostObject::createFromWrapper(bufferSource);
-          return jsi::Object::createFromHostObject(
-              runtime, bufferSourceHostObject);
-        });
-  }
-
-  if (propName == "createBuffer") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        3,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto numberOfChannels = static_cast<int>(arguments[0].getNumber());
-          auto length = static_cast<int>(arguments[1].getNumber());
-          auto sampleRate = static_cast<int>(arguments[2].getNumber());
-          auto buffer =
-              wrapper_->createBuffer(numberOfChannels, length, sampleRate);
-          auto bufferHostObject =
-              AudioBufferHostObject::createFromWrapper(buffer);
-          return jsi::Object::createFromHostObject(runtime, bufferHostObject);
-        });
-  }
-
   if (propName == "close") {
     return jsi::Function::createFromHostFunction(
         runtime,
@@ -172,12 +30,12 @@ jsi::Value AudioContextHostObject::get(
             const jsi::Value &thisValue,
             const jsi::Value *arguments,
             size_t count) -> jsi::Value {
-          wrapper_->close();
+          getAudioContextWrapperFromBaseAudioContextWrapper()->close();
           return jsi::Value::undefined();
         });
   }
 
-  throw std::runtime_error("Not yet implemented!");
+  return BaseAudioContextHostObject::get(runtime, propNameId);
 }
 
 void AudioContextHostObject::set(
@@ -186,6 +44,11 @@ void AudioContextHostObject::set(
     const jsi::Value &value) {
   auto propName = propNameId.utf8(runtime);
 
-  throw std::runtime_error("Not yet implemented!");
+  return BaseAudioContextHostObject::set(runtime, propNameId, value);
+}
+
+std::shared_ptr<AudioContextWrapper>
+AudioContextHostObject::getAudioContextWrapperFromBaseAudioContextWrapper() {
+  return std::static_pointer_cast<AudioContextWrapper>(wrapper_);
 }
 } // namespace audioapi

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -2,25 +2,19 @@
 
 #include <jsi/jsi.h>
 #include <memory>
-#include <utility>
 #include <vector>
 
-#include "AudioBufferHostObject.h"
-#include "AudioBufferSourceNodeHostObject.h"
+#include"JsiPromise.h"
 #include "AudioContextWrapper.h"
-#include "AudioDestinationNodeHostObject.h"
-#include "BiquadFilterNodeHostObject.h"
-#include "GainNodeHostObject.h"
-#include "OscillatorNodeHostObject.h"
-#include "StereoPannerNodeHostObject.h"
+#include "BaseAudioContextHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioContextHostObject : public jsi::HostObject {
+class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -32,12 +26,12 @@ class AudioContextHostObject : public jsi::HostObject {
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
   static std::shared_ptr<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper) {
-    return std::make_shared<AudioContextHostObject>(wrapper);
+      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
+    return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
   }
 
  private:
-  std::shared_ptr<AudioContextWrapper> wrapper_;
-  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+  std::shared_ptr<AudioContextWrapper>
+  getAudioContextWrapperFromBaseAudioContextWrapper();
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioNodeHostObject.cpp

@@ -21,7 +21,6 @@ std::vector<jsi::PropNameID> AudioNodeHostObject::getPropertyNames(
       jsi::PropNameID::forAscii(runtime, "channelCountMode"));
   propertyNames.push_back(
       jsi::PropNameID::forAscii(runtime, "channelInterpretation"));
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "context"));
   return propertyNames;
 }
 
@@ -88,11 +87,6 @@ jsi::Value AudioNodeHostObject::get(
         runtime, wrapper_->getChannelInterpretation());
   }
 
-  if (propName == "context") {
-    // TODO fix this
-    return jsi::Value::undefined();
-  }
-
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -0,0 +1,240 @@
+#include <thread>
+
+#include "BaseAudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+BaseAudioContextHostObject::BaseAudioContextHostObject(
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    : wrapper_(wrapper), promiseVendor_(promiseVendor) {
+  auto destinationNodeWrapper = wrapper_->getDestination();
+  destination_ =
+      AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
+}
+
+std::vector<jsi::PropNameID> BaseAudioContextHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "destination"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "state"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "sampleRate"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "currentTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createOscillator"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createGain"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createStereoPanner"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBiquadFilter"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBufferSource"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createPeriodicWave"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "decodeAudioDataSource"));
+  return propertyNames;
+}
+
+jsi::Value BaseAudioContextHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "destination") {
+    return jsi::Object::createFromHostObject(runtime, destination_);
+  }
+
+  if (propName == "state") {
+    return jsi::String::createFromUtf8(runtime, wrapper_->getState());
+  }
+
+  if (propName == "sampleRate") {
+    return {wrapper_->getSampleRate()};
+  }
+
+  if (propName == "currentTime") {
+    return {wrapper_->getCurrentTime()};
+  }
+
+  if (propName == "createOscillator") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto oscillator = wrapper_->createOscillator();
+          auto oscillatorHostObject =
+              OscillatorNodeHostObject::createFromWrapper(oscillator);
+          return jsi::Object::createFromHostObject(
+              runtime, oscillatorHostObject);
+        });
+  }
+
+  if (propName == "createGain") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto gain = wrapper_->createGain();
+          auto gainHostObject = GainNodeHostObject::createFromWrapper(gain);
+          return jsi::Object::createFromHostObject(runtime, gainHostObject);
+        });
+  }
+
+  if (propName == "createStereoPanner") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto stereoPanner = wrapper_->createStereoPanner();
+          auto stereoPannerHostObject =
+              StereoPannerNodeHostObject::createFromWrapper(stereoPanner);
+          return jsi::Object::createFromHostObject(
+              runtime, stereoPannerHostObject);
+        });
+  }
+
+  if (propName == "createBiquadFilter") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto biquadFilter = wrapper_->createBiquadFilter();
+          auto biquadFilterHostObject =
+              BiquadFilterNodeHostObject::createFromWrapper(biquadFilter);
+          return jsi::Object::createFromHostObject(
+              runtime, biquadFilterHostObject);
+        });
+  }
+
+  if (propName == "createBufferSource") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto bufferSource = wrapper_->createBufferSource();
+          auto bufferSourceHostObject =
+              AudioBufferSourceNodeHostObject::createFromWrapper(bufferSource);
+          return jsi::Object::createFromHostObject(
+              runtime, bufferSourceHostObject);
+        });
+  }
+
+  if (propName == "createBuffer") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto numberOfChannels = static_cast<int>(arguments[0].getNumber());
+          auto length = static_cast<int>(arguments[1].getNumber());
+          auto sampleRate = static_cast<int>(arguments[2].getNumber());
+          auto buffer =
+              wrapper_->createBuffer(numberOfChannels, length, sampleRate);
+          auto bufferHostObject =
+              AudioBufferHostObject::createFromWrapper(buffer);
+          return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+        });
+  }
+
+  if (propName == "createPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto real = arguments[0].getObject(runtime).getArray(runtime);
+          auto imag = arguments[1].getObject(runtime).getArray(runtime);
+          auto disableNormalization = arguments[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 = wrapper_->createPeriodicWave(
+              realData, imagData, disableNormalization, length);
+          auto periodicWaveHostObject =
+              PeriodicWaveHostObject::createFromWrapper(periodicWave);
+          return jsi::Object::createFromHostObject(
+              runtime, periodicWaveHostObject);
+        });
+  }
+
+  if (propName == "decodeAudioDataSource") {
+    auto decode = [this](jsi::Runtime& runtime,
+                         const jsi::Value&,
+                         const jsi::Value* arguments,
+                         size_t count) -> jsi::Value {
+      auto sourcePath = arguments[0].getString(runtime).utf8(runtime);
+
+      auto promise = promiseVendor_->createPromise([this, &runtime, sourcePath](std::shared_ptr<JsiPromise::Promise> promise) {
+        std::thread([this, &runtime, sourcePath, promise = std::move(promise)]() {
+          auto results = wrapper_->decodeAudioDataSource(sourcePath);
+          auto audioBufferHostObject = AudioBufferHostObject::createFromWrapper(results);
+
+          promise->resolve(jsi::Object::createFromHostObject(runtime, audioBufferHostObject));
+        }).detach();
+      });
+
+      return promise;
+    };
+
+    return jsi::Function::createFromHostFunction(runtime, propNameId, 1, decode);
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void BaseAudioContextHostObject::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/BaseAudioContextHostObject.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "JsiPromise.h"
+#include "AudioBufferHostObject.h"
+#include "AudioBufferSourceNodeHostObject.h"
+#include "AudioDestinationNodeHostObject.h"
+#include "BaseAudioContextWrapper.h"
+#include "BiquadFilterNodeHostObject.h"
+#include "GainNodeHostObject.h"
+#include "OscillatorNodeHostObject.h"
+#include "PeriodicWaveHostObject.h"
+#include "StereoPannerNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class BaseAudioContextHostObject : public jsi::HostObject {
+ public:
+  explicit BaseAudioContextHostObject(
+      const std::shared_ptr<BaseAudioContextWrapper> &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;
+
+ protected:
+  std::shared_ptr<BaseAudioContextWrapper> wrapper_;
+  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.cpp

@@ -30,6 +30,8 @@ std::vector<jsi::PropNameID> BiquadFilterNodeHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "Q"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "getFrequencyResponse"));
   return propertyNames;
 }
 
@@ -60,6 +62,48 @@ jsi::Value BiquadFilterNodeHostObject::get(
     return jsi::String::createFromUtf8(runtime, waveType);
   }
 
+  if (propName == "getFrequencyResponse") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto frequencyArray = args[0].getObject(rt).asArray(rt);
+          auto magResponseOut = args[1].getObject(rt).asArray(rt);
+          auto phaseResponseOut = args[2].getObject(rt).asArray(rt);
+
+          std::vector<float> frequencyArrayVector(frequencyArray.length(rt));
+          for (size_t i = 0; i < frequencyArray.length(rt); i++) {
+            frequencyArrayVector[i] = static_cast<float>(
+                frequencyArray.getValueAtIndex(rt, i).getNumber());
+          }
+
+          std::vector<float> magResponseOutVector(magResponseOut.length(rt));
+          std::vector<float> phaseResponseOutVector(
+              phaseResponseOut.length(rt));
+
+          auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+          wrapper->getFrequencyResponse(
+              frequencyArrayVector,
+              magResponseOutVector,
+              phaseResponseOutVector);
+
+          for (size_t i = 0; i < magResponseOutVector.size(); i++) {
+            magResponseOut.setValueAtIndex(rt, i, magResponseOutVector[i]);
+          }
+
+          for (size_t i = 0; i < phaseResponseOutVector.size(); i++) {
+            phaseResponseOut.setValueAtIndex(rt, i, phaseResponseOutVector[i]);
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
   return AudioNodeHostObject::get(runtime, propNameId);
 }