react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,82 +1,36 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
-#include <audioapi/utils/CircularOverflowableAudioArray.h>
-
-namespace audioapi {
-
-AudioRecorder::AudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  constexpr int minRingBufferSize = 8192;
-  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-  isRunning_.store(false);
-}
-
-void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
-  onAudioReadyCallbackId_ = callbackId;
-}
-
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject =
-      std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  std::unordered_map<std::string, EventValue> body = {};
-  body.insert({"buffer", audioBufferHostObject});
-  body.insert({"numFrames", numFrames});
-
-  if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", onAudioReadyCallbackId_, body);
-  }
-}
-
-void AudioRecorder::sendRemainingData() {
-  auto bus = std::make_shared<AudioBus>(
-      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  auto *outputChannel = bus->getChannel(0)->getData();
-  auto availableFrames =
-      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
-
-  circularBuffer_->pop_front(
-      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
-
-  invokeOnAudioReadyCallback(bus, availableFrames);
-}
-
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  node->init(ringBufferSize_);
-  adapterNodeLock_.lock();
-  adapterNode_ = node;
-  adapterNodeLock_.unlock();
-}
-
-void AudioRecorder::disconnect() {
-  adapterNodeLock_.lock();
-  adapterNode_ = nullptr;
-  adapterNodeLock_.unlock();
-}
-
-void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-  if (adapterNodeLock_.try_lock()) {
-    if (adapterNode_ != nullptr) {
-      adapterNode_->buff_->write(data, numFrames);
-    }
-    adapterNodeLock_.unlock();
-  }
-  circularBuffer_->push_back(data, numFrames);
-}
-
-} // namespace audioapi
+// void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
+// { node->init(); adapterNodeLock_.lock(); adapterNode_ = node;
+// adapterNodeLock_.unlock();
+// isConnected_.store(true);
+//   node->init(ringBufferSize_);
+//   adapterNodeLock_.lock();
+//   adapterNode_ = node;
+//   adapterNodeLock_.unlock();
+// }
+
+// void AudioRecorder::disconnect() {
+// adapterNodeLock_.lock();
+// adapterNode_ = nullptr;
+// adapterNodeLock_.unlock();
+// isConnected_.store(false);
+// }
+
+// AudioRecorder::AudioRecorder(
+//     const std::shared_ptr<AudioEventHandlerRegistry>
+//     &audioEventHandlerRegistry)
+//       audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+//   constexpr int minRingBufferSize = 8192;
+//   ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
+
+//   circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
+//   state_.store(RecorderState::Idle);
+// }
+
+// void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
+//   if (adapterNodeLock_.try_lock()) {
+//     if (adapterNode_ != nullptr) {
+//       adapterNode_->buff_->write(data, numFrames);
+//     }
+//     adapterNodeLock_.unlock();
+//   }
+// }

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -3,61 +3,82 @@
 #include <memory>
 #include <atomic>
 #include <mutex>
+#include <string>
+#include <tuple>
 
 namespace audioapi {
 
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;
-class CircularOverflowableAudioArray;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(
+  enum RecorderState { Idle, Recording, Paused };
+  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry):
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
+  virtual ~AudioRecorder() = default;
+
+  virtual std::string start() = 0;
+  virtual std::tuple<std::string, double, double> stop() = 0;
+
+  virtual void enableFileOutput(
     float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
-  );
+    size_t channelCount,
+    size_t bitRate,
+    size_t iosFlags,
+    size_t androidFlags) = 0;
+  virtual void disableFileOutput() = 0;
 
-  virtual ~AudioRecorder() = default;
+  virtual void pause() = 0;
+  virtual void resume() = 0;
+
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) {}
+  void disconnect() {}
 
-  void setOnAudioReadyCallbackId(uint64_t callbackId);
-  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
+  virtual void setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
+
+  virtual double getCurrentDuration() const = 0;
+
+  bool usesCallback() const {
+    return callbackOutputEnabled_.load();
+  }
 
-  /// @brief
-  /// # Connects the recorder to the adapter node.
-  ///
-  /// The adapter node will be used to read audio data from the recorder.
-  /// @note Few frames of audio might not yet be written to the buffer when connecting.
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
+  bool usesFileOutput() const {
+    return fileOutputEnabled_.load();
+  }
 
