react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.3

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -17,6 +17,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace audioapi {
 
@@ -27,8 +28,7 @@ class AudioAPIModuleInstaller {
   static void injectJSIBindings(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
     auto createAudioContext = getCreateAudioContextFunction(
         jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
@@ -36,38 +36,29 @@ class AudioAPIModuleInstaller {
         getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
     auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(
         jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
-    auto createAudioDecoder =
-        getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
-    auto createAudioStretcher =
-        getCreateAudioStretcherFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioDecoder = getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioStretcher = getCreateAudioStretcherFunction(jsiRuntime, jsCallInvoker);
 
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioContext", createAudioContext);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioRecorder", createAudioRecorder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
     jsiRuntime->global().setProperty(
         *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioDecoder", createAudioDecoder);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioStretcher", createAudioStretcher);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioDecoder", createAudioDecoder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioStretcher", createAudioStretcher);
 
     auto audioEventHandlerRegistryHostObject =
-        std::make_shared<AudioEventHandlerRegistryHostObject>(
-            audioEventHandlerRegistry);
+        std::make_shared<AudioEventHandlerRegistryHostObject>(audioEventHandlerRegistry);
     jsiRuntime->global().setProperty(
         *jsiRuntime,
         "AudioEventEmitter",
-        jsi::Object::createFromHostObject(
-            *jsiRuntime, audioEventHandlerRegistryHostObject));
+        jsi::Object::createFromHostObject(*jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
  private:
   static jsi::Function getCreateAudioContextFunction(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
@@ -80,36 +71,29 @@ class AudioAPIModuleInstaller {
             size_t count) -> jsi::Value {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
-          auto initSuspended = args[1].getBool();
 
-          #if RN_AUDIO_API_ENABLE_WORKLETS
-              auto runtimeRegistry = RuntimeRegistry{
-                  .uiRuntime = uiRuntime,
-                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[2])
-              };
-          #else
-              auto runtimeRegistry = RuntimeRegistry{};
-          #endif
+#if RN_AUDIO_API_ENABLE_WORKLETS
+          auto runtimeRegistry = RuntimeRegistry{
+              .uiRuntime = uiRuntime,
+              .audioRuntime = worklets::extractWorkletRuntime(runtime, args[1])};
+#else
+          auto runtimeRegistry = RuntimeRegistry{};
+#endif
 
           audioContext = std::make_shared<AudioContext>(
-              sampleRate,
-              initSuspended,
-              audioEventHandlerRegistry,
-              runtimeRegistry);
+              sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+
           auto audioContextHostObject =
-              std::make_shared<AudioContextHostObject>(
-                  audioContext, &runtime, jsCallInvoker);
+              std::make_shared<AudioContextHostObject>(audioContext, &runtime, jsCallInvoker);
 
-          return jsi::Object::createFromHostObject(
-              runtime, audioContextHostObject);
+          return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
         });
   }
 
   static jsi::Function getCreateOfflineAudioContextFunction(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
@@ -124,34 +108,27 @@ class AudioAPIModuleInstaller {
           auto length = static_cast<size_t>(args[1].getNumber());
           auto sampleRate = static_cast<float>(args[2].getNumber());
 
-            #if RN_AUDIO_API_ENABLE_WORKLETS
-                auto runtimeRegistry = RuntimeRegistry{
-                    .uiRuntime = uiRuntime,
-                    .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])
-                };
-            #else
-            auto runtimeRegistry = RuntimeRegistry{};
-            #endif
-
-            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
-              numberOfChannels,
-              length,
-              sampleRate,
-              audioEventHandlerRegistry,
-              runtimeRegistry);
-            auto audioContextHostObject =
-              std::make_shared<OfflineAudioContextHostObject>(
-                    offlineAudioContext, &runtime, jsCallInvoker);
-
-            return jsi::Object::createFromHostObject(
-                runtime, audioContextHostObject);
+#if RN_AUDIO_API_ENABLE_WORKLETS
+          auto runtimeRegistry = RuntimeRegistry{
+              .uiRuntime = uiRuntime,
+              .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])};
+#else
+          auto runtimeRegistry = RuntimeRegistry{};
+#endif
+
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(
+              numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+
+          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+              offlineAudioContext, &runtime, jsCallInvoker);
+
+          return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
         });
   }
 
   static jsi::Function getCreateAudioRecorderFunction(
       jsi::Runtime *jsiRuntime,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry) {
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -164,8 +141,9 @@ class AudioAPIModuleInstaller {
           auto audioRecorderHostObject =
               std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry);
 
-          return jsi::Object::createFromHostObject(
-              runtime, audioRecorderHostObject);
+          auto jsiObject = jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
+
+          return jsiObject;
         });
   }
 
