react-native-audio-api 0.11.0-nightly-0a987bc-20251120 → 0.11.0-nightly-6dcac64-20251122

package/RNAudioAPI.podspec

@@ -4,12 +4,14 @@ require_relative './scripts/rnaa_utils'
 package_json = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 $new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+$RN_AUDIO_API_FFMPEG_DISABLED = ENV['DISABLE_AUDIOAPI_FFMPEG'].nil? ? false : ENV['DISABLE_AUDIOAPI_FFMPEG'] == '1' # false by default
 
 folly_flags = "-DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32"
 fabric_flags = $new_arch_enabled ? '-DRCT_NEW_ARCH_ENABLED' : ''
 version_flag = "-DAUDIOAPI_VERSION=#{package_json['version']}"
 
 worklets_preprocessor_flag = check_if_worklets_enabled() ? '-DRN_AUDIO_API_ENABLE_WORKLETS=1' : ''
+ffmpeg_flag = $RN_AUDIO_API_FFMPEG_DISABLED ? '-DRN_AUDIO_API_FFMPEG_DISABLED=1' : ''
 
 Pod::Spec.new do |s|
   s.name         = "RNAudioAPI"
@@ -24,6 +26,7 @@ Pod::Spec.new do |s|
 
   s.subspec "audioapi" do |ss|
     ss.source_files = "common/cpp/audioapi/**/*.{cpp,c,h,hpp}"
+    ss.exclude_files = $RN_AUDIO_API_FFMPEG_DISABLED ? ["common/cpp/audioapi/libs/ffmpeg/**"] : []
     ss.header_dir = "audioapi"
     ss.header_mappings_dir = "common/cpp/audioapi"
 
@@ -57,7 +60,7 @@ Pod::Spec.new do |s|
   external_dir_relative = "common/cpp/audioapi/external"
   lib_dir = "$(PROJECT_DIR)/#{rn_audio_dir_relative}/#{external_dir_relative}/$(PLATFORM_NAME)"
 
-  s.ios.vendored_frameworks = [
+  s.ios.vendored_frameworks = $RN_AUDIO_API_FFMPEG_DISABLED ? [] : [
     'common/cpp/audioapi/external/ffmpeg_ios/libavcodec.xcframework',
     'common/cpp/audioapi/external/ffmpeg_ios/libavformat.xcframework',
     'common/cpp/audioapi/external/ffmpeg_ios/libavutil.xcframework',
@@ -75,10 +78,9 @@ s.pod_target_xcconfig = {
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include/opus
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include/vorbis
-    $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/ffmpeg_include
-  ].join(" "),
-  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag}",
-  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag}",
+  ].concat($RN_AUDIO_API_FFMPEG_DISABLED ? [] : ["$(PODS_TARGET_SRCROOT)/#{external_dir_relative}/ffmpeg_include"]).join(" "),
+  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag} #{ffmpeg_flag}",
+  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag} #{ffmpeg_flag}",
 }
 
 s.user_target_xcconfig = {

package/android/build.gradle

@@ -21,6 +21,10 @@ def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
+def isFFmpegDisabled() {
+  return rootProject.hasProperty("disableAudioapiFFmpeg") && rootProject.getProperty("disableAudioapiFFmpeg") == "true"
+}
+
 apply plugin: "com.android.library"
 apply plugin: 'org.jetbrains.kotlin.android'
 
@@ -124,6 +128,7 @@ file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { rea
 def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
 def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
 def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
+def IS_RN_AUDIO_API_FFMPEG_DISABLED = isFFmpegDisabled()
 
 android {
   sourceSets {
@@ -163,8 +168,9 @@ android {
           "-DANDROID_TOOLCHAIN=clang",
           "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
           "-DRN_AUDIO_API_WORKLETS_ENABLED=${isWorkletsAvailable}",
-                  "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}",
-                  "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+          "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}",
+          "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+          "-DRN_AUDIO_API_FFMPEG_DISABLED=${IS_RN_AUDIO_API_FFMPEG_DISABLED}"
         ]
 
         if (isWorkletsAvailable) {

package/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp

@@ -12,8 +12,10 @@
 
 #ifndef AUDIO_API_TEST_SUITE
 #include <android/log.h>
+#endif // AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
-#endif
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 #include <memory>
 #include <string>
@@ -73,6 +75,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
     float sampleRate) {
 #ifndef AUDIO_API_TEST_SUITE
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       __android_log_print(
@@ -80,6 +83,14 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
       return nullptr;
     }
     return buffer;
+#else
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "FFmpeg is disabled, cannot decode file: %s",
+        path.c_str());
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   ma_decoder decoder;
   ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
@@ -115,12 +126,18 @@ AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleR
 #ifndef AUDIO_API_TEST_SUITE
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
   if (format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
       return nullptr;
     }
     return buffer;
+#else
+    __android_log_print(
+        ANDROID_LOG_ERROR, "AudioDecoder", "FFmpeg is disabled, cannot decode memory block");
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   ma_decoder decoder;
   ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));

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

@@ -7,6 +7,7 @@
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
 #include <audioapi/HostObjects/effects/ConvolverNodeHostObject.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>
@@ -48,6 +49,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
       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),
