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

package/common/cpp/audioapi/core/utils/worklets/SafeIncludes.h

@@ -2,34 +2,28 @@
 
 #include <jsi/jsi.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
-#ifdef __APPLE__
-  /// We cannot make any conditional logic inside podspec but it should automatically compile those files
-  /// they should be accessible if someone has react-native-worklets in node_modules
-  #if __has_include(<worklets/WorkletRuntime/WorkletRuntime.h>)
-    #define RN_AUDIO_API_ENABLE_WORKLETS 1
-  #else
-    #define RN_AUDIO_API_ENABLE_WORKLETS 0
-  #endif
+#if ANDROID
+#include <fbjni/detail/Environment.h>
 #endif
 
 #ifndef RN_AUDIO_API_TEST
-  #define RN_AUDIO_API_TEST 0
+#define RN_AUDIO_API_TEST 0
 #endif
 
 #if RN_AUDIO_API_ENABLE_WORKLETS
-  #include <worklets/WorkletRuntime/WorkletRuntime.h>
-  #include <worklets/SharedItems/Serializable.h>
-  #include <worklets/NativeModules/WorkletsModuleProxy.h>
-  #if ANDROID
-    #include <worklets/android/WorkletsModule.h>
-  #endif
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#if ANDROID
+#include <worklets/android/WorkletsModule.h>
+#endif
 #else
 
 #define RN_AUDIO_API_WORKLETS_DISABLED_ERROR \