@@ -183,8 +161,7 @@ class AudioAPIModuleInstaller {
             size_t count) -> jsi::Value {
           auto audioDecoderHostObject =
               std::make_shared<AudioDecoderHostObject>(&runtime, jsCallInvoker);
-          return jsi::Object::createFromHostObject(
-              runtime, audioDecoderHostObject);
+          return jsi::Object::createFromHostObject(runtime, audioDecoderHostObject);
         });
   }
 
@@ -201,10 +178,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value *args,
             size_t count) -> jsi::Value {
           auto audioStretcherHostObject =
-              std::make_shared<AudioStretcherHostObject>(
-                  &runtime, jsCallInvoker);
-          return jsi::Object::createFromHostObject(
-              runtime, audioStretcherHostObject);
+              std::make_shared<AudioStretcherHostObject>(&runtime, jsCallInvoker);
+          return jsi::Object::createFromHostObject(runtime, audioStretcherHostObject);
         });
   }
 };

package/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp

@@ -1,6 +1,8 @@
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 
 #include <audioapi/core/AudioContext.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -17,39 +19,35 @@ AudioContextHostObject::AudioContextHostObject(
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
-        audioContext->close();
-
-        promise->resolve(
-            [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
-      });
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    return [audioContext](jsi::Runtime &runtime) {
+      audioContext->close();
+      return jsi::Value::undefined();
+    };
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
-        auto result = audioContext->resume();
-
-        promise->resolve(
-            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
-      });
-
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    auto result = audioContext->resume();
+    return [result](jsi::Runtime &runtime) {
+      return jsi::Value(result);
+    };
+  });
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
-        auto result = audioContext->suspend();
-
-        promise->resolve(
-            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
-      });
+  auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
+    auto result = audioContext->suspend();
+    return [result](jsi::Runtime &runtime) {
+      return jsi::Value(result);
+    };
+  });
 
   return promise;
 }

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -2,11 +2,11 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/AudioNode.h>
+#include <memory>
 
 namespace audioapi {
 
-AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
-    : node_(node) {
+AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node) : node_(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
@@ -36,8 +36,7 @@ JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCountMode) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
-  return jsi::String::createFromUtf8(
-      runtime, node_->getChannelInterpretation());
+  return jsi::String::createFromUtf8(runtime, node_->getChannelInterpretation());
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {

package/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp

@@ -1,11 +1,12 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 
 #include <audioapi/core/AudioParam.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
-AudioParamHostObject::AudioParamHostObject(
-    const std::shared_ptr<AudioParam> &param)
+AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
     : param_(param) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
@@ -75,14 +76,11 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
-  auto values =
-      std::make_unique<std::vector<float>>(rawValues, rawValues + length);
+  auto values = std::make_unique<std::vector<float>>(rawValues, rawValues + length);
 
   double startTime = args[1].getNumber();
   double duration = args[2].getNumber();

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

@@ -3,10 +3,10 @@
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
-#include <utility>
+#include <cstddef>
 #include <memory>
+#include <utility>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 using namespace facebook;

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

@@ -5,7 +5,10 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
+#include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
+#include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
@@ -18,6 +21,9 @@
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 
+#include <memory>
+#include <vector>
+
 namespace audioapi {
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
@@ -36,25 +42,26 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
   addFunctions(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletSourceNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletNode),
-      JSI_EXPORT_FUNCTION(
-          BaseAudioContextHostObject, createWorkletProcessingNode),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletProcessingNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStreamer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConstantSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createDelay),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createIIRFilter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
-  auto destination = std::make_shared<AudioDestinationNodeHostObject>(
-      context_->getDestination());
+  auto destination = std::make_shared<AudioDestinationNodeHostObject>(context_->getDestination());
   return jsi::Object::createFromHostObject(runtime, destination);
 }
 
@@ -73,8 +80,7 @@ JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, currentTime) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
   auto shouldLockRuntime = shouldUseUiRuntime;
