From 1e4533847b76b209cdf5e0ad1f701b67e3fc29e9 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 17 Jun 2025 10:19:38 +0200
Subject: [PATCH 1/3] feat: convolver impl

---
 .../src/examples/Oscillator/Oscillator.tsx    |   51 +-
 .../HostObjects/BaseAudioContextHostObject.h  |    9 +
 .../HostObjects/ConvolverNodeHostObject.h     |   56 +
 .../cpp/audioapi/core/BaseAudioContext.cpp    |    8 +
 .../cpp/audioapi/core/BaseAudioContext.h      |    2 +
 .../audioapi/core/effects/ConvolverNode.cpp   |   95 ++
 .../cpp/audioapi/core/effects/ConvolverNode.h |   38 +
 .../common/cpp/audioapi/dsp/AudioUtils.cpp    |    2 +-
 .../common/cpp/audioapi/dsp/Convolver.cpp     |  189 +++
 .../common/cpp/audioapi/dsp/Convolver.h       |   33 +
 .../common/cpp/audioapi/dsp/FFT.cpp           |   10 +-
 .../cpp/audioapi/libs/FFTConvolver/.gitignore |    2 +
 .../audioapi/libs/FFTConvolver/AudioFFT.cpp   | 1120 +++++++++++++++++
 .../cpp/audioapi/libs/FFTConvolver/AudioFFT.h |  168 +++
 .../audioapi/libs/FFTConvolver/COPYING.txt    |   18 +
 .../libs/FFTConvolver/FFTConvolver.cpp        |  206 +++
 .../audioapi/libs/FFTConvolver/FFTConvolver.h |  104 ++
 .../cpp/audioapi/libs/FFTConvolver/README.md  |   10 +
 .../FFTConvolver/TwoStageFFTConvolver.cpp     |  239 ++++
 .../libs/FFTConvolver/TwoStageFFTConvolver.h  |  129 ++
 .../audioapi/libs/FFTConvolver/Utilities.cpp  |  117 ++
 .../audioapi/libs/FFTConvolver/Utilities.h    |  355 ++++++
 .../audioapi/libs/FFTConvolver/test/Test.cpp  |  342 +++++
 packages/react-native-audio-api/src/api.ts    |    1 +
 .../src/core/BaseAudioContext.ts              |    5 +
 .../src/core/ConvolverNode.ts                 |   35 +
 .../react-native-audio-api/src/interfaces.ts  |    6 +
 27 files changed, 3331 insertions(+), 19 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/HostObjects/ConvolverNodeHostObject.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/.gitignore
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.cpp
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/COPYING.txt
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.cpp
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/README.md
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.cpp
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.h
 create mode 100755 packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/test/Test.cpp
 create mode 100644 packages/react-native-audio-api/src/core/ConvolverNode.ts

diff --git a/apps/common-app/src/examples/Oscillator/Oscillator.tsx b/apps/common-app/src/examples/Oscillator/Oscillator.tsx
index ad32abff4..c1319d557 100644
--- a/apps/common-app/src/examples/Oscillator/Oscillator.tsx
+++ b/apps/common-app/src/examples/Oscillator/Oscillator.tsx
@@ -1,12 +1,12 @@
 import React, { useRef, useState, useEffect, FC } from 'react';
-import { StyleSheet, Text, View, Pressable } from 'react-native';
+import { StyleSheet, Text, View, Pressable, Image } from 'react-native';
 import {
   AudioContext,
   GainNode,
   OscillatorNode,
   StereoPannerNode,
 } from 'react-native-audio-api';
-import type { OscillatorType } from 'react-native-audio-api';
+import type { OscillatorType, AudioBuffer, ConvolverNode } from 'react-native-audio-api';
 
 import { Container, Slider, Spacer, Button } from '../../components';
 import { layout, colors } from '../../styles';