@@ -159,11 +161,15 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
 }
 
 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());
   return object;
+#else
+  return jsi::Value::undefined();
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
@@ -190,6 +196,32 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   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);

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

@@ -36,6 +36,7 @@ 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);

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/sources/StreamerNodeHostObject.cpp

@@ -13,10 +13,14 @@ StreamerNodeHostObject::StreamerNodeHostObject(const std::shared_ptr<StreamerNod
 }
 
 JSI_HOST_FUNCTION_IMPL(StreamerNodeHostObject, initialize) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
   auto path = args[0].getString(runtime).utf8(runtime);
   auto result = streamerNode->initialize(path);
   return {result};
+#else
+  return false;
+#endif
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -4,6 +4,7 @@
 #include <audioapi/core/effects/BiquadFilterNode.h>
 #include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <audioapi/core/effects/IIRFilterNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
@@ -13,7 +14,9 @@
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/core/sources/StreamerNode.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
@@ -121,13 +124,15 @@ std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
   return constantSource;
 }
 
-#ifndef AUDIO_API_TEST_SUITE
 std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   auto streamer = std::make_shared<StreamerNode>(this);
   nodeManager_->addSourceNode(streamer);
   return streamer;
+#else
+  return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
-#endif
 
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   auto gain = std::make_shared<GainNode>(this);
@@ -147,6 +152,14 @@ std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
   return biquadFilter;
 }
 