@@ -84,12 +90,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletSourceNode = context_->createWorkletSourceNode(
-      shareableWorklet, workletRuntime, shouldLockRuntime);
+  auto workletSourceNode =
+      context_->createWorkletSourceNode(shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletSourceNodeHostObject =
       std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletSourceNodeHostObject);
+  return jsi::Object::createFromHostObject(runtime, workletSourceNodeHostObject);
 #endif
   return jsi::Value::undefined();
 }
@@ -97,8 +102,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
@@ -112,25 +116,21 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
   auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
   auto workletNode = context_->createWorkletNode(
-      shareableWorklet,
-      workletRuntime,
-      bufferLength,
-      inputChannelCount,
-      shouldLockRuntime);
-  auto workletNodeHostObject =
-      std::make_shared<WorkletNodeHostObject>(workletNode);
-  return jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
+      shareableWorklet, workletRuntime, bufferLength, inputChannelCount, shouldLockRuntime);
+  auto workletNodeHostObject = std::make_shared<WorkletNodeHostObject>(workletNode);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
+  jsiObject.setExternalMemoryPressure(
+      runtime,
+      sizeof(float) * bufferLength * inputChannelCount); // rough estimate of underlying buffer
+  return jsiObject;
 #endif
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(
-    BaseAudioContextHostObject,
-    createWorkletProcessingNode) {
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletProcessingNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
@@ -141,43 +141,42 @@ JSI_HOST_FUNCTION_IMPL(
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletProcessingNode = context_->createWorkletProcessingNode(
-      shareableWorklet, workletRuntime, shouldLockRuntime);
+  auto workletProcessingNode =
+      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletProcessingNodeHostObject =
       std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletProcessingNodeHostObject);
+  return jsi::Object::createFromHostObject(runtime, workletProcessingNodeHostObject);
 #endif
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
   auto recorderAdapter = context_->createRecorderAdapter();
-  auto recorderAdapterHostObject =
-      std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
+  auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
   return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
   auto oscillator = context_->createOscillator();
-  auto oscillatorHostObject =
-      std::make_shared<OscillatorNodeHostObject>(oscillator);
+  auto oscillatorHostObject = std::make_shared<OscillatorNodeHostObject>(oscillator);
   return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   auto streamer = context_->createStreamer();
   auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
   auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
-  object.setExternalMemoryPressure(
-      runtime, StreamerNodeHostObject::getSizeInBytes());
+  object.setExternalMemoryPressure(runtime, StreamerNodeHostObject::getSizeInBytes());
   return object;
+#else
+  return jsi::Value::undefined();
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
   auto constantSource = context_->createConstantSource();
-  auto constantSourceHostObject =
-      std::make_shared<ConstantSourceNodeHostObject>(constantSource);
+  auto constantSourceHostObject = std::make_shared<ConstantSourceNodeHostObject>(constantSource);
   return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
 }
 
@@ -187,25 +186,57 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
   return jsi::Object::createFromHostObject(runtime, gainHostObject);
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
+  auto maxDelayTime = static_cast<float>(args[0].getNumber());
+  auto delayNode = context_->createDelay(maxDelayTime);
+  auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(delayNode);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, delayNodeHostObject);
+  jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getSizeInBytes());
+  return jsiObject;
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
   auto stereoPanner = context_->createStereoPanner();