@@ -31,6 +31,35 @@ const Oscillator: FC = () => {
   const oscillatorRef = useRef<OscillatorNode | null>(null);
   const gainRef = useRef<GainNode | null>(null);
   const panRef = useRef<StereoPannerNode | null>(null);
+  const convolverRef = useRef<ConvolverNode | null>(null);
+
+  useEffect(() => {
+    const fetchImpulseResponse = async () => {
+      if (!audioContextRef.current) {
+        audioContextRef.current = new AudioContext();
+      }
+
+        const length = audioContextRef.current.sampleRate * 2; // 2 seconds
+        const impulse = audioContextRef.current.createBuffer(2, length, audioContextRef.current.sampleRate);
+        
+        for (let channel = 0; channel < impulse.numberOfChannels; channel++) {
+          const channelData = impulse.getChannelData(channel);
+          for (let i = 0; i < length; i++) {
+            // Exponentially decay the impulse
+            channelData[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / length, 2);
+          }
+        }
+
+        convolverRef.current = audioContextRef.current?.createConvolver();
+        convolverRef.current.buffer = impulse;
+      }
+
+    fetchImpulseResponse();
+
+    return () => {
+      audioContextRef.current?.close();
+    };
+  }, []);
 
   const setup = () => {
     if (!audioContextRef.current) {
@@ -50,7 +79,12 @@ const Oscillator: FC = () => {
 
     oscillatorRef.current.connect(gainRef.current);
     gainRef.current.connect(panRef.current);
-    panRef.current.connect(audioContextRef.current.destination);
+    if (convolverRef.current) {
+      panRef.current.connect(convolverRef.current);
+      convolverRef.current.connect(audioContextRef.current.destination);
+    } else {
+      panRef.current.connect(audioContextRef.current.destination);
+    }
   };
 
   const handleGainChange = (newValue: number) => {
@@ -91,6 +125,7 @@ const Oscillator: FC = () => {
     } else {
       setup();
       oscillatorRef.current?.start(0);
+      oscillatorRef.current?.stop(audioContextRef.current?.currentTime!! + 2);
     }
 
     setIsPlaying((prev) => !prev);
@@ -103,16 +138,6 @@ const Oscillator: FC = () => {
     }
   };
 
-  useEffect(() => {
-    if (!audioContextRef.current) {
-      audioContextRef.current = new AudioContext();
-    }
-
-    return () => {
-      audioContextRef.current?.close();
-    };
-  }, []);
-
   return (
     <Container centered>
       <Button onPress={handlePlayPause} title={isPlaying ? 'Pause' : 'Play'} />
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
index 6487fa17e..7e32b3c95 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
@@ -14,6 +14,7 @@
 #include <audioapi/HostObjects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/StereoPannerNodeHostObject.h>
 #include <audioapi/HostObjects/AnalyserNodeHostObject.h>
+#include <audioapi/HostObjects/ConvolverNodeHostObject.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -50,6 +51,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioData),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodePCMAudioDataInBase64));
@@ -167,6 +169,13 @@ JSI_HOST_FUNCTION(createBufferQueueSource) {
     return jsi::Object::createFromHostObject(runtime, analyserHostObject);
   }
 
+  JSI_HOST_FUNCTION(createConvolver) {
+    auto convolver = context_->createConvolver();
+    auto convolverHostObject =
+        std::make_shared<ConvolverNodeHostObject>(convolver);
+    return jsi::Object::createFromHostObject(runtime, convolverHostObject);
+  }
+
   JSI_HOST_FUNCTION(decodeAudioDataSource) {
     auto sourcePath = args[0].getString(runtime).utf8(runtime);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/ConvolverNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/ConvolverNodeHostObject.h
new file mode 100644
index 000000000..3162c553d
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/ConvolverNodeHostObject.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <iostream>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConvolverNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit 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),
+        JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, buffer));
+  }
+
+  JSI_PROPERTY_GETTER(normalize) {
+    auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+    return {convolverNode->getNormalize_()};
+  }
+
+  JSI_PROPERTY_GETTER(buffer) {
+    auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+    auto buffer = convolverNode->getBuffer();
+    auto bufferHostObject =
+        std::make_shared<AudioBufferHostObject>(buffer);
+    return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  }
+
+  JSI_PROPERTY_SETTER(normalize) {
+    auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+    convolverNode->setNormalize(value.getBool());
+  }
+
+  JSI_PROPERTY_SETTER(buffer) {
+    auto convolverNode =
+        std::static_pointer_cast<ConvolverNode>(node_);
+    if (value.isNull()) {
+      convolverNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+      return;
+    }
+
+    auto bufferHostObject =
+        value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    convolverNode->setBuffer(bufferHostObject->audioBuffer_);
+  }
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 2dd19d50d..2c9962daf 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -2,6 +2,7 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/CustomProcessorNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
@@ -15,6 +16,7 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <iostream>
 
 namespace audioapi {
 
@@ -117,6 +119,12 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver() {
+  auto convolver = std::make_shared<ConvolverNode>(this);
+  nodeManager_->addProcessingNode(convolver);
+  return convolver;
+}
+
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
     const std::string &path) {
   auto audioBus = audioDecoder_->decodeWithFilePath(path);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 9087b2dd5..986b278e1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -29,6 +29,7 @@ class AudioBufferQueueSourceNode;
 class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
+class ConvolverNode;
 
 class BaseAudioContext {
  public:
@@ -55,6 +56,7 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
+  std::shared_ptr<ConvolverNode> createConvolver();
 
   std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
   std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
new file mode 100644
index 000000000..c634fc626
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -0,0 +1,95 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/dsp/FFT.h>
+#include <audioapi/utils/AudioArray.h>
+#include <iostream>
+
+namespace audioapi {
+ConvolverNode::ConvolverNode(BaseAudioContext *context) : AudioNode(context) {
+  normalize_ = true;
+  buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+  convolver_ = std::shared_ptr<Convolver>(nullptr);
+  isInitialized_ = true;
+}
+
+bool ConvolverNode::getNormalize_() const {
+  return normalize_;
+}
+
+const std::shared_ptr<AudioBuffer> &ConvolverNode::getBuffer() const {
+  return buffer_;
+}
+
+void ConvolverNode::setNormalize(bool normalize) {
+  if (normalize_ != normalize) {
+    normalize_ = normalize;
+    if (normalize_ && buffer_)
+      calculateNormalizationScale();
+  }
+  if (!normalize_) {
+    scaleFactor_ = 1.0f;
+  }
+}
+
+void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
+  if (buffer_ != buffer) {
+    buffer_ = buffer;
+    if (normalize_)
+      calculateNormalizationScale();
+    convolver_ = std::make_shared<Convolver>();
+    auto audioArray = AudioArray(buffer->getLength());
+    memcpy(
+        audioArray.getData(), buffer->getChannelData(0), buffer->getLength());
+    convolver_->init(128, audioArray, audioArray.getSize());
+  }
+}
+
+void ConvolverNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  // printf("scale factor: %f\n", scaleFactor_);
+  convolver_->process(
+      *processingBus->getChannel(0),
+      *processingBus->getChannel(0),
+      framesToProcess);
+  for (int i = 0; i < framesToProcess; i++) {
+    processingBus->getChannel(0)->getData()[i] *= scaleFactor_;
+  }
+  if (processingBus->getNumberOfChannels() > 1) {
+    for (int channel = 1; channel < processingBus->getNumberOfChannels();
+         ++channel) {
+      processingBus->getChannel(channel)->copy(processingBus->getChannel(0));
+    }
+  }
+}
+
+void ConvolverNode::calculateNormalizationScale() {
+  int numberOfChannels = buffer_->getNumberOfChannels();
+  int length = buffer_->getLength();
+
+  float power = 0;
+
+  for (int channel = 0; channel < numberOfChannels; ++channel) {
+    float channelPower = 0;
+    auto channelData = buffer_->getChannelData(channel);
+    for (int i = 0; i < length; ++i) {
+      float sample = channelData[i];
+      channelPower += sample * sample;
+    }
+    power += channelPower;
+  }
+
+  power = std::sqrtf(power / (numberOfChannels * length));
+  if (power < MinPower) {
+    power = MinPower;
+  }
+  scaleFactor_ = 1 / power;
+  scaleFactor_ *= GainCalibration;
+  scaleFactor_ *= GainCalibrationSampleRate / buffer_->getSampleRate();
+
+  if (numberOfChannels == 4)
+    scaleFactor_ *= 0.5;
+}
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
new file mode 100644
index 000000000..2734c4c67
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/dsp/Convolver.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioBuffer;
+
+class ConvolverNode : public AudioNode {
+ public:
+    explicit ConvolverNode(BaseAudioContext *context);
+
+    [[nodiscard]] bool getNormalize_() const;
+    [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;
+    void setNormalize(bool normalize);
+    void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+
+ protected:
+    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+ private:
+  bool normalize_ = true;
+  std::shared_ptr<AudioBuffer> buffer_;
+  void calculateNormalizationScale();
+  float scaleFactor_ = 1.0f;
+  float GainCalibration = 0.00125;
+  float GainCalibrationSampleRate = 44100.0f;
+  float MinPower = 0.000125;
+  std::shared_ptr<Convolver> convolver_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/AudioUtils.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/AudioUtils.cpp
index cd66b9c4b..96a36bab9 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/dsp/AudioUtils.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/AudioUtils.cpp
@@ -30,4 +30,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return powf(10, value / 20);
 }
-} // namespace audioapi::dsp
+} // namespace audioapi::dsp
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
new file mode 100644
index 000000000..231ca4b59
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
@@ -0,0 +1,189 @@
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/dsp/Convolver.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <chrono>
+#include <iostream>
+
+namespace audioapi {
+
+Convolver::Convolver()
+    : _blockSize(0),
+      _segSize(0),
+      _segCount(0),
+      _fftComplexSize(0),
+      _segments(),
+      _segmentsIR(),
+      _fftBuffer(0),
+      _fft(nullptr),
+      _preMultiplied(),
+      _current(0),
+      _inputBuffer(0) {}
+
+void Convolver::reset() {
+  _blockSize = 0;
+  _segSize = 0;
+  _segCount = 0;
+  _fftComplexSize = 0;
+  _segments.clear();
+  _segmentsIR.clear();
+  _fftBuffer.zero();
+  _fft = nullptr;
+  _preMultiplied.clear();
+  _current = 0;
+  _inputBuffer.zero();
+}
+
+float calculateNyquistComponent(float *data, size_t size) {
+  float component = 0.0f;
+  for (size_t i = 0; i < size; ++i) {
+    if (i % 2 == 0) {
+      component += data[i];
+    } else {
+      component -= data[i];
+    }
+  }
+  return component;
+}
+
+bool Convolver::init(
+    size_t blockSize,
+    const audioapi::AudioArray &ir,
+    size_t irLen) {
+  reset();
+  // blockSize must be a power of two
+  if ((blockSize & (blockSize - 1))) {
+    return false;
+  }
+
+  // Ignore zeros at the end of the impulse response because they only waste
+  // computation time
+  while (irLen > 0 && ::fabs(ir[irLen - 1]) < 0.000001f) {
+    --irLen;
+  }
+
+  if (irLen == 0) {
+    return true;
+  }
+
+  _blockSize = blockSize;
+  // The length-N is split into P = N/B length-B sub filters
+  _segCount = (size_t)(std::ceil((float)irLen / (float)_blockSize));
+  _segSize = 2 * _blockSize;
+  // size of the FFT is 2B, so the complex size is B+1, due to the
+  // complex-conjugate symmetricity
+  _fftComplexSize = _segSize / 2 + 1;
+  _fft = std::make_shared<dsp::FFT>((int)_segSize);
+  _fftBuffer.resize(_segSize);
+
+  // segments preparation
+  for (int i = 0; i < _segCount; ++i) {
+    std::vector<std::complex<float>> vec(
+        _fftComplexSize, std::complex<float>(0.0f, 0.0f));
+    _segments.push_back(vec);
+  }
+
+  // ir preparation
+  for (int i = 0; i < _segCount; ++i) {
+    std::vector<std::complex<float>> segment(_fftComplexSize);
+    // Each sub filter is zero-padded to length 2B and transformed using a
+    // 2B-point real-to-complex FFT.
+    memcpy(
+        _fftBuffer.getData(),
+        ir.getData() + i * _blockSize,
+        _blockSize * sizeof(float));
+    memset(_fftBuffer.getData() + _blockSize, 0, _blockSize * sizeof(float));
+    _fft->doFFT(_fftBuffer.getData(), segment);
+    segment[0].imag(0.0f); // DC component should be real
+    // Nyquist component
+    segment[_fftComplexSize - 1].imag(0.0f);
+    segment[_fftComplexSize - 1].real(
+        calculateNyquistComponent(_fftBuffer.getData(), _blockSize));
+    _segmentsIR.push_back(segment);
+  }
+
+  _preMultiplied = std::vector<std::complex<float>>(_fftComplexSize);
+  _inputBuffer.resize(_segSize);
+  _current = 0;
+
+  return true;
+}
+
+void Convolver::process(
+    const audioapi::AudioArray &input,
+    audioapi::AudioArray &output,
+    size_t len) {
+  if (_segCount == 0) {
+    output.zero();
+    return;
+  }
+
+  // The input buffer acts as a 2B-point sliding window of the input signal.
+  // With each new input block, the right half of the input buffer is shifted
+  // to the left and the new block is stored in the right half.
+  memcpy(
+      _inputBuffer.getData(),
+      _inputBuffer.getData() + _blockSize,
+      _blockSize * sizeof(float));
+  memcpy(
+      _inputBuffer.getData() + _blockSize,
+      input.getData(),
+      std::min(len, _blockSize) * sizeof(float));
+
+  bool verbose = false;
+  if (verbose) {
+    for (int i = 0; i < _segSize; i++) {
+      printf("inputBuffer[%d]: %f\n", i, _inputBuffer.getData()[i]);
+    }
+  }
+
+  // All contents (DFT spectra) in the FDL are shifted up by one slot.
+  // A 2B-point real-to-complex FFT is computed from the input buffer,
+  // resulting in B+1 complex-conjugate symmetric DFT coefficients. The
+  // result is stored in the first FDL slot.
+  // _current marks first FDL slot, which is the current input block.
+  _fft->doFFT(_inputBuffer.getData(), _segments[_current]);
+  _segments[_current][0].imag(0.0f); // DC component should be real
+  // Nyquist component
+  _segments[_current][_fftComplexSize - 1].imag(0.0f);
+  _segments[_current][_fftComplexSize - 1].real(
+      calculateNyquistComponent(_inputBuffer.getData(), _blockSize));
+
+  // The P sub filter spectra are pairwisely multiplied with the input spectra
+  // in the FDL. The results are accumulated in the frequency-domain.
+  std::fill(
+      _preMultiplied.begin(),
+      _preMultiplied.end(),
+      std::complex<float>(0.0f, 0.0f));
+  for (int i = 0; i < _segCount; ++i) {
+    const int indexIr = i;
+    const int indexAudio = (_current + i) % _segCount;
+    for (int j = 0; j < _fftComplexSize; ++j) {
+      _preMultiplied[j] += _segmentsIR[indexIr][j] * _segments[indexAudio][j];
+    }
+  }
+  // move pointer to the next FDL slot
+  _current = _current > 0 ? _current - 1 : _segCount - 1;
+
+  // Of the accumulated spectral convolutions, an 2B-point complex-to-real
+  // IFFT is computed. From the resulting 2B samples, the left half is
+  // discarded and the right half is returned as the next output block.
+  _fft->doInverseFFT(_preMultiplied, _fftBuffer.getData());
+  if (verbose) {
+    for (int i = 0; i < _fftComplexSize; i++) {
+      printf(
+          "premultiplied[%d]: %f + %fi\n",
+          i,
+          _preMultiplied[i].real(),
+          _preMultiplied[i].imag());
+    }
+    for (int i = 0; i < _segSize; i++) {
+      printf("fftBuffer[%d]: %f\n", i, _fftBuffer.getData()[i]);
+    }
+  }
+  memcpy(
+      output.getData(),
+      _fftBuffer.getData() + _blockSize,
+      std::min(len, _blockSize) * sizeof(float));
+}
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.h b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.h
new file mode 100644
index 000000000..5cd72295e
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/dsp/FFT.h>
+#include <vector>
+#include <cstring>
+#include <complex>
+#include <memory>
+
+namespace audioapi {
+
+class AudioBuffer;
+
+class Convolver {
+ public:
+    Convolver();
+    bool init(size_t blockSize, const audioapi::AudioArray &ir, size_t irLen);
+    void process(const AudioArray &input, AudioArray &output, size_t len);
+    void reset();
+ private:
+    size_t _blockSize;
+    size_t _segSize;
+    size_t _segCount;
+    size_t _fftComplexSize;
+    std::vector<std::vector<std::complex<float>>> _segments;
+    std::vector<std::vector<std::complex<float>>> _segmentsIR;
+    AudioArray _fftBuffer;
+    std::shared_ptr<audioapi::dsp::FFT> _fft;
+    std::vector<std::complex<float>> _preMultiplied;
+    size_t _current;
+    AudioArray _inputBuffer;
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/FFT.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/FFT.cpp
index 787f492fe..899da7ac7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/dsp/FFT.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/FFT.cpp
@@ -20,11 +20,11 @@ void FFT::doFFT(float *in, std::vector<std::complex<float>> &out) {
       work_,
       PFFFT_FORWARD);
 
-  dsp::multiplyByScalar(
-      reinterpret_cast<float *>(&out[0]),
-      0.5f,
-      reinterpret_cast<float *>(&out[0]),
-      size_ * 2);
+  // dsp::multiplyByScalar(
+  //     reinterpret_cast<float *>(&out[0]),
+  //     0.5f,
+  //     reinterpret_cast<float *>(&out[0]),
+  //     size_ * 2);
 }
 
 void FFT::doInverseFFT(std::vector<std::complex<float>> &in, float *out) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/.gitignore b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/.gitignore
new file mode 100644
index 000000000..b681f4a33
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/.gitignore
@@ -0,0 +1,2 @@
+*.exe
+*.xcodeproj
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.cpp
new file mode 100755
index 000000000..029d09f01
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.cpp
@@ -0,0 +1,1120 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#include "AudioFFT.h"
+
+#include <cassert>
+#include <cmath>
+#include <cstring>
+
+#define AUDIOFFT_PFFFT
+
+
+#if defined(AUDIOFFT_APPLE_ACCELERATE)
+  #define AUDIOFFT_APPLE_ACCELERATE_USED
+  #include <Accelerate/Accelerate.h>
+  #include <vector>
+#elif defined (AUDIOFFT_FFTW3)
+  #define AUDIOFFT_FFTW3_USED
+  #include <fftw3.h>
+#elif defined (AUDIOFFT_PFFFT)
+  #define AUDIOFFT_PFFFT_USED
+  #include <audioapi/libs/pffft/pffft.h>
+#else
+  #if !defined(AUDIOFFT_OOURA)
+    #define AUDIOFFT_OOURA
+  #endif
+  #define AUDIOFFT_OOURA_USED
+  #include <vector>
+#endif
+
+
+namespace audiofft
+{
+
+  namespace detail
+  {
+
+    class AudioFFTImpl
+    {
+    public:
+      AudioFFTImpl() = default;
+      AudioFFTImpl(const AudioFFTImpl&) = delete;
+      AudioFFTImpl& operator=(const AudioFFTImpl&) = delete;
+      virtual ~AudioFFTImpl() = default;
+      virtual void init(size_t size) = 0;
+      virtual void fft(const float* data, float* re, float* im) = 0;
+      virtual void ifft(float* data, const float* re, const float* im) = 0;
+    };
+
+
+    constexpr bool IsPowerOf2(size_t val)
+    {
+      return (val == 1 || (val & (val-1)) == 0);
+    }
+
+
+    template<typename TypeDest, typename TypeSrc>
+    void ConvertBuffer(TypeDest* dest, const TypeSrc* src, size_t len)
+    {
+      for (size_t i=0; i<len; ++i)
+      {
+        dest[i] = static_cast<TypeDest>(src[i]);
+      }
+    }
+
+
+    template<typename TypeDest, typename TypeSrc, typename TypeFactor>
+    void ScaleBuffer(TypeDest* dest, const TypeSrc* src, const TypeFactor factor, size_t len)
+    {
+      for (size_t i=0; i<len; ++i)
+      {
+        dest[i] = static_cast<TypeDest>(static_cast<TypeFactor>(src[i]) * factor);
+      }
+    }
+
+  } // End of namespace detail
+
+
+  // ================================================================
+
+
+#ifdef AUDIOFFT_OOURA_USED
+
+  /**
+   * @internal
+   * @class OouraFFT
+   * @brief FFT implementation based on the great radix-4 routines by Takuya Ooura
+   */
+  class OouraFFT : public detail::AudioFFTImpl
+  {
+  public:
+    OouraFFT() :
+      detail::AudioFFTImpl(),
+      _size(0),
+      _ip(),
+      _w(),
+      _buffer()
+    {
+    }
+
+    OouraFFT(const OouraFFT&) = delete;
+    OouraFFT& operator=(const OouraFFT&) = delete;
+
+    virtual void init(size_t size) override
+    {
+      if (_size != size)
+      {
+        _ip.resize(2 + static_cast<int>(std::sqrt(static_cast<double>(size))));
+        _w.resize(size / 2);
+        _buffer.resize(size);
+        _size = size;
+
+        const int size4 = static_cast<int>(_size) / 4;
+        makewt(size4, _ip.data(), _w.data());
+        makect(size4, _ip.data(), _w.data() + size4);
+      }
+    }
+
+    virtual void fft(const float* data, float* re, float* im) override
+    {
+      // Convert into the format as required by the Ooura FFT
+      detail::ConvertBuffer(_buffer.data(), data, _size);
+
+      rdft(static_cast<int>(_size), +1, _buffer.data(), _ip.data(), _w.data());
+
+      // Convert back to split-complex
+      {
+        double* b = _buffer.data();
+        double* bEnd = b + _size;
+        float *r = re;
+        float *i = im;
+        while (b != bEnd)
+        {
+          *(r++) = static_cast<float>(*(b++));
+          *(i++) = static_cast<float>(-(*(b++)));
+        }
+      }
+      const size_t size2 = _size / 2;
+      re[size2] = -im[0];
+      im[0] = 0.0;
+      im[size2] = 0.0;
+    }
+
+    virtual void ifft(float* data, const float* re, const float* im) override
+    {
+      // Convert into the format as required by the Ooura FFT
+      {
+        double* b = _buffer.data();
+        double* bEnd = b + _size;
+        const float *r = re;
+        const float *i = im;
+        while (b != bEnd)
+        {
+          *(b++) = static_cast<double>(*(r++));
+          *(b++) = -static_cast<double>(*(i++));
+        }
+        _buffer[1] = re[_size / 2];
+      }
+
+      rdft(static_cast<int>(_size), -1, _buffer.data(), _ip.data(), _w.data());
+
+      // Convert back to split-complex
+      detail::ScaleBuffer(data, _buffer.data(), 2.0 / static_cast<double>(_size), _size);
+    }
+
+  private:
+    size_t _size;
+    std::vector<int> _ip;
+    std::vector<double> _w;
+    std::vector<double> _buffer;
+
+    void rdft(int n, int isgn, double *a, int *ip, double *w)
+    {
+      int nw = ip[0];
+      int nc = ip[1];
+
+      if (isgn >= 0)
+      {
+        if (n > 4)
+        {
+          bitrv2(n, ip + 2, a);
+          cftfsub(n, a, w);
+          rftfsub(n, a, nc, w + nw);
+        }
+        else if (n == 4)
+        {
+          cftfsub(n, a, w);
+        }
+        double xi = a[0] - a[1];
+        a[0] += a[1];
+        a[1] = xi;
+      }
+      else
+      {
+        a[1] = 0.5 * (a[0] - a[1]);
+        a[0] -= a[1];
+        if (n > 4)
+        {
+          rftbsub(n, a, nc, w + nw);
+          bitrv2(n, ip + 2, a);
+          cftbsub(n, a, w);
+        }
+        else if (n == 4)
+        {
+          cftfsub(n, a, w);
+        }
+      }
+    }
+
+
+    /* -------- initializing routines -------- */
+
+    void makewt(int nw, int *ip, double *w)
+    {
+      int j, nwh;
+      double delta, x, y;
+
+      ip[0] = nw;
+      ip[1] = 1;
+      if (nw > 2) {
+        nwh = nw >> 1;
+        delta = atan(1.0) / nwh;
+        w[0] = 1;
+        w[1] = 0;
+        w[nwh] = cos(delta * nwh);
+        w[nwh + 1] = w[nwh];
+        if (nwh > 2) {
+          for (j = 2; j < nwh; j += 2) {
+            x = cos(delta * j);
+            y = sin(delta * j);
+            w[j] = x;
+            w[j + 1] = y;
+            w[nw - j] = y;
+            w[nw - j + 1] = x;
+          }
+          bitrv2(nw, ip + 2, w);
+        }
+      }
+    }
+
+
+    void makect(int nc, int *ip, double *c)
+    {
+      int j, nch;
+      double delta;
+
+      ip[1] = nc;
+      if (nc > 1) {
+        nch = nc >> 1;
+        delta = atan(1.0) / nch;
+        c[0] = cos(delta * nch);
+        c[nch] = 0.5 * c[0];
+        for (j = 1; j < nch; j++) {
+          c[j] = 0.5 * cos(delta * j);
+          c[nc - j] = 0.5 * sin(delta * j);
+        }
+      }
+    }
+
+
+    /* -------- child routines -------- */
+
+
+    void bitrv2(int n, int *ip, double *a)
+    {
+      int j, j1, k, k1, l, m, m2;
+      double xr, xi, yr, yi;
+
+      ip[0] = 0;
+      l = n;
+      m = 1;
+      while ((m << 3) < l) {
+        l >>= 1;
+        for (j = 0; j < m; j++) {
+          ip[m + j] = ip[j] + l;
+        }
+        m <<= 1;
+      }
+      m2 = 2 * m;
+      if ((m << 3) == l) {
+        for (k = 0; k < m; k++) {
+          for (j = 0; j < k; j++) {
+            j1 = 2 * j + ip[k];
+            k1 = 2 * k + ip[j];
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += m2;
+            k1 += 2 * m2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += m2;
+            k1 -= m2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += m2;
+            k1 += 2 * m2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+          }
+          j1 = 2 * k + m2 + ip[k];
+          k1 = j1 + m2;
+          xr = a[j1];
+          xi = a[j1 + 1];
+          yr = a[k1];
+          yi = a[k1 + 1];
+          a[j1] = yr;
+          a[j1 + 1] = yi;
+          a[k1] = xr;
+          a[k1 + 1] = xi;
+        }
+      } else {
+        for (k = 1; k < m; k++) {
+          for (j = 0; j < k; j++) {
+            j1 = 2 * j + ip[k];
+            k1 = 2 * k + ip[j];
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += m2;
+            k1 += m2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+          }
+        }
+      }
+    }
+
+
+    void cftfsub(int n, double *a, double *w)
+    {
+      int j, j1, j2, j3, l;
+      double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+      l = 2;
+      if (n > 8) {
+        cft1st(n, a, w);
+        l = 8;
+        while ((l << 2) < n) {
+          cftmdl(n, l, a, w);
+          l <<= 2;
+        }
+      }
+      if ((l << 2) == n) {
+        for (j = 0; j < l; j += 2) {
+          j1 = j + l;
+          j2 = j1 + l;
+          j3 = j2 + l;
+          x0r = a[j] + a[j1];
+          x0i = a[j + 1] + a[j1 + 1];
+          x1r = a[j] - a[j1];
+          x1i = a[j + 1] - a[j1 + 1];
+          x2r = a[j2] + a[j3];
+          x2i = a[j2 + 1] + a[j3 + 1];
+          x3r = a[j2] - a[j3];
+          x3i = a[j2 + 1] - a[j3 + 1];
+          a[j] = x0r + x2r;
+          a[j + 1] = x0i + x2i;
+          a[j2] = x0r - x2r;
+          a[j2 + 1] = x0i - x2i;
+          a[j1] = x1r - x3i;
+          a[j1 + 1] = x1i + x3r;
+          a[j3] = x1r + x3i;
+          a[j3 + 1] = x1i - x3r;
+        }
+      } else {
+        for (j = 0; j < l; j += 2) {
+          j1 = j + l;
+          x0r = a[j] - a[j1];
+          x0i = a[j + 1] - a[j1 + 1];
+          a[j] += a[j1];
+          a[j + 1] += a[j1 + 1];
+          a[j1] = x0r;
+          a[j1 + 1] = x0i;
+        }
+      }
+    }
+
+
+    void cftbsub(int n, double *a, double *w)
+    {
+      int j, j1, j2, j3, l;
+      double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+      l = 2;
+      if (n > 8) {
+        cft1st(n, a, w);
+        l = 8;
+        while ((l << 2) < n) {
+          cftmdl(n, l, a, w);
+          l <<= 2;
+        }
+      }
+      if ((l << 2) == n) {
+        for (j = 0; j < l; j += 2) {
+          j1 = j + l;
+          j2 = j1 + l;
+          j3 = j2 + l;
+          x0r = a[j] + a[j1];
+          x0i = -a[j + 1] - a[j1 + 1];
+          x1r = a[j] - a[j1];
+          x1i = -a[j + 1] + a[j1 + 1];
+          x2r = a[j2] + a[j3];
+          x2i = a[j2 + 1] + a[j3 + 1];
+          x3r = a[j2] - a[j3];
+          x3i = a[j2 + 1] - a[j3 + 1];
+          a[j] = x0r + x2r;
+          a[j + 1] = x0i - x2i;
+          a[j2] = x0r - x2r;
+          a[j2 + 1] = x0i + x2i;
+          a[j1] = x1r - x3i;
+          a[j1 + 1] = x1i - x3r;
+          a[j3] = x1r + x3i;
+          a[j3 + 1] = x1i + x3r;
+        }
+      } else {
+        for (j = 0; j < l; j += 2) {
+          j1 = j + l;
+          x0r = a[j] - a[j1];
+          x0i = -a[j + 1] + a[j1 + 1];
+          a[j] += a[j1];
+          a[j + 1] = -a[j + 1] - a[j1 + 1];
+          a[j1] = x0r;
+          a[j1 + 1] = x0i;
+        }
+      }
+    }
+
+
+    void cft1st(int n, double *a, double *w)
+    {
+      int j, k1, k2;
+      double wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+      double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+      x0r = a[0] + a[2];
+      x0i = a[1] + a[3];
+      x1r = a[0] - a[2];
+      x1i = a[1] - a[3];
+      x2r = a[4] + a[6];
+      x2i = a[5] + a[7];
+      x3r = a[4] - a[6];
+      x3i = a[5] - a[7];
+      a[0] = x0r + x2r;
+      a[1] = x0i + x2i;
+      a[4] = x0r - x2r;
+      a[5] = x0i - x2i;
+      a[2] = x1r - x3i;
+      a[3] = x1i + x3r;
+      a[6] = x1r + x3i;
+      a[7] = x1i - x3r;
+      wk1r = w[2];
+      x0r = a[8] + a[10];
+      x0i = a[9] + a[11];
+      x1r = a[8] - a[10];
+      x1i = a[9] - a[11];
+      x2r = a[12] + a[14];
+      x2i = a[13] + a[15];
+      x3r = a[12] - a[14];
+      x3i = a[13] - a[15];
+      a[8] = x0r + x2r;
+      a[9] = x0i + x2i;
+      a[12] = x2i - x0i;
+      a[13] = x0r - x2r;
+      x0r = x1r - x3i;
+      x0i = x1i + x3r;
+      a[10] = wk1r * (x0r - x0i);
+      a[11] = wk1r * (x0r + x0i);
+      x0r = x3i + x1r;
+      x0i = x3r - x1i;
+      a[14] = wk1r * (x0i - x0r);
+      a[15] = wk1r * (x0i + x0r);
+      k1 = 0;
+      for (j = 16; j < n; j += 16) {
+        k1 += 2;
+        k2 = 2 * k1;
+        wk2r = w[k1];
+        wk2i = w[k1 + 1];
+        wk1r = w[k2];
+        wk1i = w[k2 + 1];
+        wk3r = wk1r - 2 * wk2i * wk1i;
+        wk3i = 2 * wk2i * wk1r - wk1i;
+        x0r = a[j] + a[j + 2];
+        x0i = a[j + 1] + a[j + 3];
+        x1r = a[j] - a[j + 2];
+        x1i = a[j + 1] - a[j + 3];
+        x2r = a[j + 4] + a[j + 6];
+        x2i = a[j + 5] + a[j + 7];
+        x3r = a[j + 4] - a[j + 6];
+        x3i = a[j + 5] - a[j + 7];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        x0r -= x2r;
+        x0i -= x2i;
+        a[j + 4] = wk2r * x0r - wk2i * x0i;
+        a[j + 5] = wk2r * x0i + wk2i * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j + 2] = wk1r * x0r - wk1i * x0i;
+        a[j + 3] = wk1r * x0i + wk1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j + 6] = wk3r * x0r - wk3i * x0i;
+        a[j + 7] = wk3r * x0i + wk3i * x0r;
+        wk1r = w[k2 + 2];
+        wk1i = w[k2 + 3];
+        wk3r = wk1r - 2 * wk2r * wk1i;
+        wk3i = 2 * wk2r * wk1r - wk1i;
+        x0r = a[j + 8] + a[j + 10];
+        x0i = a[j + 9] + a[j + 11];
+        x1r = a[j + 8] - a[j + 10];
+        x1i = a[j + 9] - a[j + 11];
+        x2r = a[j + 12] + a[j + 14];
+        x2i = a[j + 13] + a[j + 15];
+        x3r = a[j + 12] - a[j + 14];
+        x3i = a[j + 13] - a[j + 15];
+        a[j + 8] = x0r + x2r;
+        a[j + 9] = x0i + x2i;
+        x0r -= x2r;
+        x0i -= x2i;
+        a[j + 12] = -wk2i * x0r - wk2r * x0i;
+        a[j + 13] = -wk2i * x0i + wk2r * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j + 10] = wk1r * x0r - wk1i * x0i;
+        a[j + 11] = wk1r * x0i + wk1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j + 14] = wk3r * x0r - wk3i * x0i;
+        a[j + 15] = wk3r * x0i + wk3i * x0r;
+      }
+    }
+
+
+    void cftmdl(int n, int l, double *a, double *w)
+    {
+      int j, j1, j2, j3, k, k1, k2, m, m2;
+      double wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+      double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+      m = l << 2;
+      for (j = 0; j < l; j += 2) {
+        j1 = j + l;
+        j2 = j1 + l;
+        j3 = j2 + l;
+        x0r = a[j] + a[j1];
+        x0i = a[j + 1] + a[j1 + 1];
+        x1r = a[j] - a[j1];
+        x1i = a[j + 1] - a[j1 + 1];
+        x2r = a[j2] + a[j3];
+        x2i = a[j2 + 1] + a[j3 + 1];
+        x3r = a[j2] - a[j3];
+        x3i = a[j2 + 1] - a[j3 + 1];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j2] = x0r - x2r;
+        a[j2 + 1] = x0i - x2i;
+        a[j1] = x1r - x3i;
+        a[j1 + 1] = x1i + x3r;
+        a[j3] = x1r + x3i;
+        a[j3 + 1] = x1i - x3r;
+      }
+      wk1r = w[2];
+      for (j = m; j < l + m; j += 2) {
+        j1 = j + l;
+        j2 = j1 + l;
+        j3 = j2 + l;
+        x0r = a[j] + a[j1];
+        x0i = a[j + 1] + a[j1 + 1];
+        x1r = a[j] - a[j1];
+        x1i = a[j + 1] - a[j1 + 1];
+        x2r = a[j2] + a[j3];
+        x2i = a[j2 + 1] + a[j3 + 1];
+        x3r = a[j2] - a[j3];
+        x3i = a[j2 + 1] - a[j3 + 1];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j2] = x2i - x0i;
+        a[j2 + 1] = x0r - x2r;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j1] = wk1r * (x0r - x0i);
+        a[j1 + 1] = wk1r * (x0r + x0i);
+        x0r = x3i + x1r;
+        x0i = x3r - x1i;
+        a[j3] = wk1r * (x0i - x0r);
+        a[j3 + 1] = wk1r * (x0i + x0r);
+      }
+      k1 = 0;
+      m2 = 2 * m;
+      for (k = m2; k < n; k += m2) {
+        k1 += 2;
+        k2 = 2 * k1;
+        wk2r = w[k1];
+        wk2i = w[k1 + 1];
+        wk1r = w[k2];
+        wk1i = w[k2 + 1];
+        wk3r = wk1r - 2 * wk2i * wk1i;
+        wk3i = 2 * wk2i * wk1r - wk1i;
+        for (j = k; j < l + k; j += 2) {
+          j1 = j + l;
+          j2 = j1 + l;
+          j3 = j2 + l;
+          x0r = a[j] + a[j1];
+          x0i = a[j + 1] + a[j1 + 1];
+          x1r = a[j] - a[j1];
+          x1i = a[j + 1] - a[j1 + 1];
+          x2r = a[j2] + a[j3];
+          x2i = a[j2 + 1] + a[j3 + 1];
+          x3r = a[j2] - a[j3];
+          x3i = a[j2 + 1] - a[j3 + 1];
+          a[j] = x0r + x2r;
+          a[j + 1] = x0i + x2i;
+          x0r -= x2r;
+          x0i -= x2i;
+          a[j2] = wk2r * x0r - wk2i * x0i;
+          a[j2 + 1] = wk2r * x0i + wk2i * x0r;
+          x0r = x1r - x3i;
+          x0i = x1i + x3r;
+          a[j1] = wk1r * x0r - wk1i * x0i;
+          a[j1 + 1] = wk1r * x0i + wk1i * x0r;
+          x0r = x1r + x3i;
+          x0i = x1i - x3r;
+          a[j3] = wk3r * x0r - wk3i * x0i;
+          a[j3 + 1] = wk3r * x0i + wk3i * x0r;
+        }
+        wk1r = w[k2 + 2];
+        wk1i = w[k2 + 3];
+        wk3r = wk1r - 2 * wk2r * wk1i;
+        wk3i = 2 * wk2r * wk1r - wk1i;
+        for (j = k + m; j < l + (k + m); j += 2) {
+          j1 = j + l;
+          j2 = j1 + l;
+          j3 = j2 + l;
+          x0r = a[j] + a[j1];
+          x0i = a[j + 1] + a[j1 + 1];
+          x1r = a[j] - a[j1];
+          x1i = a[j + 1] - a[j1 + 1];
+          x2r = a[j2] + a[j3];
+          x2i = a[j2 + 1] + a[j3 + 1];
+          x3r = a[j2] - a[j3];
+          x3i = a[j2 + 1] - a[j3 + 1];
+          a[j] = x0r + x2r;
+          a[j + 1] = x0i + x2i;
+          x0r -= x2r;
+          x0i -= x2i;
+          a[j2] = -wk2i * x0r - wk2r * x0i;
+          a[j2 + 1] = -wk2i * x0i + wk2r * x0r;
+          x0r = x1r - x3i;
+          x0i = x1i + x3r;
+          a[j1] = wk1r * x0r - wk1i * x0i;
+          a[j1 + 1] = wk1r * x0i + wk1i * x0r;
+          x0r = x1r + x3i;
+          x0i = x1i - x3r;
+          a[j3] = wk3r * x0r - wk3i * x0i;
+          a[j3 + 1] = wk3r * x0i + wk3i * x0r;
+        }
+      }
+    }
+
+
+    void rftfsub(int n, double *a, int nc, double *c)
+    {
+      int j, k, kk, ks, m;
+      double wkr, wki, xr, xi, yr, yi;
+
+      m = n >> 1;
+      ks = 2 * nc / m;
+      kk = 0;
+      for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr - wki * xi;
+        yi = wkr * xi + wki * xr;
+        a[j] -= yr;
+        a[j + 1] -= yi;
+        a[k] += yr;
+        a[k + 1] -= yi;
+      }
+    }
+
+
+    void rftbsub(int n, double *a, int nc, double *c)
+    {
+      int j, k, kk, ks, m;
+      double wkr, wki, xr, xi, yr, yi;
+
+      a[1] = -a[1];
+      m = n >> 1;
+      ks = 2 * nc / m;
+      kk = 0;
+      for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr + wki * xi;
+        yi = wkr * xi - wki * xr;
+        a[j] -= yr;
+        a[j + 1] = yi - a[j + 1];
+        a[k] += yr;
+        a[k + 1] = yi - a[k + 1];
+      }
+      a[m + 1] = -a[m + 1];
+    }
+  };
+
+
+  /**
+   * @internal
+   * @brief Concrete FFT implementation
+   */
+  typedef OouraFFT AudioFFTImplementation;
+
+
+#endif // AUDIOFFT_OOURA_USED
+
+
+  // ================================================================
+
+
+#ifdef AUDIOFFT_APPLE_ACCELERATE_USED
+
+
+  /**
+   * @internal
+   * @class AppleAccelerateFFT
+   * @brief FFT implementation using the Apple Accelerate framework internally
+   */
+  class AppleAccelerateFFT : public detail::AudioFFTImpl
+  {
+  public:
+    AppleAccelerateFFT() :
+      detail::AudioFFTImpl(),
+      _size(0),
+      _powerOf2(0),
+      _fftSetup(0),
+      _re(),
+      _im()
+    {
+    }
+
+    AppleAccelerateFFT(const AppleAccelerateFFT&) = delete;
+    AppleAccelerateFFT& operator=(const AppleAccelerateFFT&) = delete;
+
+    virtual ~AppleAccelerateFFT()
+    {
+      init(0);
+    }
+
+    virtual void init(size_t size) override
+    {
+      if (_fftSetup)
+      {
+        vDSP_destroy_fftsetup(_fftSetup);
+        _size = 0;
+        _powerOf2 = 0;
+        _fftSetup = 0;
+        _re.clear();
+        _im.clear();
+      }
+
+      if (size > 0)
+      {
+        _size = size;
+        _powerOf2 = 0;
+        while ((1 << _powerOf2) < _size)
+        {
+          ++_powerOf2;
+        }
+        _fftSetup = vDSP_create_fftsetup(_powerOf2, FFT_RADIX2);
+        _re.resize(_size / 2);
+        _im.resize(_size / 2);
+      }
+    }
+
+    virtual void fft(const float* data, float* re, float* im) override
+    {
+      const size_t size2 = _size / 2;
+      DSPSplitComplex splitComplex;
+      splitComplex.realp = re;
+      splitComplex.imagp = im;
+      vDSP_ctoz(reinterpret_cast<const COMPLEX*>(data), 2, &splitComplex, 1, size2);
+      vDSP_fft_zrip(_fftSetup, &splitComplex, 1, _powerOf2, FFT_FORWARD);
+      const float factor = 0.5f;
+      vDSP_vsmul(re, 1, &factor, re, 1, size2);
+      vDSP_vsmul(im, 1, &factor, im, 1, size2);
+      re[size2] = im[0];
+      im[0] = 0.0f;
+      im[size2] = 0.0f;
+    }
+
+    virtual void ifft(float* data, const float* re, const float* im) override
+    {
+      const size_t size2 = _size / 2;
+      ::memcpy(_re.data(), re, size2 * sizeof(float));
+      ::memcpy(_im.data(), im, size2 * sizeof(float));
+      _im[0] = re[size2];
+      DSPSplitComplex splitComplex;
+      splitComplex.realp = _re.data();
+      splitComplex.imagp = _im.data();
+      vDSP_fft_zrip(_fftSetup, &splitComplex, 1, _powerOf2, FFT_INVERSE);
+      vDSP_ztoc(&splitComplex, 1, reinterpret_cast<COMPLEX*>(data), 2, size2);
+      const float factor = 1.0f / static_cast<float>(_size);
+      vDSP_vsmul(data, 1, &factor, data, 1, _size);
+    }
+
+  private:
+    size_t _size;
+    size_t _powerOf2;
+    FFTSetup _fftSetup;
+    std::vector<float> _re;
+    std::vector<float> _im;
+  };
+
+
+  /**
+   * @internal
+   * @brief Concrete FFT implementation
+   */
+  typedef AppleAccelerateFFT AudioFFTImplementation;
+
+
+#endif // AUDIOFFT_APPLE_ACCELERATE_USED
+
+    // ================================================================
+    
+    
+#ifdef AUDIOFFT_PFFFT_USED
+    
+class PFFFTFFT : public detail::AudioFFTImpl
+{
+public:
+    PFFFTFFT() : detail::AudioFFTImpl() {}
+    
+    PFFFTFFT(const PFFFTFFT&) = delete;
+    PFFFTFFT& operator=(const PFFFTFFT&) = delete;
+    
+    virtual ~PFFFTFFT() {
+        if (setup) pffft_destroy_setup(setup);
+        if (cmplx) pffft_aligned_free(cmplx);
+    }
+    
+    void init(size_t size) override {
+        assert((size & (size - 1)) == 0); // power of two check
+        if (setup) {
+            pffft_destroy_setup(setup);
+            setup = nullptr;
+        }
+        if (cmplx) {
+            pffft_aligned_free(cmplx);
+            cmplx = nullptr;
+        }
+        if (n != size) {
+            n = (int)size;
+            if (n > 0) {
+                setup = pffft_new_setup((int)n, PFFFT_REAL);
+                cmplx = (float*)pffft_aligned_malloc(n*sizeof(float));
+            }
+        }
+    }
+    
+    void fft(const float* data, float* re, float* im) override {
+        pffft_transform_ordered(setup, data, cmplx, nullptr, PFFFT_FORWARD);
+        int n2 = n>>1;
+        int j = 1;
+        for (int i = 2; i < n; i += 2) {
+            re[j] = cmplx[i];
+            im[j] = cmplx[i + 1];
+            j++;
+        }
+        re[0] = cmplx[0]; im[0] = 0.f;
+        re[n2] = cmplx[1]; im[n2] = 0.f;
+   }
+    
+    void ifft(float* data, const float* re, const float* im) override {
+        int n2 = n>>1;
+        int j = 1;
+        for (int i = 2; i < n; i += 2) {
+            cmplx[i] = re[j];
+            cmplx[i + 1] = im[j];
+            j++;
+        }
+        cmplx[0] = re[0]; // dc magnitude
+        cmplx[1] = re[n2]; // nyquist magnitude
+        
+        pffft_transform_ordered(setup, cmplx, data, nullptr, PFFFT_BACKWARD);
+        detail::ScaleBuffer(data, data, 1.0f/float(n), (size_t)n);
+    }
+    
+private:
+    PFFFT_Setup* setup = nullptr;
+    float* cmplx = nullptr; // interleaved complex buffer
+    int n = 0;
+};
+
+typedef PFFFTFFT AudioFFTImplementation;
+
+#endif // AUDIOFFT_PFFFT_USED
+
+
+  // ================================================================
+
+
+#ifdef AUDIOFFT_FFTW3_USED
+
+
+  /**
+   * @internal
+   * @class FFTW3FFT
+   * @brief FFT implementation using FFTW3 internally (see fftw.org)
+   */
+  class FFTW3FFT : public detail::AudioFFTImpl
+  {
+  public:
+    FFTW3FFT() :
+      detail::AudioFFTImpl(),
+      _size(0),
+      _complexSize(0),
+      _planForward(0),
+      _planBackward(0),
+      _data(0),
+      _re(0),
+      _im(0)
+    {
+    }
+
+    FFTW3FFT(const FFTW3FFT&) = delete;
+    FFTW3FFT& operator=(const FFTW3FFT&) = delete;
+
+    virtual ~FFTW3FFT()
+    {
+      init(0);
+    }
+
+    virtual void init(size_t size) override
+    {
+      if (_size != size)
+      {
+        if (_size > 0)
+        {
+          fftwf_destroy_plan(_planForward);
+          fftwf_destroy_plan(_planBackward);
+          _planForward = 0;
+          _planBackward = 0;
+          _size = 0;
+          _complexSize = 0;
+
+          if (_data)
+          {
+            fftwf_free(_data);
+            _data = 0;
+          }
+
+          if (_re)
+          {
+            fftwf_free(_re);
+            _re = 0;
+          }
+
+          if (_im)
+          {
+            fftwf_free(_im);
+            _im = 0;
+          }
+        }
+
+        if (size > 0)
+        {
+          _size = size;
+          _complexSize = AudioFFT::ComplexSize(_size);
+          const size_t complexSize = AudioFFT::ComplexSize(_size);
+          _data = reinterpret_cast<float*>(fftwf_malloc(_size * sizeof(float)));
+          _re = reinterpret_cast<float*>(fftwf_malloc(complexSize * sizeof(float)));
+          _im = reinterpret_cast<float*>(fftwf_malloc(complexSize * sizeof(float)));
+
+          fftw_iodim dim;
+          dim.n = static_cast<int>(size);
+          dim.is = 1;
+          dim.os = 1;
+          _planForward = fftwf_plan_guru_split_dft_r2c(1, &dim, 0, 0, _data, _re, _im, FFTW_MEASURE);
+          _planBackward = fftwf_plan_guru_split_dft_c2r(1, &dim, 0, 0, _re, _im, _data, FFTW_MEASURE);
+        }
+      }
+    }
+
+    virtual void fft(const float* data, float* re, float* im) override
+    {
+      ::memcpy(_data, data, _size * sizeof(float));
+      fftwf_execute_split_dft_r2c(_planForward, _data, _re, _im);
+      ::memcpy(re, _re, _complexSize * sizeof(float));
+      ::memcpy(im, _im, _complexSize * sizeof(float));
+    }
+
+    virtual void ifft(float* data, const float* re, const float* im) override
+    {
+      ::memcpy(_re, re, _complexSize * sizeof(float));
+      ::memcpy(_im, im, _complexSize * sizeof(float));
+      fftwf_execute_split_dft_c2r(_planBackward, _re, _im, _data);
+      detail::ScaleBuffer(data, _data, 1.0f / static_cast<float>(_size), _size);
+    }
+
+  private:
+    size_t _size;
+    size_t _complexSize;
+    fftwf_plan _planForward;
+    fftwf_plan _planBackward;
+    float* _data;
+    float* _re;
+    float* _im;
+  };
+
+
+  /**
+   * @internal
+   * @brief Concrete FFT implementation
+   */
+  typedef FFTW3FFT AudioFFTImplementation;
+
+
+#endif // AUDIOFFT_FFTW3_USED
+
+
+  // =============================================================
+
+
+  AudioFFT::AudioFFT() :
+    _impl(new AudioFFTImplementation())
+  {
+  }
+
+
+  AudioFFT::~AudioFFT()
+  {
+  }
+
+
+  void AudioFFT::init(size_t size)
+  {
+    assert(detail::IsPowerOf2(size));
+    _impl->init(size);
+  }
+
+
+  void AudioFFT::fft(const float* data, float* re, float* im)
+  {
+    _impl->fft(data, re, im);
+  }
+
+
+  void AudioFFT::ifft(float* data, const float* re, const float* im)
+  {
+    _impl->ifft(data, re, im);
+  }
+
+
+  size_t AudioFFT::ComplexSize(size_t size)
+  {
+    return (size / 2) + 1;
+  }
+
+} // End of namespace
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.h
new file mode 100755
index 000000000..dadf32e68
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/AudioFFT.h
@@ -0,0 +1,168 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#ifndef _AUDIOFFT_H
+#define _AUDIOFFT_H
+
+
+/**
+* AudioFFT provides real-to-complex/complex-to-real FFT routines.
+*
+* Features:
+*
+* - Real-complex FFT and complex-real inverse FFT for power-of-2-sized real data.
+*
+* - Uniform interface to different FFT implementations (currently Ooura, FFTW3 and Apple Accelerate).
+*
+* - Complex data is handled in "split-complex" format, i.e. there are separate
+*   arrays for the real and imaginary parts which can be useful for SIMD optimizations
+*   (split-complex arrays have to be of length (size/2+1) representing bins from DC
+*   to Nyquist frequency).
+*
+* - Output is "ready to use" (all scaling etc. is already handled internally).
+*
+* - No allocations/deallocations after the initialization which makes it usable
+*   for real-time audio applications (that's what I wrote it for and using it).
+*
+*
+* How to use it in your project:
+*
+* - Add the .h and .cpp file to your project - that's all.
+*
+* - To get extra speed, you can link FFTW3 to your project and define
+*   AUDIOFFT_FFTW3 (however, please check whether your project suits the
+*   according license).
+*
+* - To get the best speed on Apple platforms, you can link the Apple
+*   Accelerate framework to your project and define
+*   AUDIOFFT_APPLE_ACCELERATE  (however, please check whether your
+*   project suits the according license).
+*
+*
+* Remarks:
+*
+* - AudioFFT is not intended to be the fastest FFT, but to be a fast-enough
+*   FFT suitable for most audio applications.
+*
+* - AudioFFT uses the quite liberal MIT license.
+*
+*
+* Example usage:
+* @code
+* #include "AudioFFT.h"
+*
+* void Example()
+* {
+*   const size_t fftSize = 1024; // Needs to be power of 2!
+*
+*   std::vector<float> input(fftSize, 0.0f);
+*   std::vector<float> re(audiofft::AudioFFT::ComplexSize(fftSize));
+*   std::vector<float> im(audiofft::AudioFFT::ComplexSize(fftSize));
+*   std::vector<float> output(fftSize);
+*
+*   audiofft::AudioFFT fft;
+*   fft.init(1024);
+*   fft.fft(input.data(), re.data(), im.data());
+*   fft.ifft(output.data(), re.data(), im.data());
+* }
+* @endcode
+*/
+
+
+#include <cstddef>
+#include <memory>
+
+
+namespace audiofft
+{
+
+  namespace detail
+  {
+    class AudioFFTImpl;
+  }
+
+
+  // =============================================================
+
+
+  /**
+   * @class AudioFFT
+   * @brief Performs 1D FFTs
+   */
+  class AudioFFT
+  {
+  public:
+    /**
+     * @brief Constructor
+     */
+    AudioFFT();
+
+    AudioFFT(const AudioFFT&) = delete;
+    AudioFFT& operator=(const AudioFFT&) = delete;
+
+    /**
+     * @brief Destructor
+     */
+    ~AudioFFT();
+
+    /**
+     * @brief Initializes the FFT object
+     * @param size Size of the real input (must be power 2)
+     */
+    void init(size_t size);
+
+    /**
+     * @brief Performs the forward FFT
+     * @param data The real input data (has to be of the length as specified in init())
+     * @param re The real part of the complex output (has to be of length as returned by ComplexSize())
+     * @param im The imaginary part of the complex output (has to be of length as returned by ComplexSize())
+     */
+    void fft(const float* data, float* re, float* im);
+
+    /**
+     * @brief Performs the inverse FFT
+     * @param data The real output data (has to be of the length as specified in init())
+     * @param re The real part of the complex input (has to be of length as returned by ComplexSize())
+     * @param im The imaginary part of the complex input (has to be of length as returned by ComplexSize())
+     */
+    void ifft(float* data, const float* re, const float* im);
+
+    /**
+     * @brief Calculates the necessary size of the real/imaginary complex arrays
+     * @param size The size of the real data
+     * @return The size of the real/imaginary complex arrays
+     */
+    static size_t ComplexSize(size_t size);
+
+  private:
+    std::unique_ptr<detail::AudioFFTImpl> _impl;
+  };
+
+
+  /**
+   * @deprecated
+   * @brief Let's keep an AudioFFTBase type around for now because it has been here already in the 1st version in order to avoid breaking existing code.
+   */
+  typedef AudioFFT AudioFFTBase;
+
+} // End of namespace
+
+#endif // Header guard
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/COPYING.txt b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/COPYING.txt
new file mode 100644
index 000000000..808a5d497
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/COPYING.txt
@@ -0,0 +1,18 @@
+Copyright (c) 2017 HiFi-LoFi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.cpp
new file mode 100755
index 000000000..fd45c5c67
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.cpp
@@ -0,0 +1,206 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#include "FFTConvolver.h"
+
+#include <cassert>
+#include <cmath>
+
+#if defined (FFTCONVOLVER_USE_SSE)
+  #include <xmmintrin.h>
+#endif
+
+
+namespace fftconvolver
+{  
+
+FFTConvolver::FFTConvolver() :
+  _blockSize(0),
+  _segSize(0),
+  _segCount(0),
+  _fftComplexSize(0),
+  _segments(),
+  _segmentsIR(),
+  _fftBuffer(),
+  _fft(),
+  _preMultiplied(),
+  _conv(),
+  _overlap(),
+  _current(0),
+  _inputBuffer(),
+  _inputBufferFill(0)
+{
+}
+
+  
+FFTConvolver::~FFTConvolver()
+{
+  reset();
+}
+
+  
+void FFTConvolver::reset()
+{  
+  for (size_t i=0; i<_segCount; ++i)
+  {
+    delete _segments[i];
+    delete _segmentsIR[i];
+  }
+  
+  _blockSize = 0;
+  _segSize = 0;
+  _segCount = 0;
+  _fftComplexSize = 0;
+  _segments.clear();
+  _segmentsIR.clear();
+  _fftBuffer.clear();
+  _fft.init(0);
+  _preMultiplied.clear();
+  _conv.clear();
+  _overlap.clear();
+  _current = 0;
+  _inputBuffer.clear();
+  _inputBufferFill = 0;
+}
+
+  
+bool FFTConvolver::init(size_t blockSize, const Sample* ir, size_t irLen)
+{
+  reset();
+
+  if (blockSize == 0)
+  {
+    return false;
+  }
+  
+  // Ignore zeros at the end of the impulse response because they only waste computation time
+  while (irLen > 0 && ::fabs(ir[irLen-1]) < 0.000001f)
+  {
+    --irLen;
+  }
+
+  if (irLen == 0)
+  {
+    return true;
+  }
+  
+  _blockSize = NextPowerOf2(blockSize);
+  _segSize = 2 * _blockSize;
+  _segCount = static_cast<size_t>(::ceil(static_cast<float>(irLen) / static_cast<float>(_blockSize)));
+  _fftComplexSize = audiofft::AudioFFT::ComplexSize(_segSize);
+  
+  // FFT
+  _fft.init(_segSize);
+  _fftBuffer.resize(_segSize);
+  
+  // Prepare segments
+  for (size_t i=0; i<_segCount; ++i)
+  {
+    _segments.push_back(new SplitComplex(_fftComplexSize));    
+  }
+  
+  // Prepare IR
+  for (size_t i=0; i<_segCount; ++i)
+  {
+    SplitComplex* segment = new SplitComplex(_fftComplexSize);
+    const size_t remaining = irLen - (i * _blockSize);
+    const size_t sizeCopy = (remaining >= _blockSize) ? _blockSize : remaining;
+    CopyAndPad(_fftBuffer, &ir[i*_blockSize], sizeCopy);
+    _fft.fft(_fftBuffer.data(), segment->re(), segment->im());
+    _segmentsIR.push_back(segment);
+  }
+  
+  // Prepare convolution buffers  
+  _preMultiplied.resize(_fftComplexSize);
+  _conv.resize(_fftComplexSize);
+  _overlap.resize(_blockSize);
+  
+  // Prepare input buffer
+  _inputBuffer.resize(_blockSize);
+  _inputBufferFill = 0;
+
+  // Reset current position
+  _current = 0;
+  
+  return true;
+}
+
+
+void FFTConvolver::process(const Sample* input, Sample* output, size_t len)
+{
+  if (_segCount == 0)
+  {
+    ::memset(output, 0, len * sizeof(Sample));
+    return;
+  }
+
+  size_t processed = 0;
+  while (processed < len)
+  {
+    const bool inputBufferWasEmpty = (_inputBufferFill == 0);
+    const size_t processing = std::min(len-processed, _blockSize-_inputBufferFill);
+    const size_t inputBufferPos = _inputBufferFill;
+    ::memcpy(_inputBuffer.data()+inputBufferPos, input+processed, processing * sizeof(Sample));
+
+    // Forward FFT
+    CopyAndPad(_fftBuffer, &_inputBuffer[0], _blockSize); 
+    _fft.fft(_fftBuffer.data(), _segments[_current]->re(), _segments[_current]->im());
+
+    // Complex multiplication
+    if (inputBufferWasEmpty)
+    {
+      _preMultiplied.setZero();
+      for (size_t i=1; i<_segCount; ++i)
+      {
+        const size_t indexIr = i;
+        const size_t indexAudio = (_current + i) % _segCount;
+        ComplexMultiplyAccumulate(_preMultiplied, *_segmentsIR[indexIr], *_segments[indexAudio]);
+      }
+    }
+    _conv.copyFrom(_preMultiplied);
+    ComplexMultiplyAccumulate(_conv, *_segments[_current], *_segmentsIR[0]);
+
+    // Backward FFT
+    _fft.ifft(_fftBuffer.data(), _conv.re(), _conv.im());
+
+    // Add overlap
+    Sum(output+processed, _fftBuffer.data()+inputBufferPos, _overlap.data()+inputBufferPos, processing);
+
+    // Input buffer full => Next block
+    _inputBufferFill += processing;
+    if (_inputBufferFill == _blockSize)
+    {
+      // Input buffer is empty again now
+      _inputBuffer.setZero();
+      _inputBufferFill = 0;
+
+      // Save the overlap
+      ::memcpy(_overlap.data(), _fftBuffer.data()+_blockSize, _blockSize * sizeof(Sample));
+
+      // Update current segment
+      _current = (_current > 0) ? (_current - 1) : (_segCount - 1);
+    }
+
+    processed += processing;
+  }
+}
+  
+} // End of namespace fftconvolver
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.h
new file mode 100755
index 000000000..27f6d1256
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/FFTConvolver.h
@@ -0,0 +1,104 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#ifndef _FFTCONVOLVER_FFTCONVOLVER_H
+#define _FFTCONVOLVER_FFTCONVOLVER_H
+
+#include "AudioFFT.h"
+#include "Utilities.h"
+
+#include <vector>
+
+
+namespace fftconvolver
+{ 
+
+/**
+* @class FFTConvolver
+* @brief Implementation of a partitioned FFT convolution algorithm with uniform block size
+*
+* Some notes on how to use it:
+*
+* - After initialization with an impulse response, subsequent data portions of
+*   arbitrary length can be convolved. The convolver internally can handle
+*   this by using appropriate buffering.
+*
+* - The convolver works without "latency" (except for the required
+*   processing time, of course), i.e. the output always is the convolved
+*   input for each processing call.
+*
+* - The convolver is suitable for real-time processing which means that no
+*   "unpredictable" operations like allocations, locking, API calls, etc. are
+*   performed during processing (all necessary allocations and preparations take
+*   place during initialization).
+*/
+class FFTConvolver
+{  
+public:
+  FFTConvolver();  
+  virtual ~FFTConvolver();
+  
+  /**
+  * @brief Initializes the convolver
+  * @param blockSize Block size internally used by the convolver (partition size)
+  * @param ir The impulse response
+  * @param irLen Length of the impulse response
+  * @return true: Success - false: Failed
+  */
+  bool init(size_t blockSize, const Sample* ir, size_t irLen);
+
+  /**
+  * @brief Convolves the the given input samples and immediately outputs the result
+  * @param input The input samples
+  * @param output The convolution result
+  * @param len Number of input/output samples
+  */
+  void process(const Sample* input, Sample* output, size_t len);
+
+  /**
+  * @brief Resets the convolver and discards the set impulse response
+  */
+  void reset();
+  
+private:
+  size_t _blockSize;
+  size_t _segSize;
+  size_t _segCount;
+  size_t _fftComplexSize;
+  std::vector<SplitComplex*> _segments;
+  std::vector<SplitComplex*> _segmentsIR;
+  SampleBuffer _fftBuffer;
+  audiofft::AudioFFT _fft;
+  SplitComplex _preMultiplied;
+  SplitComplex _conv;
+  SampleBuffer _overlap;
+  size_t _current;
+  SampleBuffer _inputBuffer;
+  size_t _inputBufferFill;
+
+  // Prevent uncontrolled usage
+  FFTConvolver(const FFTConvolver&);
+  FFTConvolver& operator=(const FFTConvolver&);
+};
+  
+} // End of namespace fftconvolver
+
+#endif // Header guard
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/README.md b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/README.md
new file mode 100644
index 000000000..df5792720
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/README.md
@@ -0,0 +1,10 @@
+FFTConvolver
+============
+
+FFTConvolver is a C++ library for highly efficient convolution of
+audio data (e.g. for usage in real-time convolution reverbs etc.).
+
+- Partitioned convolution algorithm (using uniform block sizes)
+- Optional support for non-uniform block sizes (TwoStageFFTConvolver)
+- No external dependencies (FFT already included)
+- Optional optimization for SSE (enabled by defining FFTCONVOLVER_USE_SSE)
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.cpp
new file mode 100755
index 000000000..e3b96c0ed
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.cpp
@@ -0,0 +1,239 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#include "TwoStageFFTConvolver.h"
+
+#include <algorithm>
+#include <cmath>
+
+
+namespace fftconvolver
+{
+
+TwoStageFFTConvolver::TwoStageFFTConvolver() :
+  _headBlockSize(0),
+  _tailBlockSize(0),
+  _headConvolver(),
+  _tailConvolver0(),
+  _tailOutput0(),
+  _tailPrecalculated0(0),
+  _tailConvolver(),
+  _tailOutput(),
+  _tailPrecalculated(0),
+  _tailInput(),
+  _tailInputFill(0),
+  _precalculatedPos(0),
+  _backgroundProcessingInput()
+{
+}
+
+  
+TwoStageFFTConvolver::~TwoStageFFTConvolver()
+{
+  reset();
+}
+
+  
+void TwoStageFFTConvolver::reset()
+{
+  _headBlockSize = 0;
+  _tailBlockSize = 0;  
+  _headConvolver.reset();
+  _tailConvolver0.reset();
+  _tailOutput0.clear();
+  _tailPrecalculated0.clear();
+  _tailConvolver.reset();  
+  _tailOutput.clear();
+  _tailPrecalculated.clear();
+  _tailInput.clear();
+  _tailInputFill = 0;
+  _tailInputFill = 0;
+  _precalculatedPos = 0;
+  _backgroundProcessingInput.clear();
+}
+
+  
+bool TwoStageFFTConvolver::init(size_t headBlockSize,
+                                size_t tailBlockSize,
+                                const Sample* ir,
+                                size_t irLen)
+{
+  reset();
+
+  if (headBlockSize == 0 || tailBlockSize == 0)
+  {
+    return false;
+  }
+  
+  headBlockSize = std::max(size_t(1), headBlockSize);
+  if (headBlockSize > tailBlockSize)
+  {
+    assert(false);
+    std::swap(headBlockSize, tailBlockSize);
+  }
+  
+  // Ignore zeros at the end of the impulse response because they only waste computation time
+  while (irLen > 0 && ::fabs(ir[irLen-1]) < 0.000001f)
+  {
+    --irLen;
+  }
+
+  if (irLen == 0)
+  {
+    return true;
+  }
+  
+  _headBlockSize = NextPowerOf2(headBlockSize);
+  _tailBlockSize = NextPowerOf2(tailBlockSize);
+
+  const size_t headIrLen = std::min(irLen, _tailBlockSize);
+  _headConvolver.init(_headBlockSize, ir, headIrLen);
+
+  if (irLen > _tailBlockSize)
+  {
+    const size_t conv1IrLen = std::min(irLen-_tailBlockSize, _tailBlockSize);
+    _tailConvolver0.init(_headBlockSize, ir+_tailBlockSize, conv1IrLen);
+    _tailOutput0.resize(_tailBlockSize);
+    _tailPrecalculated0.resize(_tailBlockSize);
+  }
+
+  if (irLen > 2 * _tailBlockSize)
+  {
+    const size_t tailIrLen = irLen - (2*_tailBlockSize);
+    _tailConvolver.init(_tailBlockSize, ir+(2*_tailBlockSize), tailIrLen);
+    _tailOutput.resize(_tailBlockSize);
+    _tailPrecalculated.resize(_tailBlockSize);
+    _backgroundProcessingInput.resize(_tailBlockSize);
+  }
+
+  if (_tailPrecalculated0.size() > 0 || _tailPrecalculated.size() > 0)
+  {
+    _tailInput.resize(_tailBlockSize);
+  }
+  _tailInputFill = 0;
+  _precalculatedPos = 0;
+
+  return true;
+}
+
+
+void TwoStageFFTConvolver::process(const Sample* input, Sample* output, size_t len)
+{
+  // Head
+  _headConvolver.process(input, output, len);
+
+  // Tail
+  if (_tailInput.size() > 0)
+  {
+    size_t processed = 0;
+    while (processed < len)
+    {
+      const size_t remaining = len - processed;
+      const size_t processing = std::min(remaining, _headBlockSize - (_tailInputFill % _headBlockSize));
+      assert(_tailInputFill + processing <= _tailBlockSize);
+
+      // Sum head and tail
+      const size_t sumBegin = processed;
+      const size_t sumEnd = processed + processing;
+      {
+        // Sum: 1st tail block
+        if (_tailPrecalculated0.size() > 0)
+        {      
+          size_t precalculatedPos = _precalculatedPos;
+          for (size_t i=sumBegin; i<sumEnd; ++i)
+          {
+            output[i] += _tailPrecalculated0[precalculatedPos];
+            ++precalculatedPos;
+          }
+        }
+
+        // Sum: 2nd-Nth tail block
+        if (_tailPrecalculated.size() > 0)
+        {      
+          size_t precalculatedPos = _precalculatedPos;
+          for (size_t i=sumBegin; i<sumEnd; ++i)
+          {
+            output[i] += _tailPrecalculated[precalculatedPos];
+            ++precalculatedPos;
+          }
+        }
+
+        _precalculatedPos += processing;
+      }
+
+      // Fill input buffer for tail convolution
+      ::memcpy(_tailInput.data()+_tailInputFill, input+processed, processing * sizeof(Sample));
+      _tailInputFill += processing;
+      assert(_tailInputFill <= _tailBlockSize);
+
+      // Convolution: 1st tail block
+      if (_tailPrecalculated0.size() > 0 && _tailInputFill % _headBlockSize == 0)
+      {
+        assert(_tailInputFill >= _headBlockSize);
+        const size_t blockOffset = _tailInputFill - _headBlockSize;
+        _tailConvolver0.process(_tailInput.data()+blockOffset, _tailOutput0.data()+blockOffset, _headBlockSize);
+        if (_tailInputFill == _tailBlockSize)
+        {          
+          SampleBuffer::Swap(_tailPrecalculated0, _tailOutput0);
+        }
+      }
+
+      // Convolution: 2nd-Nth tail block (might be done in some background thread)
+      if (_tailPrecalculated.size() > 0 &&
+          _tailInputFill == _tailBlockSize &&
+          _backgroundProcessingInput.size() == _tailBlockSize &&
+          _tailOutput.size() == _tailBlockSize)
+      {
+        waitForBackgroundProcessing();
+        SampleBuffer::Swap(_tailPrecalculated, _tailOutput);
+        _backgroundProcessingInput.copyFrom(_tailInput);
+        startBackgroundProcessing();
+      }
+        
+      if (_tailInputFill == _tailBlockSize)
+      {
+        _tailInputFill = 0;
+        _precalculatedPos = 0;
+      }
+
+      processed += processing;
+    }
+  }
+}
+
+
+void TwoStageFFTConvolver::startBackgroundProcessing()
+{
+  doBackgroundProcessing();
+}
+
+
+void TwoStageFFTConvolver::waitForBackgroundProcessing()
+{
+}
+
+
+void TwoStageFFTConvolver::doBackgroundProcessing()
+{
+  _tailConvolver.process(_backgroundProcessingInput.data(), _tailOutput.data(), _tailBlockSize);
+}
+    
+} // End of namespace fftconvolver
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.h
new file mode 100755
index 000000000..5952c4a1d
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/TwoStageFFTConvolver.h
@@ -0,0 +1,129 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#ifndef _FFTCONVOLVER_TWOSTAGEFFTCONVOLVER_H
+#define _FFTCONVOLVER_TWOSTAGEFFTCONVOLVER_H
+
+#include "FFTConvolver.h"
+#include "Utilities.h"
+
+
+namespace fftconvolver
+{ 
+
+/**
+* @class TwoStageFFTConvolver
+* @brief FFT convolver using two different block sizes
+*
+* The 2-stage convolver consists internally of two convolvers:
+*
+* - A head convolver, which processes the only the begin of the impulse response.
+*
+* - A tail convolver, which processes the rest and major amount of the impulse response.
+*
+* Using a short block size for the head convolver and a long block size for
+* the tail convolver results in much less CPU usage, while keeping the
+* calculation time of each processing call short.
+*
+* Furthermore, this convolver class provides virtual methods which provide the
+* possibility to move the tail convolution into the background (e.g. by using
+* multithreading, see startBackgroundProcessing()/waitForBackgroundProcessing()).
+*
+* As well as the basic FFTConvolver class, the 2-stage convolver is suitable
+* for real-time processing which means that no "unpredictable" operations like
+* allocations, locking, API calls, etc. are performed during processing (all
+* necessary allocations and preparations take place during initialization).
+*/
+class TwoStageFFTConvolver
+{  
+public:
+  TwoStageFFTConvolver();  
+  virtual ~TwoStageFFTConvolver();
+  
+  /**
+  * @brief Initialization the convolver
+  * @param headBlockSize The head block size
+  * @param tailBlockSize the tail block size
+  * @param ir The impulse response
+  * @param irLen Length of the impulse response in samples
+  * @return true: Success - false: Failed
+  */
+  bool init(size_t headBlockSize, size_t tailBlockSize, const Sample* ir, size_t irLen);
+
+  /**
+  * @brief Convolves the the given input samples and immediately outputs the result
+  * @param input The input samples
+  * @param output The convolution result
+  * @param len Number of input/output samples
+  */
+  void process(const Sample* input, Sample* output, size_t len);
+
+  /**
+  * @brief Resets the convolver and discards the set impulse response
+  */
+  void reset();
+  
+protected:
+  /**
+  * @brief Method called by the convolver if work for background processing is available
+  *
+  * The default implementation just calls doBackgroundProcessing() to perform the "bulk"
+  * convolution. However, if you want to perform the majority of work in some background
+  * thread (which is recommended), you can overload this method and trigger the execution
+  * of doBackgroundProcessing() really in some background thread.
+  */
+  virtual void startBackgroundProcessing();
+
+  /**
+  * @brief Called by the convolver if it expects the result of its previous call to startBackgroundProcessing()
+  *
+  * After returning from this method, all background processing has to be completed.
+  */
+  virtual void waitForBackgroundProcessing();
+
+  /**
+  * @brief Actually performs the background processing work
+  */
+  void doBackgroundProcessing();
+
+private:
+  size_t _headBlockSize;
+  size_t _tailBlockSize;
+  FFTConvolver _headConvolver;
+  FFTConvolver _tailConvolver0;
+  SampleBuffer _tailOutput0;
+  SampleBuffer _tailPrecalculated0;
+  FFTConvolver _tailConvolver;
+  SampleBuffer _tailOutput;
+  SampleBuffer _tailPrecalculated;
+  SampleBuffer _tailInput;
+  size_t _tailInputFill;
+  size_t _precalculatedPos;
+  SampleBuffer _backgroundProcessingInput;
+
+  // Prevent uncontrolled usage
+  TwoStageFFTConvolver(const TwoStageFFTConvolver&);
+  TwoStageFFTConvolver& operator=(const TwoStageFFTConvolver&);
+};
+  
+} // End of namespace fftconvolver
+
+#endif // Header guard
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.cpp
new file mode 100644
index 000000000..3d00e6f50
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.cpp
@@ -0,0 +1,117 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#include "Utilities.h"
+
+
+namespace fftconvolver
+{
+
+bool SSEEnabled()
+{
+#if defined(FFTCONVOLVER_USE_SSE)
+  return true;
+#else
+  return false;
+#endif
+}
+
+
+void Sum(Sample* FFTCONVOLVER_RESTRICT result,
+         const Sample* FFTCONVOLVER_RESTRICT a,
+         const Sample* FFTCONVOLVER_RESTRICT b,
+         size_t len)
+{
+  const size_t end4 = 4 * (len / 4);
+  for (size_t i=0; i<end4; i+=4)
+  {
+    result[i+0] = a[i+0] + b[i+0];
+    result[i+1] = a[i+1] + b[i+1];
+    result[i+2] = a[i+2] + b[i+2];
+    result[i+3] = a[i+3] + b[i+3];
+  }
+  for (size_t i=end4; i<len; ++i)
+  {
+    result[i] = a[i] + b[i];
+  }
+}
+
+
+void ComplexMultiplyAccumulate(SplitComplex& result, const SplitComplex& a, const SplitComplex& b)
+{
+  assert(result.size() == a.size());
+  assert(result.size() == b.size());
+  ComplexMultiplyAccumulate(result.re(), result.im(), a.re(), a.im(), b.re(), b.im(), result.size());
+}
+
+
+void ComplexMultiplyAccumulate(Sample* FFTCONVOLVER_RESTRICT re, 
+                               Sample* FFTCONVOLVER_RESTRICT im,
+                               const Sample* FFTCONVOLVER_RESTRICT reA,
+                               const Sample* FFTCONVOLVER_RESTRICT imA,
+                               const Sample* FFTCONVOLVER_RESTRICT reB,
+                               const Sample* FFTCONVOLVER_RESTRICT imB,
+                               const size_t len)
+{
+#if defined(FFTCONVOLVER_USE_SSE)
+  const size_t end4 = 4 * (len / 4);
+  for (size_t i=0; i<end4; i+=4)
+  {
+    const __m128 ra = _mm_load_ps(&reA[i]);
+    const __m128 rb = _mm_load_ps(&reB[i]);
+    const __m128 ia = _mm_load_ps(&imA[i]);
+    const __m128 ib = _mm_load_ps(&imB[i]);
+    __m128 real = _mm_load_ps(&re[i]);
+    __m128 imag = _mm_load_ps(&im[i]);
+    real = _mm_add_ps(real, _mm_mul_ps(ra, rb));
+    real = _mm_sub_ps(real, _mm_mul_ps(ia, ib));
+    _mm_store_ps(&re[i], real);
+    imag = _mm_add_ps(imag, _mm_mul_ps(ra, ib));
+    imag = _mm_add_ps(imag, _mm_mul_ps(ia, rb));
+    _mm_store_ps(&im[i], imag);
+  }
+  for (size_t i=end4; i<len; ++i)
+  {
+    re[i] += reA[i] * reB[i] - imA[i] * imB[i];
+    im[i] += reA[i] * imB[i] + imA[i] * reB[i];
+  }
+#else
+  const size_t end4 = 4 * (len / 4);
+  for (size_t i=0; i<end4; i+=4)
+  {
+    re[i+0] += reA[i+0] * reB[i+0] - imA[i+0] * imB[i+0];
+    re[i+1] += reA[i+1] * reB[i+1] - imA[i+1] * imB[i+1];
+    re[i+2] += reA[i+2] * reB[i+2] - imA[i+2] * imB[i+2];
+    re[i+3] += reA[i+3] * reB[i+3] - imA[i+3] * imB[i+3];
+    im[i+0] += reA[i+0] * imB[i+0] + imA[i+0] * reB[i+0];
+    im[i+1] += reA[i+1] * imB[i+1] + imA[i+1] * reB[i+1];
+    im[i+2] += reA[i+2] * imB[i+2] + imA[i+2] * reB[i+2];
+    im[i+3] += reA[i+3] * imB[i+3] + imA[i+3] * reB[i+3];
+  }
+  for (size_t i=end4; i<len; ++i)
+  {
+    re[i] += reA[i] * reB[i] - imA[i] * imB[i];
+    im[i] += reA[i] * imB[i] + imA[i] * reB[i];
+  }
+#endif
+}
+
+} // End of namespace fftconvolver
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.h
new file mode 100644
index 000000000..19a5e4b41
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/Utilities.h
@@ -0,0 +1,355 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#ifndef _FFTCONVOLVER_UTILITIES_H
+#define _FFTCONVOLVER_UTILITIES_H
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <new>
+
+
+namespace fftconvolver
+{
+
+#if defined(__SSE__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
+  #if !defined(FFTCONVOLVER_USE_SSE) && !defined(FFTCONVOLVER_DONT_USE_SSE)
+    #define FFTCONVOLVER_USE_SSE
+  #endif
+#endif
+
+
+#if defined (FFTCONVOLVER_USE_SSE)
+  #include <xmmintrin.h>
+#endif
+
+
+#if defined(__GNUC__)
+  #define FFTCONVOLVER_RESTRICT __restrict__
+#else
+  #define FFTCONVOLVER_RESTRICT
+#endif
+
+
+/**
+* @brief Returns whether SSE optimization for the convolver is enabled
+* @return true: Enabled - false: Disabled
+*/
+bool SSEEnabled();
+
+
+/**
+* @class Buffer
+* @brief Simple buffer implementation (uses 16-byte alignment if SSE optimization is enabled)
+*/
+template<typename T>
+class Buffer
+{
+public:  
+  explicit Buffer(size_t initialSize = 0) :
+    _data(0),
+    _size(0)
+  {
+    resize(initialSize);
+  }
+
+  virtual ~Buffer()
+  {
+    clear();
+  }
+
+  void clear()
+  {
+    deallocate(_data);
+    _data = 0;
+    _size = 0;
+  }
+
+  void resize(size_t size)
+  {
+    if (_size != size)
+    {
+      clear();
+
+      if (size > 0)
+      {
+        assert(!_data && _size == 0);
+        _data = allocate(size);
+        _size = size;
+      }
+    }
+    setZero();
+  }
+
+  size_t size() const
+  {
+    return _size;
+  }
+
+  void setZero()
+  {
+    ::memset(_data, 0, _size * sizeof(T));
+  }
+
+  void copyFrom(const Buffer<T>& other)
+  {
+    assert(_size == other._size);
+    if (this != &other)
+    {
+      ::memcpy(_data, other._data, _size * sizeof(T));
+    }
+  }
+
+  T& operator[](size_t index)
+  {
+    assert(_data && index < _size);
+    return _data[index];
+  }
+
+  const T& operator[](size_t index) const
+  {
+    assert(_data && index < _size);
+    return _data[index];
+  }
+
+  operator bool() const
+  {
+    return (_data != 0 && _size > 0);
+  }
+
+  T* data()
+  {
+    return _data;
+  }
+
+  const T* data() const
+  {
+    return _data;
+  }
+
+  static void Swap(Buffer<T>& a, Buffer<T>& b)
+  {
+    std::swap(a._data, b._data);
+    std::swap(a._size, b._size);
+  }
+
+private:
+  T* allocate(size_t size)
+  {
+#if defined(FFTCONVOLVER_USE_SSE)
+    return static_cast<T*>(_mm_malloc(size * sizeof(T), 16));
+#else
+    return new T[size];
+#endif
+  }
+  
+  void deallocate(T* ptr)
+  {
+#if defined(FFTCONVOLVER_USE_SSE)
+    _mm_free(ptr);
+#else
+    delete [] ptr;
+#endif
+  }
+
+  T* _data;
+  size_t _size;
+
+  // Prevent uncontrolled usage
+  Buffer(const Buffer&);
+  Buffer& operator=(const Buffer&);
+};
+
+
+/**
+* @brief Type of one sample
+*/
+typedef float Sample;
+
+
+/**
+* @brief Buffer for samples
+*/
+typedef Buffer<Sample> SampleBuffer;
+
+
+/**
+* @class SplitComplex
+* @brief Buffer for split-complex representation of FFT results
+*
+* The split-complex representation stores the real and imaginary parts
+* of FFT results in two different memory buffers which is useful e.g. for
+* SIMD optimizations.
+*/
+class SplitComplex
+{
+public:
+  explicit SplitComplex(size_t initialSize = 0) : 
+    _size(0),
+    _re(),
+    _im()
+  {
+    resize(initialSize);
+  }
+
+  ~SplitComplex()
+  {
+    clear();
+  }
+
+  void clear()
+  {
+    _re.clear();
+    _im.clear();
+    _size = 0;
+  }
+
+  void resize(size_t newSize)
+  {
+    _re.resize(newSize);
+    _im.resize(newSize);
+    _size = newSize;
+  }
+
+  void setZero()
+  {
+    _re.setZero();
+    _im.setZero();
+  }
+
+  void copyFrom(const SplitComplex& other)
+  {
+    _re.copyFrom(other._re);
+    _im.copyFrom(other._im);
+  }
+
+  Sample* re()
+  {
+    return _re.data();
+  }
+
+  const Sample* re() const
+  {
+    return _re.data();
+  }
+
+  Sample* im()
+  {
+    return _im.data();
+  }
+
+  const Sample* im() const
+  {
+    return _im.data();
+  }
+
+  size_t size() const
+  {
+    return _size;
+  }
+
+private:
+  size_t _size;
+  SampleBuffer _re;
+  SampleBuffer _im;
+
+  // Prevent uncontrolled usage
+  SplitComplex(const SplitComplex&);
+  SplitComplex& operator=(const SplitComplex&);
+};
+
+
+/**
+* @brief Returns the next power of 2 of a given number
+* @param val The number
+* @return The next power of 2
+*/
+template<typename T>
+T NextPowerOf2(const T& val)
+{
+  T nextPowerOf2 = 1;
+  while (nextPowerOf2 < val)
+  {
+    nextPowerOf2 *= 2;
+  }
+  return nextPowerOf2;
+}
+  
+
+/**
+* @brief Sums two given sample arrays
+* @param result The result array
+* @param a The 1st array
+* @param b The 2nd array
+* @param len The length of the arrays
+*/
+void Sum(Sample* FFTCONVOLVER_RESTRICT result,
+         const Sample* FFTCONVOLVER_RESTRICT a,
+         const Sample* FFTCONVOLVER_RESTRICT b,
+         size_t len);
+
+
+/**
+* @brief Copies a source array into a destination buffer and pads the destination buffer with zeros
+* @param dest The destination buffer
+* @param src The source array
+* @param srcSize The size of the source array
+*/
+template<typename T>
+void CopyAndPad(Buffer<T>& dest, const T* src, size_t srcSize)
+{
+  assert(dest.size() >= srcSize);
+  ::memcpy(dest.data(), src, srcSize * sizeof(T));
+  ::memset(dest.data() + srcSize, 0, (dest.size()-srcSize) * sizeof(T)); 
+}
+
+
+/**
+* @brief Adds the complex product of two split-complex buffers to a result buffer
+* @param result The result buffer
+* @param a The 1st factor of the complex product
+* @param b The 2nd factor of the complex product
+*/
+void ComplexMultiplyAccumulate(SplitComplex& result, const SplitComplex& a, const SplitComplex& b);
+
+
+/**
+* @brief Adds the complex product of two split-complex arrays to a result array
+* @param re The real part of the result buffer
+* @param im The imaginary part of the result buffer
+* @param reA The real part of the 1st factor of the complex product
+* @param imA The imaginary part of the 1st factor of the complex product
+* @param reB The real part of the 2nd factor of the complex product
+* @param imB The imaginary part of the 2nd factor of the complex product
+*/
+void ComplexMultiplyAccumulate(Sample* FFTCONVOLVER_RESTRICT re, 
+                               Sample* FFTCONVOLVER_RESTRICT im,
+                               const Sample* FFTCONVOLVER_RESTRICT reA,
+                               const Sample* FFTCONVOLVER_RESTRICT imA,
+                               const Sample* FFTCONVOLVER_RESTRICT reB,
+                               const Sample* FFTCONVOLVER_RESTRICT imB,
+                               const size_t len);
+  
+} // End of namespace fftconvolver
+
+#endif // Header guard
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/test/Test.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/test/Test.cpp
new file mode 100755
index 000000000..23fdda046
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/FFTConvolver/test/Test.cpp
@@ -0,0 +1,342 @@
+// ==================================================================================
+// Copyright (c) 2017 HiFi-LoFi
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ==================================================================================
+
+#include <algorithm>
+#include <cstring>
+#include <numeric>
+#include <vector>
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+
+#include "audioapi/libs/FFTConvolver/FFTConvolver.h"
+#include "audioapi/libs/FFTConvolver/TwoStageFFTConvolver.h"
+#include "audioapi/libs/FFTConvolver/Utilities.h"
+
+
+template<typename T>
+void SimpleConvolve(const T* input, size_t inLen, const T* ir, size_t irLen, T* output)
+{
+  if (irLen > inLen)
+  {
+    SimpleConvolve(ir, irLen, input, inLen, output);
+    return;
+  }
+
+  ::memset(output, 0, (inLen+irLen-1) * sizeof(T));
+
+  for (size_t n=0; n<irLen; ++n)
+  {
+    for (size_t m=0; m<=n; ++m)
+    {
+      output[n] += ir[m] * input[n-m];
+    }
+  }
+
+  for (size_t n=irLen; n<inLen; ++n)
+  {
+    for (size_t m=0; m<irLen; ++m)
+    {
+      output[n] += ir[m] * input[n-m];
+    }
+  }
+
+  for (size_t n=inLen; n<inLen+irLen-1; ++n)
+  {
+    for (size_t m=n-inLen+1; m<irLen; ++m)
+    {
+      output[n] += ir[m] * input[n-m];
+    }
+  }
+}
+
+
+static bool TestConvolver(size_t inputSize,
+                          size_t irSize,
+                          size_t blockSizeMin,
+                          size_t blockSizeMax,
+                          size_t blockSizeConvolver,
+                          bool refCheck)
+{
+  // Prepare input and IR
+  std::vector<fftconvolver::Sample> in(inputSize);
+  for (size_t i=0; i<inputSize; ++i)
+  {
+    in[i] = 0.1f * static_cast<fftconvolver::Sample>(i+1);
+  }
+
+  std::vector<fftconvolver::Sample> ir(irSize);
+  for (size_t i=0; i<irSize; ++i)
+  {
+    ir[i] = 0.1f * static_cast<fftconvolver::Sample>(i+1);
+  }
+
+  // Simple convolver
+  std::vector<fftconvolver::Sample> outSimple(in.size() + ir.size() - 1, fftconvolver::Sample(0.0));
+  if (refCheck)
+  {
+    SimpleConvolve(&in[0], in.size(), &ir[0], ir.size(), &outSimple[0]);
+  }
+
+  // FFT convolver
+  std::vector<fftconvolver::Sample> out(in.size() + ir.size() - 1, fftconvolver::Sample(0.0));
+  {
+    fftconvolver::FFTConvolver convolver;
+    convolver.init(blockSizeConvolver, &ir[0], ir.size());
+    std::vector<fftconvolver::Sample> inBuf(blockSizeMax);
+    size_t processedOut = 0;
+    size_t processedIn = 0;
+    while (processedOut < out.size())
+    {
+      const size_t blockSize = blockSizeMin + (static_cast<size_t>(rand()) % (1+(blockSizeMax-blockSizeMin)));
+
+      const size_t remainingOut = out.size() - processedOut;
+      const size_t remainingIn = in.size() - processedIn;
+
+      const size_t processingOut = std::min(remainingOut, blockSize);
+      const size_t processingIn = std::min(remainingIn, blockSize);
+
+      memset(&inBuf[0], 0, inBuf.size() * sizeof(fftconvolver::Sample));
+      if (processingIn > 0)
+      {
+        memcpy(&inBuf[0], &in[processedIn], processingIn * sizeof(fftconvolver::Sample));
+      }
+
+      convolver.process(&inBuf[0], &out[processedOut], processingOut);
+
+      processedOut += processingOut;
+      processedIn += processingIn;
+    }
+  }
+
+  if (refCheck)
+  {
+    size_t diffSamples = 0;
+    const double absTolerance = 0.001 * static_cast<double>(ir.size());
+    const double relTolerance = 0.0001 * ::log(static_cast<double>(ir.size()));
+    for (size_t i=0; i<outSimple.size(); ++i)
+    {
+      const double a = static_cast<double>(out[i]);
+      const double b = static_cast<double>(outSimple[i]);
+      if (::fabs(a) > 1.0 && ::fabs(b) > 1.0)
+      {
+        const double absError = ::fabs(a-b);
+        const double relError = absError / b;
+        if (relError > relTolerance && absError > absTolerance)
+        {
+          ++diffSamples;
+        }
+      }
+    }
+    printf("Correctness Test (input %d, IR %d, blocksize %d-%d) => %s\n", static_cast<int>(inputSize), static_cast<int>(irSize), static_cast<int>(blockSizeMin), static_cast<int>(blockSizeMax), (diffSamples == 0) ? "[OK]" : "[FAILED]");
+    return (diffSamples == 0);
+  }
+  else
+  {
+    printf("Performance Test (input %d, IR %d, blocksize %d-%d) => Completed\n", static_cast<int>(inputSize), static_cast<int>(irSize), static_cast<int>(blockSizeMin), static_cast<int>(blockSizeMax));
+    return true;
+  }
+}
+
+
+static bool TestTwoStageConvolver(size_t inputSize,
+                                  size_t irSize,
+                                  size_t blockSizeMin,
+                                  size_t blockSizeMax,
+                                  size_t blockSizeHead,
+                                  size_t blockSizeTail,
+                                  bool refCheck)
+{
+  // Prepare input and IR
+  std::vector<fftconvolver::Sample> in(inputSize);
+  for (size_t i=0; i<inputSize; ++i)
+  {
+    in[i] = 0.1f * static_cast<fftconvolver::Sample>(i+1);
+  }
+
+  std::vector<fftconvolver::Sample> ir(irSize);
+  for (size_t i=0; i<irSize; ++i)
+  {
+    ir[i] = 0.1f * static_cast<fftconvolver::Sample>(i+1);
+  }
+
+  // Simple convolver
+  std::vector<fftconvolver::Sample> outSimple(in.size() + ir.size() - 1, fftconvolver::Sample(0.0));
+  if (refCheck)
+  {
+    SimpleConvolve(&in[0], in.size(), &ir[0], ir.size(), &outSimple[0]);
+  }
+
+  // FFT convolver
+  std::vector<fftconvolver::Sample> out(in.size() + ir.size() - 1, fftconvolver::Sample(0.0));
+  {
+    fftconvolver::TwoStageFFTConvolver convolver;
+    convolver.init(blockSizeHead, blockSizeTail, &ir[0], ir.size());
+    std::vector<fftconvolver::Sample> inBuf(blockSizeMax);
+    size_t processedOut = 0;
+    size_t processedIn = 0;
+    while (processedOut < out.size())
+    {
+      const size_t blockSize = blockSizeMin + (static_cast<size_t>(rand()) % (1+(blockSizeMax-blockSizeMin)));
+
+      const size_t remainingOut = out.size() - processedOut;
+      const size_t remainingIn = in.size() - processedIn;
+
+      const size_t processingOut = std::min(remainingOut, blockSize);
+      const size_t processingIn = std::min(remainingIn, blockSize);
+
+      memset(&inBuf[0], 0, inBuf.size() * sizeof(fftconvolver::Sample));
+      if (processingIn > 0)
+      {
+        memcpy(&inBuf[0], &in[processedIn], processingIn * sizeof(fftconvolver::Sample));
+      }
+
+      convolver.process(&inBuf[0], &out[processedOut], processingOut);
+
+      processedOut += processingOut;
+      processedIn += processingIn;
+    }
+  }
+
+  if (refCheck)
+  {
+    size_t diffSamples = 0;
+    const double absTolerance = 0.001 * static_cast<double>(ir.size());
+    const double relTolerance = 0.0001 * ::log(static_cast<double>(ir.size()));
+    for (size_t i=0; i<outSimple.size(); ++i)
+    {
+      const double a = static_cast<double>(out[i]);
+      const double b = static_cast<double>(outSimple[i]);
+      if (::fabs(a) > 1.0 && ::fabs(b) > 1.0)
+      {
+        const double absError = ::fabs(a-b);
+        const double relError = absError / b;
+        if (relError > relTolerance && absError > absTolerance)
+        {
+          ++diffSamples;
+        }
+      }
+    }
+    printf("Correctness Test (2-stage, input %d, IR %d, blocksize %d-%d) => %s\n", static_cast<int>(inputSize), static_cast<int>(irSize), static_cast<int>(blockSizeMin), static_cast<int>(blockSizeMax), (diffSamples == 0) ? "[OK]" : "[FAILED]");
+    return (diffSamples == 0);
+  }
+  else
+  {
+    printf("Performance Test (2-stage, input %d, IR %d, blocksize %d-%d) => Completed\n", static_cast<int>(inputSize), static_cast<int>(irSize), static_cast<int>(blockSizeMin), static_cast<int>(blockSizeMax));
+    return true;
+  }
+}
+
+
+#define TEST_CORRECTNESS
+//#define TEST_PERFORMANCE
+
+#define TEST_FFTCONVOLVER
+#define TEST_TWOSTAGEFFTCONVOLVER
+
+
+int main()
+{
+#if defined(TEST_CORRECTNESS) && defined(TEST_FFTCONVOLVER)
+  TestConvolver(1, 1, 1, 1, 1, true);
+  TestConvolver(2, 2, 2, 2, 2, true);
+  TestConvolver(3, 3, 3, 3, 3, true);
+
+  TestConvolver(3, 2, 2, 2, 2, true);
+  TestConvolver(4, 2, 2, 2, 2, true);
+  TestConvolver(4, 3, 2, 2, 2, true);
+  TestConvolver(9, 4, 3, 3, 2, true);
+  TestConvolver(171, 7, 5, 5, 5, true);
+  TestConvolver(1979, 17, 7, 7, 5, true);
+  TestConvolver(100, 10, 3, 5, 5, true);
+  TestConvolver(123, 45, 12, 34, 34, true);
+
+  TestConvolver(2, 3, 2, 2, 2, true);
+  TestConvolver(2, 4, 2, 2, 2, true);
+  TestConvolver(3, 4, 2, 2, 2, true);
+  TestConvolver(4, 9, 3, 3, 3, true);
+  TestConvolver(7, 171, 5, 5, 5, true);
+  TestConvolver(17, 1979, 7, 7, 7, true);
+  TestConvolver(10, 100, 3, 5, 5, true);
+  TestConvolver(45, 123, 12, 34, 34, true);
+
+  TestConvolver(100000, 1234, 100,  128,  128, true);
+  TestConvolver(100000, 1234, 100,  256,  256, true);
+  TestConvolver(100000, 1234, 100,  512,  512, true);
+  TestConvolver(100000, 1234, 100, 1024, 1024, true);
+  TestConvolver(100000, 1234, 100, 2048, 2048, true);
+
+  TestConvolver(100000, 4321, 100,  128,  128, true);
+  TestConvolver(100000, 4321, 100,  256,  256, true);
+  TestConvolver(100000, 4321, 100,  512,  512, true);
+  TestConvolver(100000, 4321, 100, 1024, 1024, true);
+  TestConvolver(100000, 4321, 100, 2048, 2048, true);
+#endif
+
+
+#if defined(TEST_PERFORMANCE) && defined(TEST_FFTCONVOLVER)
+  TestConvolver(3*60*44100, 20*44100, 50, 100, 1024, false);
+#endif
+
+#if defined(TEST_CORRECTNESS) && defined(TEST_TWOSTAGEFFTCONVOLVER)
+  TestTwoStageConvolver(1, 1, 1, 1, 1, 1, true);
+  TestTwoStageConvolver(2, 2, 2, 2, 2, 2, true);
+  TestTwoStageConvolver(3, 3, 3, 3, 3, 3, true);
+
+  TestTwoStageConvolver(3, 2, 2, 2, 2, 4, true);
+  TestTwoStageConvolver(4, 2, 2, 2, 2, 4, true);
+  TestTwoStageConvolver(4, 3, 2, 2, 2, 4, true);
+  TestTwoStageConvolver(9, 4, 3, 3, 2, 4, true);
+  TestTwoStageConvolver(171, 7, 5, 5, 5, 10,true);
+  TestTwoStageConvolver(1979, 17, 7, 7, 5, 10, true);
+  TestTwoStageConvolver(100, 10, 3, 5, 5, 10, true);
+  TestTwoStageConvolver(123, 45, 12, 34, 34, 68, true);
+
+  TestTwoStageConvolver(2, 3, 2, 2, 1, 2, true);
+  TestTwoStageConvolver(2, 4, 2, 2, 1, 2, true);
+  TestTwoStageConvolver(3, 4, 2, 2, 1, 2, true);
+  TestTwoStageConvolver(4, 9, 3, 3, 2, 4, true);
+  TestTwoStageConvolver(7, 171, 5, 5, 2, 16, true);
+  TestTwoStageConvolver(17, 1979, 7, 7, 4, 16, true);
+  TestTwoStageConvolver(10, 100, 3, 5, 1, 4, true);
+  TestTwoStageConvolver(45, 123, 12, 34, 4, 32, true);
+
+  TestTwoStageConvolver(100000, 1234, 100,  128,  128, 4096, true);
+  TestTwoStageConvolver(100000, 1234, 100,  256,  256, 4096, true);
+  TestTwoStageConvolver(100000, 1234, 100,  512,  512, 4096, true);
+  TestTwoStageConvolver(100000, 1234, 100, 1024, 1024, 4096, true);
+  TestTwoStageConvolver(100000, 1234, 100, 2048, 2048, 4096, true);
+
+  TestTwoStageConvolver(100000, 4321, 100,  128,  128, 4096, true);
+  TestTwoStageConvolver(100000, 4321, 100,  256,  256, 4096, true);
+  TestTwoStageConvolver(100000, 4321, 100,  512,  512, 4096, true);
+  TestTwoStageConvolver(100000, 4321, 100, 1024, 1024, 4096, true);
+  TestTwoStageConvolver(100000, 4321, 100, 2048, 2048, 4096, true);
+#endif
+
+
+#if defined(TEST_PERFORMANCE) && defined(TEST_TWOSTAGEFFTCONVOLVER)
+  TestTwoStageConvolver(3*60*44100, 20*44100, 50, 100, 100, 2*8192, false);
+#endif
+
+  return 0;
+}
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 5f59581c6..12e603421 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -59,6 +59,7 @@ export { default as StereoPannerNode } from './core/StereoPannerNode';
 export { default as AudioRecorder } from './core/AudioRecorder';
 export { default as AudioManager } from './system';
 export { default as useSystemVolume } from './hooks/useSytemVolume';