+std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(
+    const std::vector<float> &feedforward,
+    const std::vector<float> &feedback) {
+  auto iirFilter = std::make_shared<IIRFilterNode>(this, feedforward, feedback);
+  nodeManager_->addProcessingNode(iirFilter);
+  return iirFilter;
+}
+
 std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(bool pitchCorrection) {
   auto bufferSource = std::make_shared<AudioBufferSourceNode>(this, pitchCorrection);
   nodeManager_->addSourceNode(bufferSource);

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -23,6 +23,7 @@ class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
+class IIRFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
@@ -70,6 +71,9 @@ class BaseAudioContext {
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
+  std::shared_ptr<IIRFilterNode> createIIRFilter(
+      const std::vector<float> &feedforward,
+      const std::vector<float> &feedback);
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
   std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
   static std::shared_ptr<AudioBuffer>

package/common/cpp/audioapi/core/effects/IIRFilterNode.cpp

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2016 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2020 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1.  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/IIRFilterNode.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+IIRFilterNode::IIRFilterNode(
+    BaseAudioContext *context,
+    const std::vector<float> &feedforward,
+    const std::vector<float> &feedback)
+    : AudioNode(context), feedforward_(feedforward), feedback_(feedback) {
+  isInitialized_ = true;
+  channelCountMode_ = ChannelCountMode::MAX;
+
+  int maxChannels = MAX_CHANNEL_COUNT;
+  xBuffers_.resize(maxChannels);
+  yBuffers_.resize(maxChannels);
+  bufferIndices.resize(maxChannels, 0);
+
+  for (int c = 0; c < maxChannels; ++c) {
+    xBuffers_[c].resize(bufferLength, 0.0f);
+    yBuffers_[c].resize(bufferLength, 0.0f);
+  }
+
+  size_t feedforwardLength = feedforward_.size();
+  size_t feedbackLength = feedback_.size();
+
+  if (feedback_[0] != 1) {
+    float scale = feedback_[0];
+    for (unsigned k = 1; k < feedbackLength; ++k)
+      feedback_[k] /= scale;
+
+    for (unsigned k = 0; k < feedforwardLength; ++k)
+      feedforward_[k] /= scale;
+
+    feedback_[0] = 1.0f;
+  }
+}
+
+// Compute Z-transform of the filter
+//
+// frequency response -  H(z)
+//          sum(b[k]*z^(-k), k, 0, M)
+//  H(z) = -------------------------------
+//           sum(a[k]*z^(-k), k, 0, N)
+//
+//          sum(b[k]*z1^k, k, 0, M)
+//       = -------------------------------
+//           sum(a[k]*z1^k, k, 0, N)
+//
+// where z1 = 1/z and z = e^(j * pi * frequency)
+// z1 = e^(-j * pi * frequency)
+//
+// phase response - angle of the frequency response
+//
+
+void IIRFilterNode::getFrequencyResponse(
+    const float *frequencyArray,
+    float *magResponseOutput,
+    float *phaseResponseOutput,
+    size_t length) {
+  float nyquist = context_->getNyquistFrequency();
+
+  for (size_t k = 0; k < length; ++k) {
+    float normalizedFreq = frequencyArray[k] / nyquist;
+
+    if (normalizedFreq < 0.0f || normalizedFreq > 1.0f) {
+      // Out-of-bounds frequencies should return NaN.
+      magResponseOutput[k] = std::nanf("");
+      phaseResponseOutput[k] = std::nanf("");
+      continue;
+    }
+
+    float omega = -PI * normalizedFreq;
+    auto z = std::complex<float>(std::cos(omega), std::sin(omega));
+
+    auto numerator = IIRFilterNode::evaluatePolynomial(feedforward_, z, feedforward_.size() - 1);
+    auto denominator = IIRFilterNode::evaluatePolynomial(feedback_, z, feedback_.size() - 1);
+    auto response = numerator / denominator;
+
+    magResponseOutput[k] = static_cast<float>(std::abs(response));
+    phaseResponseOutput[k] = static_cast<float>(atan2(imag(response), real(response)));
+  }
+}
+
+// y[n] = sum(b[k] * x[n - k], k = 0, M) - sum(a[k] * y[n - k], k = 1, N)
+// where b[k] are the feedforward coefficients and a[k] are the feedback coefficients of the filter
+
+// TODO: tail
+
+std::shared_ptr<AudioBus> IIRFilterNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  int numChannels = processingBus->getNumberOfChannels();
+
+  size_t feedforwardLength = feedforward_.size();
+  size_t feedbackLength = feedback_.size();
+  int minLength = std::min(feedbackLength, feedforwardLength);
+
+  int mask = bufferLength - 1;
+
+  for (int c = 0; c < numChannels; ++c) {
+    auto channelData = processingBus->getChannel(c)->getData();
+    auto &x = xBuffers_[c];
+    auto &y = yBuffers_[c];
+    size_t bufferIndex = bufferIndices[c];
+
+    for (int n = 0; n < framesToProcess; ++n) {
+      float yn = feedforward_[0] * channelData[n];
+
+      for (int k = 1; k < minLength; ++k) {
+        int m = (bufferIndex - k) & mask;
+        yn = std::fma(feedforward_[k], x[m], yn);
+        yn = std::fma(-feedback_[k], y[m], yn);
+      }
+
+      for (int k = minLength; k < feedforwardLength; ++k) {
+        yn = std::fma(feedforward_[k], x[(bufferIndex - k) & mask], yn);
+      }
+      for (int k = minLength; k < feedbackLength; ++k) {
+        yn = std::fma(-feedback_[k], y[(bufferIndex - k) & (bufferLength - 1)], yn);
+      }
+
+      channelData[n] = yn;
+
+      x[bufferIndex] = channelData[n];
+      y[bufferIndex] = yn;
+
+      bufferIndex = (bufferIndex + 1) & (bufferLength - 1);
+    }
+    bufferIndices[c] = bufferIndex;
+  }
+  return processingBus;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/effects/IIRFilterNode.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 The Chromium Authors. All rights reserved.
+ * Copyright (C) 2020 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1.  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <complex>
+#include <vector>
+
+#include <memory>
+
+namespace audioapi {
+
+class IIRFilterNode : public AudioNode {
+
+ public:
+  explicit IIRFilterNode(
+      BaseAudioContext *context,
+      const std::vector<float> &feedforward,
+      const std::vector<float> &feedback);
+
+  void getFrequencyResponse(
+      const float *frequencyArray,
+      float *magResponseOutput,
+      float *phaseResponseOutput,
+      size_t length);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  static constexpr size_t bufferLength = 32;
+  size_t m_bufferIndex = 0;
+
+  std::vector<float> feedforward_;
+  std::vector<float> feedback_;
+
+  std::vector<std::vector<float>> xBuffers_; // xBuffers_[channel][index]
+  std::vector<std::vector<float>> yBuffers_;
+  std::vector<size_t> bufferIndices;
+
+  static std::complex<float>
+  evaluatePolynomial(const std::vector<float> coefficients, std::complex<float> z, int order) {
+    // Use Horner's method to evaluate the polynomial P(z) = sum(coef[k]*z^k, k, 0, order);
+    std::complex<float> result = 0;
+    for (int k = order; k >= 0; --k)
+      result = result * z + std::complex<float>(coefficients[k]);
+    return result;
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -13,7 +13,7 @@
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/utils/AudioBus.h>
 
-#ifndef AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -22,7 +22,7 @@ extern "C" {
 #include <libavutil/samplefmt.h>
 #include <libswresample/swresample.h>
 }
-#endif
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 #include <atomic>
 #include <cmath>
@@ -36,7 +36,7 @@ static constexpr audioapi::channels::spsc::OverflowStrategy STREAMER_NODE_SPSC_O
     audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
 static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_STRATEGY =
     audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
-#endif
+#endif // AUDIO_API_TEST_SUITE
 
 static constexpr bool VERBOSE = false;
 static constexpr int CHANNEL_CAPACITY = 32;
@@ -78,7 +78,7 @@ class StreamerNode : public AudioScheduledSourceNode {
       int framesToProcess) override;
 
  private:
-#ifndef AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   AVFormatContext *fmtCtx_;
   AVCodecContext *codecCtx_;
   const AVCodec *decoder_;
@@ -149,6 +149,6 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    */
   bool setupDecoder();
-#endif // AUDIO_API_TEST_SUITE
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 };
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/Constants.h

@@ -10,6 +10,7 @@ namespace audioapi {
 // audio
 static constexpr int RENDER_QUANTUM_SIZE = 128;
 static constexpr size_t MAX_FFT_SIZE = 32768;
+static constexpr int MAX_CHANNEL_COUNT = 32;
 
 // stretcher
 static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -9,7 +9,9 @@
  */
 
 #include <audioapi/core/sources/AudioBuffer.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <functional>

package/common/cpp/test/CMakeLists.txt

@@ -81,6 +81,7 @@ add_executable(
 add_compile_definitions(AUDIO_API_TEST_SUITE)
 add_compile_definitions(RN_AUDIO_API_ENABLE_WORKLETS=0)
 add_compile_definitions(RN_AUDIO_API_TEST=1)
+add_compile_definitions(RN_AUDIO_API_FFMPEG_DISABLED=1)
 
 target_link_libraries(tests
   rnaudioapi