-  /// @brief
-  /// # Disconnects the recorder from the adapter node.
-  ///
-  /// The adapter node will no longer be used to read audio data from the recorder.
-  /// @note Last few frames of audio might be written to the buffer after disconnecting.
-  void disconnect();
+  bool isConnected() const {
+    return isConnected_.load();
+  }
 
-  virtual void start() = 0;
-  virtual void stop() = 0;
+  bool isRecording() const {
+    return state_.load() == RecorderState::Recording;
+  }
+
+  bool isPaused() const {
+    return state_.load() == RecorderState::Paused;
+  }
 
  protected:
-  float sampleRate_;
-  int bufferLength_;
-  size_t ringBufferSize_;
+  // size_t ringBufferSize_;
 
-  std::atomic<bool> isRunning_;
-  std::shared_ptr<CircularAudioArray> circularBuffer_;
+  std::atomic<RecorderState> state_{ RecorderState::Idle };
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
+  std::atomic<bool> isConnected_{false};
+  // std::shared_ptr<CircularAudioArray> circularBuffer_;
 
   mutable std::mutex adapterNodeLock_;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
 
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
-
-  void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi

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

@@ -25,12 +25,14 @@ StreamerNode::StreamerNode(BaseAudioContext *context)
       codecpar_(nullptr),
       pkt_(nullptr),
       frame_(nullptr),
+      pendingFrame_(nullptr),
       bufferedBus_(nullptr),
+      bufferedBusIndex_(0),
+      maxBufferSize_(0),
       audio_stream_index_(-1),
       swrCtx_(nullptr),
       resampledData_(nullptr),
