react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

package/common/cpp/audioapi/core/utils/AudioStretcher.cpp

@@ -5,6 +5,8 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <cstdint>
+#include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -43,8 +45,8 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       outputChannels,
       0x1);
 
-  int maxOutputFrames = stretch_output_capacity(
-      stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
+  int maxOutputFrames =
+      stretch_output_capacity(stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
   std::vector<int16_t> stretchedBuffer(maxOutputFrames * outputChannels);
 
   int outputFrames = stretch_samples(
@@ -54,13 +56,11 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       stretchedBuffer.data(),
       1 / playbackSpeed);
 
-  outputFrames +=
-      stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+  outputFrames += stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
   stretchedBuffer.resize(outputFrames * outputChannels);
   stretch_deinit(stretcher);
 
-  auto audioBus =
-      std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
+  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();

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

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <numbers>
 #include <cmath>
 #include <limits>
+#include <numbers>
 
 // https://webaudio.github.io/web-audio-api/
 
@@ -16,8 +16,10 @@ static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;
 static constexpr float LOWER_FREQUENCY_LIMIT_DETECTION = 55.0f;
 
 // general
-static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
-static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
+static constexpr float MOST_POSITIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::max());
+static constexpr float MOST_NEGATIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 static constexpr float PI = std::numbers::pi_v<float>;

package/common/cpp/audioapi/core/utils/ParamChangeEvent.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/utils/ParamChangeEvent.h>
+#include <utility>
 
 namespace audioapi {
 

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

@@ -20,16 +20,16 @@ class ParamChangeEvent {
       ParamChangeEventType type);
 
   ParamChangeEvent(const ParamChangeEvent &other) = delete;
-  ParamChangeEvent& operator=(const ParamChangeEvent &other) = delete;
+  ParamChangeEvent &operator=(const ParamChangeEvent &other) = delete;
 
   explicit ParamChangeEvent(ParamChangeEvent &&other) noexcept
-    : startTime_(other.startTime_),
-      endTime_(other.endTime_),
-      calculateValue_(std::move(other.calculateValue_)),
-      startValue_(other.startValue_),
-      endValue_(other.endValue_),
-      type_(other.type_) {}
-  ParamChangeEvent& operator=(ParamChangeEvent &&other) noexcept {
+      : startTime_(other.startTime_),
+        endTime_(other.endTime_),
+        calculateValue_(std::move(other.calculateValue_)),
+        startValue_(other.startValue_),
+        endValue_(other.endValue_),
+        type_(other.type_) {}
+  ParamChangeEvent &operator=(ParamChangeEvent &&other) noexcept {
     if (this != &other) {
       startTime_ = other.startTime_;
       endTime_ = other.endTime_;
@@ -53,7 +53,7 @@ class ParamChangeEvent {
   [[nodiscard]] inline float getStartValue() const noexcept {
     return startValue_;
   }
-  [[nodiscard]] inline const std::function<float(double, double, float, float, double)>&
+  [[nodiscard]] inline const std::function<float(double, double, float, float, double)> &
   getCalculateValue() const noexcept {
     return calculateValue_;
   }

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

@@ -2,28 +2,28 @@
 
 #include <jsi/jsi.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
 #if ANDROID
-  #include <fbjni/detail/Environment.h>
+#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
@@ -36,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
   }
 };
@@ -74,12 +70,11 @@ struct RuntimeRegistry {
   std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
 
 #if ANDROID
-    ~RuntimeRegistry() {
-        facebook::jni::ThreadScope::WithClassLoader(
-            [this]() {
-                uiRuntime.reset();
-                audioRuntime.reset();
-            });
-    }
+  ~RuntimeRegistry() {
+    facebook::jni::ThreadScope::WithClassLoader([this]() {
+      uiRuntime.reset();
+      audioRuntime.reset();
+    });
+  }
 #endif
 };

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

@@ -1,4 +1,6 @@
 #include <audioapi/core/utils/worklets/WorkletsRunner.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -6,23 +8,21 @@ WorkletsRunner::WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
     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;
@@ -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,
-    const 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) {

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

@@ -9,8 +9,10 @@
 #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 {
 
@@ -41,10 +43,7 @@ void Convolver::reset() {
   _inputBuffer.zero();
 }
 
-bool Convolver::init(
-    size_t blockSize,
-    const audioapi::AudioArray &ir,
-    size_t irLen) {
+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))) {
@@ -54,7 +53,8 @@ bool Convolver::init(
   // Ignore zeros at the end of the impulse response because they only waste
   // computation time
   _blockSize = blockSize;
-  _trueSegmentCount = (size_t)(std::ceil((float)irLen / (float)_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;
   }
@@ -64,12 +64,13 @@ bool Convolver::init(
   }
 
   // The length-N is split into P = N/B length-B sub filters
-  _segCount = (size_t)(std::ceil((float)irLen / (float)_blockSize));
+  _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>((int)_segSize);
+  _fft = std::make_shared<dsp::FFT>(static_cast<int>(_segSize));
   _fftBuffer.resize(_segSize);
 
   // segments preparation
@@ -85,10 +86,7 @@ bool Convolver::init(
     const size_t samplesToCopy = std::min(_blockSize, remainingSamples);
 
     if (samplesToCopy > 0) {
-      memcpy(
-          _fftBuffer.getData(),
-          ir.getData() + i * _blockSize,
-          samplesToCopy * sizeof(float));
+      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.
@@ -171,10 +169,7 @@ 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));
+  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.
@@ -188,26 +183,19 @@ void Convolver::process(float *data, float *outputData) {
 
   // 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>));
+  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);
+    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));
+  memcpy(outputData, _fftBuffer.getData() + _blockSize, _blockSize * sizeof(float));
 }
 } // namespace audioapi

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

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <audioapi/utils/AudioArray.h>
 #include <audioapi/dsp/FFT.h>
-#include <vector>
-#include <cstring>
+#include <audioapi/utils/AlignedAllocator.hpp>
+#include <audioapi/utils/AudioArray.h>
 #include <complex>
+#include <cstring>
 #include <memory>
-#include <audioapi/utils/AlignedAllocator.hpp>
+#include <vector>
 
 namespace audioapi {
 
@@ -17,29 +17,31 @@ class Convolver {
       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; }
+  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;
+  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);
+      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() {

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,14 +16,10 @@ class FFT {
   explicit FFT(int size);
   ~FFT();
 
-  template<typename Allocator>
+  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);
+        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
@@ -31,14 +27,10 @@ class FFT {
     // out[0].imag = Nyquist component - should be pure real
   }
 
-  template<typename Allocator>
+  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);
+        pffftSetup_, reinterpret_cast<float *>(&in[0]), out, work_, PFFFT_BACKWARD);
 
     dsp::multiplyByScalar(out, 1.0f / static_cast<float>(size_), out, size_);
   }