react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h

@@ -4,10 +4,10 @@
 #include <audioapi/jsi/JsiPromise.h>
 
 #include <jsi/jsi.h>
+#include <cstddef>
 #include <memory>
 #include <utility>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 using namespace facebook;
@@ -36,11 +36,14 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createGain);
   JSI_HOST_FUNCTION_DECL(createStereoPanner);
   JSI_HOST_FUNCTION_DECL(createBiquadFilter);
+  JSI_HOST_FUNCTION_DECL(createIIRFilter);
   JSI_HOST_FUNCTION_DECL(createBufferSource);
   JSI_HOST_FUNCTION_DECL(createBufferQueueSource);
   JSI_HOST_FUNCTION_DECL(createBuffer);
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
+  JSI_HOST_FUNCTION_DECL(createConvolver);
+  JSI_HOST_FUNCTION_DECL(createDelay);
 
   std::shared_ptr<BaseAudioContext> context_;
 

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp

@@ -2,6 +2,8 @@
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/core/OfflineAudioContext.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -17,52 +19,44 @@ OfflineAudioContextHostObject::OfflineAudioContextHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, resume) {
-  auto promise = promiseVendor_->createPromise(
-      [this](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-        audioContext->resume();
-      });
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+  auto promise = promiseVendor_->createAsyncPromise([audioContext]() {
+    audioContext->resume();
+    return [](jsi::Runtime &runtime) {
+      return jsi::Value::undefined();
+    };
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
   double when = args[0].getNumber();
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
 
-  auto promise = promiseVendor_->createPromise(
-      [this, when](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-        OfflineAudioContextSuspendCallback callback = [promise]() {
-          promise->resolve(
-              [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
-        };
-        audioContext->suspend(when, callback);
-      });
+  auto promise = promiseVendor_->createAsyncPromise([=](Promise &&promise) {
+    OfflineAudioContextSuspendCallback callback = [promise = std::move(promise)]() {
+      promise.resolve([](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+    };
+    audioContext->suspend(when, callback);
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, startRendering) {
-  auto promise = promiseVendor_->createPromise(
-      [this](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-
-        OfflineAudioContextResultCallback callback =
-            [promise](const std::shared_ptr<AudioBuffer> &audioBuffer) -> void {
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(audioBuffer);
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            return jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+  auto promise = promiseVendor_->createAsyncPromise([audioContext](Promise &&promise) {
+    OfflineAudioContextResultCallback callback =
+        [promise = std::move(promise)](const std::shared_ptr<AudioBuffer> &audioBuffer) {
+          auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+          promise.resolve([audioBufferHostObject](jsi::Runtime &runtime) {
+            return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
           });
         };
 
-        audioContext->startRendering(callback);
-      });
+    audioContext->startRendering(callback);
+  });
 
   return promise;
 }

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.h

@@ -15,9 +15,9 @@ class OfflineAudioContext;
 class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit OfflineAudioContextHostObject(
-          const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
-          jsi::Runtime *runtime,
-          const std::shared_ptr<react::CallInvoker> &callInvoker);
+      const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
 
   JSI_HOST_FUNCTION_DECL(resume);
   JSI_HOST_FUNCTION_DECL(suspend);

package/common/cpp/audioapi/HostObjects/WorkletNodeHostObject.h

@@ -12,7 +12,6 @@ using namespace facebook;
 class WorkletNodeHostObject : public AudioNodeHostObject {
  public:
   explicit WorkletNodeHostObject(const std::shared_ptr<WorkletNode> &node)
-      : AudioNodeHostObject(node) {
-  }
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/WorkletProcessingNodeHostObject.h

@@ -12,7 +12,6 @@ using namespace facebook;
 class WorkletProcessingNodeHostObject : public AudioNodeHostObject {
  public:
   explicit WorkletProcessingNodeHostObject(const std::shared_ptr<WorkletProcessingNode> &node)
-      : AudioNodeHostObject(node) {
-  }
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp

@@ -1,11 +1,11 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 
 #include <audioapi/core/analysis/AnalyserNode.h>
+#include <memory>
 
 namespace audioapi {
 
-AnalyserNodeHostObject::AnalyserNodeHostObject(
-    const std::shared_ptr<AnalyserNode> &node)
+AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
     : AudioNodeHostObject(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
@@ -90,10 +90,8 @@ JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, window) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
@@ -104,10 +102,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
@@ -118,10 +114,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
@@ -132,10 +126,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteTimeDomainData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 

package/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 
 #include <memory>
 #include <vector>
@@ -11,8 +11,7 @@ using namespace facebook;
 
 class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit AudioDestinationNodeHostObject(
-      const std::shared_ptr<AudioDestinationNode> &node)
+  explicit AudioDestinationNodeHostObject(const std::shared_ptr<AudioDestinationNode> &node)
       : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -17,35 +18,31 @@ BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
 
   addSetters(JSI_EXPORT_PROPERTY_SETTER(BiquadFilterNodeHostObject, type));
 
-  addFunctions(
-      JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
+  addFunctions(JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, frequency) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
-      biquadFilterNode->getFrequencyParam());
+  auto frequencyParam_ =
+      std::make_shared<AudioParamHostObject>(biquadFilterNode->getFrequencyParam());
   return jsi::Object::createFromHostObject(runtime, frequencyParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, detune) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto detuneParam_ = std::make_shared<AudioParamHostObject>(
-      biquadFilterNode->getDetuneParam());
+  auto detuneParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getDetuneParam());
   return jsi::Object::createFromHostObject(runtime, detuneParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, Q) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto QParam_ =
-      std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
+  auto QParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
   return jsi::Object::createFromHostObject(runtime, QParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, gain) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto gainParam_ =
-      std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
+  auto gainParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
   return jsi::Object::createFromHostObject(runtime, gainParam_);
 }
 
@@ -61,30 +58,21 @@ JSI_PROPERTY_SETTER_IMPL(BiquadFilterNodeHostObject, type) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
-  auto arrayBufferFrequency = args[0]
-                                  .getObject(runtime)
-                                  .getPropertyAsObject(runtime, "buffer")
-                                  .getArrayBuffer(runtime);
-  auto frequencyArray =
-      reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
-  auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
-
-  auto arrayBufferMag = args[1]
-                            .getObject(runtime)
-                            .getPropertyAsObject(runtime, "buffer")
-                            .getArrayBuffer(runtime);
+  auto arrayBufferFrequency =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto frequencyArray = reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+  auto length = static_cast<size_t>(arrayBufferFrequency.size(runtime));
+
+  auto arrayBufferMag =
+      args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
 
-  auto arrayBufferPhase = args[2]
-                              .getObject(runtime)
-                              .getPropertyAsObject(runtime, "buffer")
-                              .getArrayBuffer(runtime);
-  auto phaseResponseOut =
-      reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
+  auto arrayBufferPhase =
+      args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
 
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  biquadFilterNode->getFrequencyResponse(
-      frequencyArray, magResponseOut, phaseResponseOut, length);
+  biquadFilterNode->getFrequencyResponse(frequencyArray, magResponseOut, phaseResponseOut, length);
 
   return jsi::Value::undefined();
 }

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h

@@ -13,8 +13,7 @@ class BiquadFilterNode;
 
 class BiquadFilterNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit BiquadFilterNodeHostObject(
-      const std::shared_ptr<BiquadFilterNode> &node);
+  explicit BiquadFilterNodeHostObject(const std::shared_ptr<BiquadFilterNode> &node);
 
   JSI_PROPERTY_GETTER_DECL(frequency);
   JSI_PROPERTY_GETTER_DECL(detune);

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -0,0 +1,50 @@
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <memory>
+
+namespace audioapi {
+
+ConvolverNodeHostObject::ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, buffer));
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, normalize));
+  addFunctions(JSI_EXPORT_FUNCTION(ConvolverNodeHostObject, setBuffer));
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  return {convolverNode->getNormalize_()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, buffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  auto buffer = convolverNode->getBuffer();
+  auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes() + 16);
+  return jsiObject;
+}
+
+JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  convolverNode->setNormalize(value.getBool());
+}
+
+JSI_HOST_FUNCTION_IMPL(ConvolverNodeHostObject, setBuffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  if (args[0].isUndefined()) {
+    convolverNode->setBuffer(nullptr);
+    return jsi::Value::undefined();
+  }
+
+  auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  convolverNode->setBuffer(bufferHostObject->audioBuffer_);
+  thisValue.asObject(runtime).setExternalMemoryPressure(
+      runtime, bufferHostObject->getSizeInBytes() + 16);
+  return jsi::Value::undefined();
+}
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConvolverNode;
+
+class ConvolverNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node);
+  JSI_PROPERTY_GETTER_DECL(normalize);
+  JSI_PROPERTY_GETTER_DECL(buffer);
+  JSI_PROPERTY_SETTER_DECL(normalize);
+  JSI_HOST_FUNCTION_DECL(setBuffer);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp

@@ -0,0 +1,27 @@
+#include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/DelayNode.h>
+#include <memory>
+
+namespace audioapi {
+
+DelayNodeHostObject::DelayNodeHostObject(const std::shared_ptr<DelayNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
+}
+
+size_t DelayNodeHostObject::getSizeInBytes() const {
+  auto delayNode = std::static_pointer_cast<DelayNode>(node_);
+  return sizeof(float) * delayNode->context_->getSampleRate() *
+      delayNode->getDelayTimeParam()->getMaxValue();
+}
+
+JSI_PROPERTY_GETTER_IMPL(DelayNodeHostObject, delayTime) {
+  auto delayNode = std::static_pointer_cast<DelayNode>(node_);
+  auto delayTimeParam = std::make_shared<AudioParamHostObject>(delayNode->getDelayTimeParam());
+  return jsi::Object::createFromHostObject(runtime, delayTimeParam);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class DelayNode;
+
+class DelayNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit DelayNodeHostObject(const std::shared_ptr<DelayNode> &node);
+
+  [[nodiscard]] size_t getSizeInBytes() const;
+
+  JSI_PROPERTY_GETTER_DECL(delayTime);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -12,8 +13,7 @@ GainNodeHostObject::GainNodeHostObject(const std::shared_ptr<GainNode> &node)
 
 JSI_PROPERTY_GETTER_IMPL(GainNodeHostObject, gain) {
   auto gainNode = std::static_pointer_cast<GainNode>(node_);
-  auto gainParam =
-      std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+  auto gainParam = std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
   return jsi::Object::createFromHostObject(runtime, gainParam);
 }
 

package/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp

@@ -0,0 +1,33 @@
+#include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
+#include <audioapi/core/effects/IIRFilterNode.h>
+#include <memory>
+
+namespace audioapi {
+
+IIRFilterNodeHostObject::IIRFilterNodeHostObject(const std::shared_ptr<IIRFilterNode> &node)
+    : AudioNodeHostObject(node) {
+
+  addFunctions(JSI_EXPORT_FUNCTION(IIRFilterNodeHostObject, getFrequencyResponse));
+}
+
+JSI_HOST_FUNCTION_IMPL(IIRFilterNodeHostObject, getFrequencyResponse) {
+  auto arrayBufferFrequency =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto frequencyArray = reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+  auto length = static_cast<size_t>(arrayBufferFrequency.size(runtime));
+
+  auto arrayBufferMag =
+      args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
+
+  auto arrayBufferPhase =
+      args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
+
+  auto iirFilterNode = std::static_pointer_cast<IIRFilterNode>(node_);
+  iirFilterNode->getFrequencyResponse(frequencyArray, magResponseOut, phaseResponseOut, length);
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class IIRFilterNode;
+
+class IIRFilterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit IIRFilterNodeHostObject(const std::shared_ptr<IIRFilterNode> &node);
+
+  JSI_HOST_FUNCTION_DECL(getFrequencyResponse);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/PeriodicWaveHostObject.h

@@ -13,8 +13,7 @@ class PeriodicWaveHostObject : public jsi::HostObject {
  public:
   std::shared_ptr<PeriodicWave> periodicWave_;
 
-  explicit PeriodicWaveHostObject(
-      const std::shared_ptr<PeriodicWave> &periodicWave)
+  explicit PeriodicWaveHostObject(const std::shared_ptr<PeriodicWave> &periodicWave)
       : periodicWave_(periodicWave) {}
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -13,8 +14,7 @@ StereoPannerNodeHostObject::StereoPannerNodeHostObject(
 
 JSI_PROPERTY_GETTER_IMPL(StereoPannerNodeHostObject, pan) {
   auto stereoPannerNode = std::static_pointer_cast<StereoPannerNode>(node_);
-  auto panParam_ =
-      std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
+  auto panParam_ = std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
   return jsi::Object::createFromHostObject(runtime, panParam_);
 }
 

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.h

@@ -13,8 +13,7 @@ class StereoPannerNode;
 
 class StereoPannerNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit StereoPannerNodeHostObject(
-      const std::shared_ptr<StereoPannerNode> &node);
+  explicit StereoPannerNodeHostObject(const std::shared_ptr<StereoPannerNode> &node);
 
   JSI_PROPERTY_GETTER_DECL(pan);
 };

package/common/cpp/audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
 
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -9,27 +10,20 @@ AudioEventHandlerRegistryHostObject::AudioEventHandlerRegistryHostObject(
   eventHandlerRegistry_ = eventHandlerRegistry;
 
   addFunctions(
-      JSI_EXPORT_FUNCTION(
-          AudioEventHandlerRegistryHostObject, addAudioEventListener),
-      JSI_EXPORT_FUNCTION(
-          AudioEventHandlerRegistryHostObject, removeAudioEventListener));
+      JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, addAudioEventListener),
+      JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, removeAudioEventListener));
 }
 
-JSI_HOST_FUNCTION_IMPL(
-    AudioEventHandlerRegistryHostObject,
-    addAudioEventListener) {
+JSI_HOST_FUNCTION_IMPL(AudioEventHandlerRegistryHostObject, addAudioEventListener) {
   auto eventName = args[0].getString(runtime).utf8(runtime);
-  auto callback = std::make_shared<jsi::Function>(
-      args[1].getObject(runtime).getFunction(runtime));
+  auto callback = std::make_shared<jsi::Function>(args[1].getObject(runtime).getFunction(runtime));
 
   auto listenerId = eventHandlerRegistry_->registerHandler(eventName, callback);
 
   return jsi::String::createFromUtf8(runtime, std::to_string(listenerId));
 }
 
-JSI_HOST_FUNCTION_IMPL(
-    AudioEventHandlerRegistryHostObject,
-    removeAudioEventListener) {
+JSI_HOST_FUNCTION_IMPL(AudioEventHandlerRegistryHostObject, removeAudioEventListener) {
   auto eventName = args[0].getString(runtime).utf8(runtime);
   uint64_t listenerId = std::stoull(args[1].getString(runtime).utf8(runtime));
 

package/common/cpp/audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h

@@ -2,12 +2,12 @@
 
 #include <audioapi/jsi/JsiHostObject.h>
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
 #include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
-#include <string>
 
 namespace audioapi {
 using namespace facebook;
@@ -16,13 +16,13 @@ class AudioEventHandlerRegistry;
 
 class AudioEventHandlerRegistryHostObject : public JsiHostObject {
  public:
-    explicit AudioEventHandlerRegistryHostObject(const std::shared_ptr<AudioEventHandlerRegistry>& eventHandlerRegistry);
+  explicit AudioEventHandlerRegistryHostObject(
+      const std::shared_ptr<AudioEventHandlerRegistry> &eventHandlerRegistry);
 
-    JSI_HOST_FUNCTION_DECL(addAudioEventListener);
-    JSI_HOST_FUNCTION_DECL(removeAudioEventListener);
+  JSI_HOST_FUNCTION_DECL(addAudioEventListener);
+  JSI_HOST_FUNCTION_DECL(removeAudioEventListener);
 
  private:
-    std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
+  std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
 };
 } // namespace audioapi
-