+export { default as ConvolverNode } from './core/ConvolverNode';
 
 export {
   OscillatorType,
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 9ea349629..541cffc04 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -16,6 +16,7 @@ import PeriodicWave from './PeriodicWave';
 import AnalyserNode from './AnalyserNode';
 import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
 import { InvalidAccessError, NotSupportedError } from '../errors';
+import ConvolverNode from './ConvolverNode';
 
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
@@ -127,6 +128,10 @@ export default class BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
+  createConvolver(): ConvolverNode {
+    return new ConvolverNode(this, this.context.createConvolver());
+  }
+
   async decodeAudioDataSource(sourcePath: string): Promise<AudioBuffer> {
     // Remove the file:// prefix if it exists
     if (sourcePath.startsWith('file://')) {
diff --git a/packages/react-native-audio-api/src/core/ConvolverNode.ts b/packages/react-native-audio-api/src/core/ConvolverNode.ts
new file mode 100644
index 000000000..a2b71592f
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/ConvolverNode.ts
@@ -0,0 +1,35 @@
+import { IConvolverNode } from '../interfaces';
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioBuffer from './AudioBuffer';
+
+export default class ConvolverNode extends AudioNode {
+  constructor(context: BaseAudioContext, node: IConvolverNode) {
+    super(context, node);
+    this.normalize = node.normalize;
+  }
+
+  public get buffer(): AudioBuffer | null {
+    const buffer = (this.node as IConvolverNode).buffer;
+    if (!buffer) {
+      return null;
+    }
+    return new AudioBuffer(buffer);
+  }
+
+  public set buffer(buffer: AudioBuffer | null) {
+    if (!buffer) {
+      (this.node as IConvolverNode).buffer = null;
+      return;
+    }
+    (this.node as IConvolverNode).buffer = buffer.buffer;
+  }
+
+  public get normalize(): boolean {
+    return (this.node as IConvolverNode).normalize;
+  }
+
+  public set normalize(value: boolean) {
+    (this.node as IConvolverNode).normalize = value;
+  }
+}
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index cd48019c6..7f0956ab6 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -33,6 +33,7 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
+  createConvolver: () => IConvolverNode;
   decodeAudioDataSource: (sourcePath: string) => Promise<IAudioBuffer>;
   decodeAudioData: (arrayBuffer: ArrayBuffer) => Promise<IAudioBuffer>;
   decodePCMAudioDataInBase64: (b64: string) => Promise<IAudioBuffer>;
@@ -137,6 +138,11 @@ export interface IAudioBufferQueueSourceNode
   pause: () => void;
 }
 
+export interface IConvolverNode extends IAudioNode {
+  buffer: IAudioBuffer | null;
+  normalize: boolean;
+}
+
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;

From f6de1fefafe2ddd425fa3e0d288b3898f0df1c89 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 1 Jul 2025 14:10:42 +0200
Subject: [PATCH 2/3] feat: remove nyquist components

---
 .../common/cpp/audioapi/dsp/Convolver.cpp     | 32 ++++++-------------
 1 file changed, 10 insertions(+), 22 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
index 231ca4b59..d6a19c1b4 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Convolver.cpp
@@ -34,18 +34,6 @@ void Convolver::reset() {
   _inputBuffer.zero();
 }
 
-float calculateNyquistComponent(float *data, size_t size) {
-  float component = 0.0f;
-  for (size_t i = 0; i < size; ++i) {
-    if (i % 2 == 0) {
-      component += data[i];
-    } else {
-      component -= data[i];
-    }
-  }
-  return component;
-}
-
 bool Convolver::init(
     size_t blockSize,
     const audioapi::AudioArray &ir,
@@ -94,11 +82,6 @@ bool Convolver::init(
         _blockSize * sizeof(float));
     memset(_fftBuffer.getData() + _blockSize, 0, _blockSize * sizeof(float));
     _fft->doFFT(_fftBuffer.getData(), segment);
-    segment[0].imag(0.0f); // DC component should be real
-    // Nyquist component
-    segment[_fftComplexSize - 1].imag(0.0f);
-    segment[_fftComplexSize - 1].real(
-        calculateNyquistComponent(_fftBuffer.getData(), _blockSize));
     _segmentsIR.push_back(segment);
   }
 
@@ -143,11 +126,16 @@ void Convolver::process(
   // result is stored in the first FDL slot.
   // _current marks first FDL slot, which is the current input block.
   _fft->doFFT(_inputBuffer.getData(), _segments[_current]);
-  _segments[_current][0].imag(0.0f); // DC component should be real
-  // Nyquist component
-  _segments[_current][_fftComplexSize - 1].imag(0.0f);
-  _segments[_current][_fftComplexSize - 1].real(
-      calculateNyquistComponent(_inputBuffer.getData(), _blockSize));
+  _fft->doInverseFFT(_segments[_current], _fftBuffer.getData());
+  for (int i = 0; i < _segSize; ++i) {
+    if (verbose) {
+      printf(
+          "fft[%d]: %f %f\n",
+          i,
+          _inputBuffer.getData()[i],
+          _fftBuffer.getData()[i]);
+    }
+  }
 
   // The P sub filter spectra are pairwisely multiplied with the input spectra
   // in the FDL. The results are accumulated in the frequency-domain.

From 362b8b58c9fd00a85ec9783ad1bb805d7a2447ba Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Mon, 7 Jul 2025 10:30:25 +0200
Subject: [PATCH 3/3] feat: refactored example for reverb

---
 .../src/examples/Oscillator/Oscillator.tsx     | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/apps/common-app/src/examples/Oscillator/Oscillator.tsx b/apps/common-app/src/examples/Oscillator/Oscillator.tsx
index c1319d557..b80c4b8fc 100644
--- a/apps/common-app/src/examples/Oscillator/Oscillator.tsx
+++ b/apps/common-app/src/examples/Oscillator/Oscillator.tsx
@@ -29,6 +29,7 @@ const Oscillator: FC = () => {
 
   const audioContextRef = useRef<AudioContext | null>(null);
   const oscillatorRef = useRef<OscillatorNode | null>(null);
+  const oscillatorRef2 = useRef<OscillatorNode | null>(null);
   const gainRef = useRef<GainNode | null>(null);
   const panRef = useRef<StereoPannerNode | null>(null);
   const convolverRef = useRef<ConvolverNode | null>(null);
@@ -61,13 +62,15 @@ const Oscillator: FC = () => {
     };
   }, []);
 
-  const setup = () => {
+  const setup = (reverb: boolean) => {
     if (!audioContextRef.current) {
       audioContextRef.current = new AudioContext();
     }
 
     oscillatorRef.current = audioContextRef.current.createOscillator();
+    oscillatorRef2.current = audioContextRef.current.createOscillator();
     oscillatorRef.current.frequency.value = frequency;
+    oscillatorRef2.current.frequency.value = frequency;
     oscillatorRef.current.detune.value = detune;
     oscillatorRef.current.type = oscillatorType;
 
@@ -79,7 +82,7 @@ const Oscillator: FC = () => {
 
     oscillatorRef.current.connect(gainRef.current);
     gainRef.current.connect(panRef.current);
-    if (convolverRef.current) {
+    if (convolverRef.current && reverb) {
       panRef.current.connect(convolverRef.current);
       convolverRef.current.connect(audioContextRef.current.destination);
     } else {
@@ -119,13 +122,17 @@ const Oscillator: FC = () => {
     }
   };
 
-  const handlePlayPause = () => {
+  const handlePlayPause = (reverb: boolean) => {
     if (isPlaying) {
       oscillatorRef.current?.stop(0);
     } else {
-      setup();
+      setup(reverb);
       oscillatorRef.current?.start(0);
       oscillatorRef.current?.stop(audioContextRef.current?.currentTime!! + 2);
+      gainRef.current?.gain.setValueAtTime(0, audioContextRef.current?.currentTime!! + 2);
+      oscillatorRef2.current?.start(audioContextRef.current?.currentTime!! + 2);
+      oscillatorRef2.current?.connect(gainRef.current!);
+      oscillatorRef2.current?.stop(audioContextRef.current?.currentTime!! + 3);
     }
 
     setIsPlaying((prev) => !prev);
@@ -140,7 +147,8 @@ const Oscillator: FC = () => {
 
   return (
     <Container centered>
-      <Button onPress={handlePlayPause} title={isPlaying ? 'Pause' : 'Play'} />
+      <Button onPress={() => handlePlayPause(false)} title={isPlaying ? 'Pause' : 'Play without reverb'} />
+      <Button onPress={() => handlePlayPause(true)} title={isPlaying ? 'Pause' : 'Play reverb'} />
       <Spacer.Vertical size={49} />
       <Slider
         label="Gain"