-      maxResampledSamples_(0),
-      processedSamples_(0) {}
+      maxResampledSamples_(0) {}
 
 StreamerNode::~StreamerNode() {
   cleanup();
@@ -64,30 +66,24 @@ bool StreamerNode::initialize(const std::string &input_url) {
     return false;
   }
 
+  maxBufferSize_ = BUFFER_LENGTH_SECONDS * codecCtx_->sample_rate;
+  // If decoding is faster than playing, we buffer few seconds of audio
+  bufferedBus_ = std::make_shared<AudioBus>(
+      maxBufferSize_, codecpar_->ch_layout.nb_channels, codecCtx_->sample_rate);
+
   channelCount_ = codecpar_->ch_layout.nb_channels;
   audioBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
 
-  auto [sender, receiver] = channels::spsc::channel<
-      StreamingData,
-      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
-      channels::spsc::WaitStrategy::ATOMIC_WAIT>(CHANNEL_CAPACITY);
-  sender_ = std::move(sender);
-  receiver_ = std::move(receiver);
-
   streamingThread_ = std::thread(&StreamerNode::streamAudio, this);
-  streamFlag.store(true, std::memory_order_release);
+  streamFlag.store(true);
   isInitialized_ = true;
   return true;
 }
 
 void StreamerNode::stop(double when) {
   AudioScheduledSourceNode::stop(when);
-  streamFlag.store(false, std::memory_order_release);
-  StreamingData dummy;
-  while (receiver_.try_receive(dummy) ==
-         channels::spsc::ResponseStatus::SUCCESS)
-    ; // clear the receiver
+  streamFlag.store(false);
 }
 
 bool StreamerNode::setupResampler() {
@@ -126,22 +122,29 @@ bool StreamerNode::setupResampler() {
 }
 
 void StreamerNode::streamAudio() {
-  while (streamFlag.load(std::memory_order_acquire)) {
-    if (av_read_frame(fmtCtx_, pkt_) < 0) {
-      return;
-    }
-    if (pkt_->stream_index == audio_stream_index_) {
-      if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
+  while (streamFlag.load()) {
+    if (pendingFrame_ != nullptr) {
+      if (!processFrameWithResampler(pendingFrame_)) {
         return;
       }
-      if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
+    } else {
+      if (av_read_frame(fmtCtx_, pkt_) < 0) {
         return;
       }
-      if (!processFrameWithResampler(frame_)) {
-        return;
+      if (pkt_->stream_index == audio_stream_index_) {
+        if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
+          return;
+        }
+        if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
+          return;
+        }
+        if (!processFrameWithResampler(frame_)) {
+          return;
+        }
       }
+      av_packet_unref(pkt_);
     }
-    av_packet_unref(pkt_);
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
 }
 
@@ -157,33 +160,28 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
     return processingBus;
   }
 
-  int bufferRemaining = bufferedBusSize_ - processedSamples_;
-  int alreadyProcessed = 0;
-  if (bufferRemaining < framesToProcess) {
-    if (bufferedBus_ != nullptr) {
-      for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
-        memcpy(
-            processingBus->getChannel(ch)->getData(),
-            bufferedBus_->getChannel(ch)->getData() + processedSamples_,
-            bufferRemaining * sizeof(float));
-      }
-      framesToProcess -= bufferRemaining;
-      alreadyProcessed += bufferRemaining;
-    }
-    StreamingData data;
-    receiver_.try_receive(data);
-    bufferedBus_ = std::make_shared<AudioBus>(std::move(data.bus));
-    bufferedBusSize_ = data.size;
-    processedSamples_ = 0;
-  }
-  if (bufferedBus_ != nullptr) {
+  // If we have enough buffered data, copy to output bus
+  if (bufferedBusIndex_ >= framesToProcess) {
+    Locker locker(mutex_);
     for (int ch = 0; ch < processingBus->getNumberOfChannels(); ch++) {
       memcpy(
-          processingBus->getChannel(ch)->getData() + alreadyProcessed,
-          bufferedBus_->getChannel(ch)->getData() + processedSamples_,
-          framesToProcess * sizeof(float));
+          processingBus->getChannel(ch)->getData(),
+          bufferedBus_->getChannel(ch)->getData(),
+          offsetLength * sizeof(float));
+
+      memmove(
+          bufferedBus_->getChannel(ch)->getData(),
+          bufferedBus_->getChannel(ch)->getData() + offsetLength,
+          (maxBufferSize_ - offsetLength) * sizeof(float));
     }
-    processedSamples_ += framesToProcess;
+    bufferedBusIndex_ -= offsetLength;
+  } else {
+    if (VERBOSE)
+      printf(
+          "Buffer underrun: have %zu, need %zu\n",
+          bufferedBusIndex_,
+          (size_t)framesToProcess);
+    processingBus->zero();
   }
 
   return processingBus;
@@ -222,21 +220,22 @@ bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
     return false;
   }
 
-  // if we would like to finish dont copy anything
-  if (!streamFlag.load(std::memory_order_acquire)) {
+  // Check if converted data fits in buffer
+  if (bufferedBusIndex_ + converted_samples > maxBufferSize_) {
+    pendingFrame_ = frame;
     return true;
+  } else {
+    pendingFrame_ = nullptr;
   }
-  auto bus = AudioBus(
-      static_cast<size_t>(converted_samples),
-      codecCtx_->ch_layout.nb_channels,
-      context_->getSampleRate());
+
+  // Copy converted data to our buffer
+  Locker locker(mutex_);
   for (int ch = 0; ch < codecCtx_->ch_layout.nb_channels; ch++) {
     auto *src = reinterpret_cast<float *>(resampledData_[ch]);
-    float *dst = bus.getChannel(ch)->getData();
+    float *dst = bufferedBus_->getChannel(ch)->getData() + bufferedBusIndex_;
     memcpy(dst, src, converted_samples * sizeof(float));
   }
-  StreamingData data{std::move(bus), static_cast<size_t>(converted_samples)};
-  sender_.send(std::move(data));
+  bufferedBusIndex_ += converted_samples;
   return true;
 }
 
