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

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_;

package/common/cpp/audioapi/dsp/VectorMath.cpp

@@ -25,6 +25,7 @@
 
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <algorithm>
 
 #if defined(HAVE_ACCELERATE)
 #include <Accelerate/Accelerate.h>
@@ -47,8 +48,7 @@ void multiplyByScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsmul(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsmul(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void addScalar(
@@ -56,8 +56,7 @@ void addScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsadd(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsadd(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void add(
@@ -65,14 +64,7 @@ void add(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vadd(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vadd(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void subtract(
@@ -80,14 +72,7 @@ void subtract(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsub(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsub(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void multiply(
@@ -95,19 +80,10 @@ void multiply(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vmul(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vmul(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   float maximumValue = 0;
   vDSP_maxmgv(inputVector, 1, &maximumValue, numberOfElementsToProcess);
   return maximumValue;
@@ -118,15 +94,7 @@ void multiplyByScalarThenAddToOutput(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsma(
-      inputVector,
-      1,
-      &scalar,
-      outputVector,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 #else
@@ -508,15 +476,15 @@ void multiply(
   bool source2Aligned = is16ByteAligned(inputVector2);
   bool destAligned = is16ByteAligned(outputVector);
 
-#define SSE2_MULT(loadInstr, storeInstr)           \
-  while (outputVector < endP) {                    \
-    pSource1 = _mm_load_ps(inputVector1);          \
+#define SSE2_MULT(loadInstr, storeInstr) \
+  while (outputVector < endP) { \
+    pSource1 = _mm_load_ps(inputVector1); \
     pSource2 = _mm_##loadInstr##_ps(inputVector2); \
-    dest = _mm_mul_ps(pSource1, pSource2);         \
-    _mm_##storeInstr##_ps(outputVector, dest);     \
-    inputVector1 += 4;                             \
-    inputVector2 += 4;                             \
-    outputVector += 4;                             \
+    dest = _mm_mul_ps(pSource1, pSource2); \
+    _mm_##storeInstr##_ps(outputVector, dest); \
+    inputVector1 += 4; \
+    inputVector2 += 4; \
+    outputVector += 4; \
   }
 
   if (source2Aligned && destAligned) // Both aligned.
@@ -552,9 +520,7 @@ void multiply(
   }
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   size_t n = numberOfElementsToProcess;
   float max = 0;
 
@@ -647,15 +613,15 @@ void multiplyByScalarThenAddToOutput(
 
   bool destAligned = is16ByteAligned(outputVector);
 
-#define SSE2_MULT_ADD(loadInstr, storeInstr)   \
-  while (outputVector < endP) {                \
-    pSource = _mm_load_ps(inputVector);        \
-    temp = _mm_mul_ps(pSource, mScale);        \
+#define SSE2_MULT_ADD(loadInstr, storeInstr) \
+  while (outputVector < endP) { \
+    pSource = _mm_load_ps(inputVector); \
+    temp = _mm_mul_ps(pSource, mScale); \
     dest = _mm_##loadInstr##_ps(outputVector); \
-    dest = _mm_add_ps(dest, temp);             \
+    dest = _mm_add_ps(dest, temp); \
     _mm_##storeInstr##_ps(outputVector, dest); \
-    inputVector += 4;                          \
-    outputVector += 4;                         \
+    inputVector += 4; \
+    outputVector += 4; \
   }
 
   if (destAligned)

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

@@ -28,23 +28,50 @@
 // Defines the interface for several vector math functions whose implementation
 // will ideally be optimized.
 
-#include <cstddef>
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 
 namespace audioapi::dsp {
 
-void multiplyByScalarThenAddToOutput(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
-void multiplyByScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void addScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void add(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void subtract(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void multiply(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void addScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void add(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void subtract(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void multiply(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 // Finds the maximum magnitude of a float vector.
 float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
 
-void linearToDecibels(const float *inputVector, float *outputVector, size_t numberOfElementsToProcess);
+void linearToDecibels(
+    const float *inputVector,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 } // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,12 +1,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
+#include <algorithm>
 
 namespace audioapi::dsp {
 
-void WindowFunction::forcePerfectReconstruction(
-    float *data,
-    int windowLength,
-    int interval) {
+void WindowFunction::forcePerfectReconstruction(float *data, int windowLength, int interval) {
   for (int i = 0; i < interval; ++i) {
     float sum2 = 0;
 
@@ -58,14 +56,11 @@ float Kaiser::bandwidthToBeta(float bandwidth, bool heuristicOptimal) {
 }
 
 void ApproximateConfinedGaussian::apply(float *data, int size) const {
-  auto offsetScale =
-      getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
+  auto offsetScale = getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
   auto norm = 1 / (getGaussian(1.0f) - 2 * offsetScale * getGaussian(2.0f));
   for (int i = 0; i < size; ++i) {
     auto r = static_cast<float>(2 * i + 1) / static_cast<float>(size) - 1.0f;
-    data[i] = norm *
-        (getGaussian(r) -
-         offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
+    data[i] = norm * (getGaussian(r) - offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
   }
 }
 

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cmath>
-#include <algorithm>
 
 namespace audioapi::dsp {
 
@@ -9,7 +8,7 @@ namespace audioapi::dsp {
 // https://personalpages.hs-kempten.de/~vollratj/InEl/pdf/Window%20function%20-%20Wikipedia.pdf
 class WindowFunction {
  public:
-  explicit WindowFunction(float amplitude = 1.0f): amplitude_(amplitude) {}
+  explicit WindowFunction(float amplitude = 1.0f) : amplitude_(amplitude) {}
 
   virtual void apply(float *data, int size) const = 0;
   // forces STFT perfect-reconstruction (WOLA) on an existing window, for a given STFT interval.
@@ -23,29 +22,30 @@ class WindowFunction {
 //https://en.wikipedia.org/wiki/Hann_function
 // https://www.sciencedirect.com/topics/engineering/hanning-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.hann.html#scipy.signal.windows.hann
-class Hann: public WindowFunction {
+class Hann : public WindowFunction {
  public:
-  explicit Hann(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Hann(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
 // https://www.sciencedirect.com/topics/engineering/blackman-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.blackman.html#scipy.signal.windows.blackman
-class Blackman: public WindowFunction {
+class Blackman : public WindowFunction {
  public:
-  explicit Blackman(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Blackman(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
-
 // https://en.wikipedia.org/wiki/Kaiser_window
-class Kaiser: public WindowFunction {
+class Kaiser : public WindowFunction {
  public:
-  explicit Kaiser(float beta, float amplitude = 1.0f): WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
+  explicit Kaiser(float beta, float amplitude = 1.0f)
+      : WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
 
-  static Kaiser withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
+  static Kaiser
+  withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
     return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal), amplitude);
   }
 
@@ -59,25 +59,26 @@ class Kaiser: public WindowFunction {
 
   // https://en.wikipedia.org/wiki/Bessel_function#Modified_Bessel_functions:_I%CE%B1,_K%CE%B1
   static inline float bessel0(float x) {
-      const double significanceLimit = 1e-4;
-      auto result = 0.0f;
-      auto term = 1.0f;
-      auto m = 1.0f;
-      while (term > significanceLimit) {
-          result += term;
-          ++m;
-          term *= (x * x) / (4 * m * m);
-      }
-
-      return result;
+    const double significanceLimit = 1e-4;
+    auto result = 0.0f;
+    auto term = 1.0f;
+    auto m = 1.0f;
+    while (term > significanceLimit) {
+      result += term;
+      ++m;
+      term *= (x * x) / (4 * m * m);
+    }
+
+    return result;
   }
   static float bandwidthToBeta(float bandwidth, bool heuristicOptimal = false);
 };
 
 // https://www.recordingblogs.com/wiki/gaussian-window
-class ApproximateConfinedGaussian: public WindowFunction {
+class ApproximateConfinedGaussian : public WindowFunction {
  public:
-  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f): WindowFunction(amplitude), gaussianFactor_(0.0625f/(sigma*sigma)) {}
+  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f)
+      : WindowFunction(amplitude), gaussianFactor_(0.0625f / (sigma * sigma)) {}
 
   static ApproximateConfinedGaussian withBandwidth(float bandwidth, float amplitude = 1.0f) {
     return ApproximateConfinedGaussian(bandwidthToSigma(bandwidth), amplitude);