-  auto stereoPannerHostObject =
-      std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
+  auto stereoPannerHostObject = std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
   return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   auto biquadFilter = context_->createBiquadFilter();
-  auto biquadFilterHostObject =
-      std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
+  auto biquadFilterHostObject = std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createIIRFilter) {
+  auto feedforwardArray = args[0].asObject(runtime).asArray(runtime);
+  auto feedbackArray = args[1].asObject(runtime).asArray(runtime);
+
+  size_t feedforwardLength = feedforwardArray.length(runtime);
+  size_t feedbackLength = feedbackArray.length(runtime);
+
+  std::vector<float> feedforward;
+  std::vector<float> feedback;
+
+  feedforward.reserve(feedforwardLength);
+  feedback.reserve(feedbackLength);
+
+  for (size_t i = 0; i < feedforwardLength; ++i) {
+    feedforward.push_back(feedforwardArray.getValueAtIndex(runtime, i).asNumber());
+  }
+
+  for (size_t i = 0; i < feedbackLength; ++i) {
+    feedback.push_back(feedbackArray.getValueAtIndex(runtime, i).asNumber());
+  }
+
+  auto iirFilter = context_->createIIRFilter(feedforward, feedback);
+  auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(iirFilter);
+  return jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
   auto pitchCorrection = args[0].asBool();
   auto bufferSource = context_->createBufferSource(pitchCorrection);
-  auto bufferSourceHostObject =
-      std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
+  auto bufferSourceHostObject = std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
@@ -214,37 +245,30 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
   auto bufferSource = context_->createBufferQueueSource(pitchCorrection);
   auto bufferStreamSourceHostObject =
       std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
-  return jsi::Object::createFromHostObject(
-      runtime, bufferStreamSourceHostObject);
+  return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
   auto numberOfChannels = static_cast<int>(args[0].getNumber());
   auto length = static_cast<size_t>(args[1].getNumber());
   auto sampleRate = static_cast<float>(args[2].getNumber());
-  auto buffer =
-      BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
+  auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
 
   auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
-  jsiObject.setExternalMemoryPressure(
-      runtime, bufferHostObject->getSizeInBytes());
+  jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
 
   return jsiObject;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
-  auto arrayBufferReal = args[0]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
+  auto arrayBufferReal =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto real = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
   auto length = static_cast<int>(arrayBufferReal.size(runtime));
 
-  auto arrayBufferImag = args[1]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
+  auto arrayBufferImag =
+      args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto imag = reinterpret_cast<float *>(arrayBufferImag.data(runtime));
 
   auto disableNormalization = args[2].getBool();
@@ -252,14 +276,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
   auto complexData = std::vector<std::complex<float>>(length);
 
   for (size_t i = 0; i < length; i++) {
-    complexData[i] = std::complex<float>(
-        static_cast<float>(real[i]), static_cast<float>(imag[i]));
+    complexData[i] = std::complex<float>(static_cast<float>(real[i]), static_cast<float>(imag[i]));
   }
 
-  auto periodicWave =
-      context_->createPeriodicWave(complexData, disableNormalization, length);
-  auto periodicWaveHostObject =
-      std::make_shared<PeriodicWaveHostObject>(periodicWave);
+  auto periodicWave = context_->createPeriodicWave(complexData, disableNormalization, length);
+  auto periodicWaveHostObject = std::make_shared<PeriodicWaveHostObject>(periodicWave);
 
   return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
 }
@@ -269,4 +290,22 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
+
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
+  auto disableNormalization = args[1].getBool();
+  std::shared_ptr<ConvolverNode> convolver;
+  if (args[0].isUndefined()) {
+    convolver = context_->createConvolver(nullptr, disableNormalization);
+  } else {
+    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    convolver = context_->createConvolver(bufferHostObject->audioBuffer_, disableNormalization);
+  }
+  auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(convolver);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, convolverHostObject);
+  if (!args[0].isUndefined()) {
+    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
+  }
+  return jsiObject;
+}
 } // namespace audioapi