@@ -281,7 +280,7 @@ bool StreamerNode::setupDecoder() {
 }
 
 void StreamerNode::cleanup() {
-  streamFlag.store(false, std::memory_order_release);
+  streamFlag.store(false);
   // cleanup cannot be called from the streaming thread so there is no need to
   // check if we are in the same thread
   streamingThread_.join();

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

@@ -11,7 +11,6 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
-#include <audioapi/utils/AudioBus.h>
 
 #ifndef AUDIO_API_TEST_SUITE
 extern "C" {
@@ -28,35 +27,8 @@ extern "C" {
 #include <memory>
 #include <string>
 #include <atomic>
-#include <utility>
-#ifndef AUDIO_API_TEST_SUITE
-#include <audioapi/utils/SpscChannel.hpp>
 
-static constexpr audioapi::channels::spsc::OverflowStrategy STREAMER_NODE_SPSC_OVERFLOW_STRATEGY =
-    audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
-static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_STRATEGY =
-    audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
-#endif
-
-static constexpr bool VERBOSE = false;
-static constexpr int CHANNEL_CAPACITY = 32;
-
-struct StreamingData{
-  audioapi::AudioBus bus;
-  size_t size;
-  StreamingData() = default;
-  StreamingData(audioapi::AudioBus b, size_t s) : bus(b), size(s) {}
-  StreamingData(const StreamingData& data) : bus(data.bus), size(data.size) {}
-  StreamingData(StreamingData&& data) noexcept : bus(std::move(data.bus)), size(data.size) {}
-  StreamingData& operator=(const StreamingData& data) {
-    if (this == &data) {
-      return *this;
-    }
-    bus = data.bus;
-    size = data.size;
-    return *this;
-  }
-};
+static bool constexpr VERBOSE = false;
 
 namespace audioapi {
 
@@ -84,20 +56,19 @@ class StreamerNode : public AudioScheduledSourceNode {
   AVCodecParameters* codecpar_;
   AVPacket* pkt_;
   AVFrame* frame_; // Frame that is currently being processed
-  SwrContext* swrCtx_;
-  uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
-
+  AVFrame* pendingFrame_; // Frame that is saved if bufferedBus is full
   std::shared_ptr<AudioBus> bufferedBus_; // audio bus for buffering hls frames
-  size_t bufferedBusSize_; // size of currently buffered bus
+  size_t bufferedBusIndex_; // index in the buffered bus where we write the next frame
+  size_t maxBufferSize_; // maximum size of the buffered bus
   int audio_stream_index_; // index of the audio stream channel in the input
+  SwrContext* swrCtx_;
+  uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
   int maxResampledSamples_;
-  size_t processedSamples_;
-
+  std::mutex mutex_;
   std::thread streamingThread_;
   std::atomic<bool> streamFlag; // Flag to control the streaming thread
+  static constexpr float BUFFER_LENGTH_SECONDS = 5.0f; // Length of the buffer in seconds
   static constexpr int INITIAL_MAX_RESAMPLED_SAMPLES = 8192; // Initial size for resampled data
-  channels::spsc::Sender<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> sender_;
-  channels::spsc::Receiver<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> receiver_;
 
   /**
    * @brief Setting up the resampler

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

@@ -1,6 +1,5 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
-#include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
@@ -222,10 +221,6 @@ inline bool AudioNodeManager::nodeCanBeDestructed(
   if constexpr (std::is_base_of_v<AudioScheduledSourceNode, U>) {
     return node.use_count() == 1 &&
         (node->isUnscheduled() || node->isFinished());
-  } else if constexpr (std::is_base_of_v<
-                           ConvolverNode,
-                           U>) { // convolver overrides disabling behavior
-    return node.use_count() == 1 && !node->isEnabled();
   }
   return node.use_count() == 1;
 }

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <numbers>
 #include <cmath>
 #include <limits>
 
@@ -20,7 +19,7 @@ static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::nume
 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>;
+static constexpr float PI = static_cast<float>(M_PI);
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

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

@@ -5,6 +5,16 @@
 #include <string>
 #include <memory>
 
+#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
+#endif
+
 #ifndef RN_AUDIO_API_TEST
   #define RN_AUDIO_API_TEST 0
 #endif

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

@@ -30,4 +30,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/FFT.cpp

@@ -12,4 +12,30 @@ 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

@@ -16,32 +16,8 @@ class FFT {
   explicit FFT(int size);
   ~FFT();
 
-  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_);
-  }
+  void doFFT(float *in, std::vector<std::complex<float>> &out);
+  void doInverseFFT(std::vector<std::complex<float>> &in, float *out);
 
  private:
   int size_;