-  std::runtime_error(               \
+  std::runtime_error( \
       "Worklets are disabled. Please install react-native-worklets or check if you have supported version to enable these features.");
 
 /// @brief Dummy implementation of worklets for non-worklet builds they should do nothing and mock necessary methods
@@ -42,28 +36,24 @@ class MessageQueueThread {};
 class WorkletsModuleProxy {};
 class WorkletRuntime {
  public:
-  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool) {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Runtime &getJSIRuntime() const {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Value executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+  explicit WorkletRuntime(
+      uint64_t,
+      const std::shared_ptr<MessageQueueThread> &,
+      const std::string &,
+      const bool){throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR} jsi::Runtime &getJSIRuntime() const {
+      throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR} jsi::Value
+      executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const {
+          throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR} jsi::Value
+      executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+          throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR} jsi::Value
+      executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const {
     throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
   }
 };
 class SerializableWorklet {
  public:
-  SerializableWorklet(jsi::Runtime*, const jsi::Object &) {
-    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
-  }
-  jsi::Value toJSValue(jsi::Runtime &rt) {
+  SerializableWorklet(jsi::Runtime *, const jsi::Object &){
+      throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR} jsi::Value toJSValue(jsi::Runtime &rt) {
     throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
   }
 };
@@ -78,4 +68,13 @@ class SerializableWorklet {
 struct RuntimeRegistry {
   std::weak_ptr<worklets::WorkletRuntime> uiRuntime;
   std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
+
+#if ANDROID
+  ~RuntimeRegistry() {
+    facebook::jni::ThreadScope::WithClassLoader([this]() {
+      uiRuntime.reset();
+      audioRuntime.reset();
+    });
+  }
+#endif
 };

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.cpp

@@ -1,28 +1,28 @@
 #include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     bool shouldLockRuntime)
-    : weakRuntime_(std::move(weakRuntime)),
-      shouldLockRuntime(shouldLockRuntime) {
+    : weakRuntime_(std::move(weakRuntime)), shouldLockRuntime(shouldLockRuntime) {
   auto strongRuntime = weakRuntime_.lock();
   if (strongRuntime == nullptr) {
     return;
   }
 #if RN_AUDIO_API_ENABLE_WORKLETS
   unsafeRuntimePtr = &strongRuntime->getJSIRuntime();
-  strongRuntime->executeSync(
-      [this, shareableWorklet](jsi::Runtime &rt) -> jsi::Value {
-        /// Placement new to avoid dynamic memory allocation
-        new (reinterpret_cast<jsi::Function *>(&unsafeWorklet))
-            jsi::Function(shareableWorklet->toJSValue(*unsafeRuntimePtr)
-                              .asObject(*unsafeRuntimePtr)
-                              .asFunction(*unsafeRuntimePtr));
-        return jsi::Value::undefined();
-      });
+  strongRuntime->executeSync([this, shareableWorklet](jsi::Runtime &rt) -> jsi::Value {
+    /// Placement new to avoid dynamic memory allocation
+    new (reinterpret_cast<jsi::Function *>(&unsafeWorklet))
+        jsi::Function(shareableWorklet->toJSValue(*unsafeRuntimePtr)
+                          .asObject(*unsafeRuntimePtr)
+                          .asFunction(*unsafeRuntimePtr));
+    return jsi::Value::undefined();
+  });
   workletInitialized = true;
 #else
   unsafeRuntimePtr = nullptr;
@@ -33,8 +33,8 @@ WorkletsRunner::WorkletsRunner(
 WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
     : weakRuntime_(std::move(other.weakRuntime_)),
       unsafeRuntimePtr(other.unsafeRuntimePtr),
-      shouldLockRuntime(other.shouldLockRuntime),
-      workletInitialized(other.workletInitialized) {
+      workletInitialized(other.workletInitialized),
+      shouldLockRuntime(other.shouldLockRuntime) {
   if (workletInitialized) {
     std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
     other.workletInitialized = false;
@@ -56,8 +56,7 @@ WorkletsRunner::~WorkletsRunner() {
 }
 
 std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
-    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
-    noexcept(noexcept(job)) {
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job)) {
   auto strongRuntime = weakRuntime_.lock();
   if (strongRuntime == nullptr) {
     return std::nullopt;
@@ -70,13 +69,12 @@ std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
 }
 
 std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeUnsafe(
-    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
-    noexcept(noexcept(job)) {
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job)) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   return job(*unsafeRuntimePtr);
 #else
   return std::nullopt;
 #endif
-};
+}
 
 }; // namespace audioapi

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <jsi/jsi.h>
 
-#include <functional>
 #include <atomic>
+#include <functional>
 #include <memory>
-#include <utility>
 #include <optional>
+#include <utility>
 
 namespace audioapi {
 using namespace facebook;
@@ -27,10 +27,10 @@ using namespace facebook;
 class WorkletsRunner {
  public:
   explicit WorkletsRunner(
-    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
-    bool shouldLockRuntime = true);
-  WorkletsRunner(WorkletsRunner&&);
+      std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+      const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      bool shouldLockRuntime = true);
+  WorkletsRunner(WorkletsRunner &&);
   ~WorkletsRunner();
 
   /// @brief Call the worklet function with the given arguments.
@@ -38,19 +38,18 @@ class WorkletsRunner {
   /// @param ...args
   /// @return The result of the worklet function call.
   /// @note This method is unsafe and should be used with caution. It assumes that the runtime and worklet are valid and runtime is locked.
-  template<typename... Args>
-  inline jsi::Value callUnsafe(Args&&... args) {
+  template <typename... Args>
+  inline jsi::Value callUnsafe(Args &&...args) {
     return getUnsafeWorklet().call(*unsafeRuntimePtr, std::forward<Args>(args)...);
   }
 
-
   /// @brief Call the worklet function with the given arguments.
   /// @tparam ...Args
   /// @param ...args
   /// @return The result of the worklet function call.
   /// @note This method is safe and will check if the runtime is available before calling the worklet. If the runtime is not available, it will return nullopt.
-  template<typename... Args>
-  inline std::optional<jsi::Value> call(Args&&... args) {
+  template <typename... Args>
+  inline std::optional<jsi::Value> call(Args &&...args) {
     return executeOnRuntimeGuarded([this, args...](jsi::Runtime &rt) -> jsi::Value {
       return callUnsafe(std::forward<Args>(args)...);
     });
@@ -60,14 +59,17 @@ class WorkletsRunner {
   /// @param job
   /// @return nullopt if the runtime is not available or the result of the job execution
   /// @note Execution is synchronous and will be guarded if shouldLockRuntime is true.
-  inline std::optional<jsi::Value> executeOnRuntimeSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
-    if (shouldLockRuntime) return executeOnRuntimeGuarded(std::move(job));
-    else return executeOnRuntimeUnsafe(std::move(job));
+  inline std::optional<jsi::Value> executeOnRuntimeSync(
+      const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job)) {
+    if (shouldLockRuntime)
+      return executeOnRuntimeGuarded(std::move(job));
+    else
+      return executeOnRuntimeUnsafe(std::move(job));
   }
 
  private:
   std::weak_ptr<worklets::WorkletRuntime> weakRuntime_;
-  jsi::Runtime* unsafeRuntimePtr = nullptr;
+  jsi::Runtime *unsafeRuntimePtr = nullptr;
 
   /// @note We want to avoid automatic destruction as
   /// when runtime is destroyed, underlying pointer will be invalid
@@ -76,12 +78,14 @@ class WorkletsRunner {
   bool shouldLockRuntime = true;
 
   inline jsi::Function &getUnsafeWorklet() {
-    return *reinterpret_cast<jsi::Function*>(&unsafeWorklet);
+    return *reinterpret_cast<jsi::Function *>(&unsafeWorklet);
   }
 
-  std::optional<jsi::Value> executeOnRuntimeGuarded(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
+  std::optional<jsi::Value> executeOnRuntimeGuarded(
+      const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job));
 
-  std::optional<jsi::Value> executeOnRuntimeUnsafe(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
+  std::optional<jsi::Value> executeOnRuntimeUnsafe(
+      const std::function<jsi::Value(jsi::Runtime &)> &&job) const noexcept(noexcept(job));
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -9,18 +9,12 @@ double sampleFrameToTime(int sampleFrame, float sampleRate) {
   return static_cast<double>(sampleFrame) / sampleRate;
 }
 
-float linearInterpolate(
-    const float *source,
-    size_t firstIndex,
-    size_t secondIndex,
-    float factor) {
+float linearInterpolate(const float *source, size_t firstIndex, size_t secondIndex, float factor) {
   if (firstIndex == secondIndex && firstIndex >= 1) {
-    return source[firstIndex] +
-        factor * (source[firstIndex] - source[firstIndex - 1]);
+    return source[firstIndex] + factor * (source[firstIndex] - source[firstIndex - 1]);
   }
 
-  return source[firstIndex] +
-      factor * (source[secondIndex] - source[firstIndex]);
+  return source[firstIndex] + factor * (source[secondIndex] - source[firstIndex]);
 }
 
 float linearToDecibels(float value) {
@@ -30,4 +24,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return pow(10, value / 20);
 }
-} // namespace audioapi::dsp
+} // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/AudioUtils.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <cmath>
 
 namespace audioapi::dsp {
 

package/common/cpp/audioapi/dsp/Convolver.cpp

@@ -0,0 +1,201 @@
+// implementation of linear convolution algorithm described in this paper:
+// https://publications.rwth-aachen.de/record/466561/files/466561.pdf page 110
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#endif
+
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/dsp/Convolver.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <algorithm>
+#include <chrono>
+#include <iostream>
+#include <memory>
+
+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;
+  _current = 0;
+  _fft = nullptr;
+  _segments.clear();
+  _segmentsIR.clear();
+  _preMultiplied.clear();
+  _fftBuffer.zero();
+  _inputBuffer.zero();
+}
+
+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
+  _blockSize = blockSize;
+  _trueSegmentCount =
+      static_cast<size_t>((std::ceil(static_cast<float>(irLen) / static_cast<float>(_blockSize))));
+  while (irLen > 0 && ::fabs(ir[irLen - 1]) < 10e-3) {
+    --irLen;
+  }
+
+  if (irLen == 0) {
+    return true;
+  }
+
+  // The length-N is split into P = N/B length-B sub filters
+  _segCount =
+      static_cast<size_t>((std::ceil(static_cast<float>(irLen) / static_cast<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>(static_cast<int>(_segSize));
+  _fftBuffer.resize(_segSize);
+
+  // segments preparation
+  for (int i = 0; i < _segCount; ++i) {
+    aligned_vec_complex vec(_fftComplexSize, std::complex<float>(0.0f, 0.0f));
+    _segments.push_back(vec);
+  }
+
+  // ir preparation
+  for (int i = 0; i < _segCount; ++i) {
+    aligned_vec_complex segment(_fftComplexSize);
+    const size_t remainingSamples = irLen - (i * _blockSize);
+    const size_t samplesToCopy = std::min(_blockSize, remainingSamples);
+
+    if (samplesToCopy > 0) {
+      memcpy(_fftBuffer.getData(), ir.getData() + i * _blockSize, samplesToCopy * sizeof(float));
+    }
+    // Each sub filter is zero-padded to length 2B and transformed using a
+    // 2B-point real-to-complex FFT.
+    memset(_fftBuffer.getData() + _blockSize, 0, _blockSize * sizeof(float));
+    _fft->doFFT(_fftBuffer.getData(), segment);
+    segment.at(0).imag(0.0f); // ensure DC component is real
+    _segmentsIR.push_back(segment);
+  }
+
+  _preMultiplied = aligned_vec_complex(_fftComplexSize);
+  _inputBuffer.resize(_segSize);
+  _current = 0;
+
+  return true;
+}
+
+/// @brief Fast pairwise complex multiplication using ARM NEON intrinsics
+/// @param ir Impulse response
+/// @param audio Input audio signal
+/// @param pre Output buffer for pre-multiplied results
+/// @note IMPORTANT: ir, audio, and pre must be the same size and should be
+/// aligned to 16 bytes for optimal performance
+void pairwise_complex_multiply_fast(
+    const Convolver::aligned_vec_complex &ir,
+    const Convolver::aligned_vec_complex &audio,
+    Convolver::aligned_vec_complex &pre) {
+  size_t n = ir.size();
+
+/// @note Using ARM NEON intrinsics for SIMD optimization
+/// This implementation is on average 2x faster than the scalar version on ARM
+/// architectures With 16-byte alignment it can be even faster up to 2.5x
+#ifdef __ARM_NEON
+  size_t j = 0;
+
+  // Main vector loop: process 4 complex samples (8 floats) per iteration using
+  // vld2q/vst2q deinterleave
+  for (; j <= n - 4; j += 4) {
+    // load de-interleaved real/imag for 4 complex values
+    float32x4x2_t ir_de = vld2q_f32(reinterpret_cast<const float *>(&ir[j]));
+    float32x4x2_t a_de = vld2q_f32(reinterpret_cast<const float *>(&audio[j]));
+    float32x4x2_t pre_de = vld2q_f32(reinterpret_cast<float *>(&pre[j]));
+
+    float32x4_t ir_re = ir_de.val[0];
+    float32x4_t ir_im = ir_de.val[1];
+    float32x4_t a_re = a_de.val[0];
+    float32x4_t a_im = a_de.val[1];
+
+    // real = ir_re * a_re - ir_im * a_im
+    float32x4_t real = vmulq_f32(ir_re, a_re);
+    real = vmlsq_f32(real, ir_im, a_im);
+    // imag = ir_re * a_im + ir_im * a_re
+    float32x4_t imag = vmulq_f32(ir_re, a_im);
+    imag = vmlaq_f32(imag, ir_im, a_re);
+
+    // accumulate into pre
+    float32x4_t new_re = vaddq_f32(pre_de.val[0], real);
+    float32x4_t new_im = vaddq_f32(pre_de.val[1], imag);
+
+    float32x4x2_t out_de;
+    out_de.val[0] = new_re;
+    out_de.val[1] = new_im;
+
+    vst2q_f32(reinterpret_cast<float *>(&pre[j]), out_de);
+  }
+
+  // Tail
+  for (; j < n; ++j) {
+    pre[j] += ir[j] * audio[j];
+  }
+
+#else
+  // Fallback scalar implementation
+  for (size_t i = 0; i < n; ++i) {
+    pre[i] += ir[i] * audio[i];
+  }
+#endif
+}
+
+void Convolver::process(float *data, float *outputData) {
+  // 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.
+  memmove(_inputBuffer.getData(), _inputBuffer.getData() + _blockSize, _blockSize * sizeof(float));
+  memcpy(_inputBuffer.getData() + _blockSize, data, _blockSize * sizeof(float));
+
+  // All contents (DFT spectra) in the FDL are shifted up by one slot.
+  _current = (_current > 0) ? _current - 1 : _segCount - 1;
+  // 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); // ensure DC component is real
+
+  // The P sub filter spectra are pairwisely multiplied with the input spectra
+  // in the FDL. The results are accumulated in the frequency-domain.
+  memset(_preMultiplied.data(), 0, _preMultiplied.size() * sizeof(std::complex<float>));
+  // this is a bottleneck of the algorithm
+  for (int i = 0; i < _segCount; ++i) {
+    const int indexAudio = (_current + i) % _segCount;
+    const auto &impulseResponseSegment = _segmentsIR[i];
+    const auto &audioSegment = _segments[indexAudio];
+    pairwise_complex_multiply_fast(impulseResponseSegment, audioSegment, _preMultiplied);
+  }
+  // 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());
+
+  memcpy(outputData, _fftBuffer.getData() + _blockSize, _blockSize * sizeof(float));
+}
+} // namespace audioapi

package/common/cpp/audioapi/dsp/Convolver.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <audioapi/dsp/FFT.h>
+#include <audioapi/utils/AlignedAllocator.hpp>
+#include <audioapi/utils/AudioArray.h>
+#include <complex>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBuffer;
+
+class Convolver {
+  using aligned_vec_complex =
+      std::vector<std::complex<float>, AlignedAllocator<std::complex<float>, 16>>;
+
+ public:
+  Convolver();
+  bool init(size_t blockSize, const AudioArray &ir, size_t irLen);
+  void process(float *inputData, float *outputData);
+  void reset();
+  inline size_t getSegCount() const {
+    return _trueSegmentCount;
+  }
+
+ private:
+  size_t _trueSegmentCount;
+  size_t _blockSize;
+  size_t _segSize;
+  size_t _segCount;
+  size_t _fftComplexSize;
+  std::vector<aligned_vec_complex> _segments;
+  std::vector<aligned_vec_complex> _segmentsIR;
+  AudioArray _fftBuffer;
+  std::shared_ptr<dsp::FFT> _fft;
+  aligned_vec_complex _preMultiplied;
+  size_t _current;
+  AudioArray _inputBuffer;
+
+  friend void pairwise_complex_multiply_fast(
+      const aligned_vec_complex &ir,
+      const aligned_vec_complex &audio,
+      aligned_vec_complex &pre);
+};
+} // namespace audioapi

package/common/cpp/audioapi/dsp/FFT.cpp

@@ -4,7 +4,7 @@ namespace audioapi::dsp {
 
 FFT::FFT(int size) : size_(size) {
   pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
-  work_ = (float *)pffft_aligned_malloc(size_ * sizeof(float));
+  work_ = reinterpret_cast<float *>(pffft_aligned_malloc(size_ * sizeof(float)));
 }
 
 FFT::~FFT() {
@@ -12,30 +12,4 @@ FFT::~FFT() {
   pffft_aligned_free(work_);
 }
 
-void FFT::doFFT(float *in, std::vector<std::complex<float>> &out) {
-  pffft_transform_ordered(
-      pffftSetup_,
-      in,
-      reinterpret_cast<float *>(&out[0]),
-      work_,
-      PFFFT_FORWARD);
-
-  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) {
-  pffft_transform_ordered(
-      pffftSetup_,
-      reinterpret_cast<float *>(&in[0]),
-      out,
-      work_,
-      PFFFT_BACKWARD);
-
-  dsp::multiplyByScalar(out, 1.0f / static_cast<float>(size_), out, size_);
-}
-
 } // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/FFT.h

@@ -5,8 +5,8 @@
 
 #include <algorithm>
 #include <cmath>
-#include <utility>
 #include <complex>
+#include <utility>
 #include <vector>
 
 namespace audioapi::dsp {
@@ -16,8 +16,24 @@ class FFT {
   explicit FFT(int size);
   ~FFT();
 
-  void doFFT(float *in, std::vector<std::complex<float>> &out);
-  void doInverseFFT(std::vector<std::complex<float>> &in, float *out);
+  template <typename Allocator>
+  void doFFT(float *in, std::vector<std::complex<float>, Allocator> &out) {
+    pffft_transform_ordered(
+        pffftSetup_, in, reinterpret_cast<float *>(&out[0]), work_, PFFFT_FORWARD);
+    // this is a possible place for bugs and mistakes
+    // due to pffft implementation and how it stores results
+    // keep this information in mind
+    // out[0].real = DC component - should be pure real
+    // out[0].imag = Nyquist component - should be pure real
+  }
+
+  template <typename Allocator>
+  void doInverseFFT(std::vector<std::complex<float>, Allocator> &in, float *out) {
+    pffft_transform_ordered(
+        pffftSetup_, reinterpret_cast<float *>(&in[0]), out, work_, PFFFT_BACKWARD);
+
+    dsp::multiplyByScalar(out, 1.0f / static_cast<float>(size_), out, size_);
+  }
 
  private:
   int size_;