react-native-audio-api 0.4.12-beta.4 → 0.4.12

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

@@ -2,10 +2,10 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -14,15 +14,18 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       loop_(false),
       loopStart_(0),
       loopEnd_(0),
+      timeStretchType_(TimeStretchType::LINEAR),
       vReadIndex_(0.0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-  alignedBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
-  detuneParam_ = std::make_shared<AudioParam>(0.0, MIN_DETUNE, MAX_DETUNE);
+  detuneParam_ = std::make_shared<AudioParam>(
+      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
   playbackRateParam_ = std::make_shared<AudioParam>(
       1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
 
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
   isInitialized_ = true;
 }
 
@@ -51,6 +54,10 @@ std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
   return buffer_;
 }
 
+std::string AudioBufferSourceNode::getTimeStretchType() const {
+  return toString(timeStretchType_);
+}
+
 void AudioBufferSourceNode::setLoop(bool loop) {
   loop_ = loop;
 }
@@ -69,8 +76,6 @@ void AudioBufferSourceNode::setBuffer(
 
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-    alignedBus_ = std::make_shared<AudioBus>(
-        RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
     loopEnd_ = 0;
     return;
   }
@@ -78,17 +83,18 @@ void AudioBufferSourceNode::setBuffer(
   buffer_ = buffer;
   channelCount_ = buffer_->getNumberOfChannels();
 
-  alignedBus_ = std::make_shared<AudioBus>(
-      buffer_->getLength(), channelCount_, context_->getSampleRate());
-  alignedBus_->zero();
-  alignedBus_->sum(buffer_->bus_.get());
-
   audioBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
 }
 
+void AudioBufferSourceNode::setTimeStretchType(const std::string &type) {
+  timeStretchType_ = fromString(type);
+}
+
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
   AudioScheduledSourceNode::start(when);
 
@@ -117,7 +123,7 @@ void AudioBufferSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // No audio data to fill, zero the output and return.
-  if (!buffer_) {
+  if (!buffer_ || !buffer_->bus_) {
     processingBus->zero();
     return;
   }
@@ -130,26 +136,58 @@ void AudioBufferSourceNode::processNode(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-  float playbackRate = getPlaybackRateValue(startOffset);
+  if (timeStretchType_ == TimeStretchType::LINEAR) {
+    auto computedPlaybackRate = getComputedPlaybackRateValue();
+    updatePlaybackInfo(
+        processingBus, framesToProcess, startOffset, offsetLength);
+
+    if (computedPlaybackRate == 0.0f || !isPlaying()) {
+      processingBus->zero();
+      return;
+    } else if (std::fabs(computedPlaybackRate) == 1.0) {
+      processWithoutInterpolation(
+          processingBus, startOffset, offsetLength, computedPlaybackRate);
+    } else {
+      processWithInterpolation(
+          processingBus, startOffset, offsetLength, computedPlaybackRate);
+    }
+  } else {
+    auto time = context_->getCurrentTime();
+    auto playbackRate =
+        std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
+    auto detune =
+        std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
 
-  assert(alignedBus_ != nullptr);
-  assert(alignedBus_->getSize() > 0);
+    playbackRateBus_->zero();
+
+    auto framesNeededToStretch =
+        static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+
+    updatePlaybackInfo(
+        playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
-  if (playbackRate == 0.0f || !isPlaying()) {
-    processingBus->zero();
-    return;
-  } else if (std::fabs(playbackRate) == 1.0) {
     processWithoutInterpolation(
-        processingBus, startOffset, offsetLength, playbackRate);
-  } else {
-    processWithInterpolation(
-        processingBus, startOffset, offsetLength, playbackRate);
+        playbackRateBus_, startOffset, offsetLength, playbackRate);
+
+    auto stretch = buffer_->stretch_;
+
+    stretch->process(
+        playbackRateBus_.get()[0],
+        framesNeededToStretch,
+        processingBus.get()[0],
+        framesToProcess);
+
+    stretch->setTransposeSemitones(detune);
   }
 
   handleStopScheduled();
 }
 
+double AudioBufferSourceNode::getStopTime() const {
+  return dsp::sampleFrameToTime(
+      static_cast<int>(vReadIndex_), buffer_->getSampleRate());
+}
+
 /**
  * Helper functions
  */
@@ -182,12 +220,12 @@ void AudioBufferSourceNode::processWithoutInterpolation(
     // Direction is forward, we can normally copy the data
     if (direction == 1) {
       processingBus->copy(
-          alignedBus_.get(), readIndex, writeIndex, framesToCopy);
+          buffer_->bus_.get(), readIndex, writeIndex, framesToCopy);
     } else {
       for (int i = 0; i < framesToCopy; i += 1) {
         for (int j = 0; j < processingBus->getNumberOfChannels(); j += 1) {
           (*processingBus->getChannel(j))[writeIndex + i] =
-              (*alignedBus_->getChannel(j))[readIndex - i];
+              (*buffer_->bus_->getChannel(j))[readIndex - i];
         }
       }
     }
@@ -248,10 +286,10 @@ void AudioBufferSourceNode::processWithInterpolation(
 
     for (int i = 0; i < processingBus->getNumberOfChannels(); i += 1) {
       float *destination = processingBus->getChannel(i)->getData();
-      const float *source = alignedBus_->getChannel(i)->getData();
+      const float *source = buffer_->bus_->getChannel(i)->getData();
 
-      destination[writeIndex] = AudioUtils::linearInterpolate(
-          source, readIndex, nextReadIndex, factor);
+      destination[writeIndex] =
+          dsp::linearInterpolate(source, readIndex, nextReadIndex, factor);
     }
 
     writeIndex += 1;
@@ -271,13 +309,12 @@ void AudioBufferSourceNode::processWithInterpolation(
   }
 }
 
-float AudioBufferSourceNode::getPlaybackRateValue(size_t &startOffset) {
-  auto time = context_->getCurrentTime() +
-      static_cast<double>(startOffset) / context_->getSampleRate();
+float AudioBufferSourceNode::getComputedPlaybackRateValue() {
+  auto time = context_->getCurrentTime();
 
   auto sampleRateFactor = buffer_->getSampleRate() / context_->getSampleRate();
-  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
   auto playbackRate = playbackRateParam_->getValueAtTime(time);
+  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
 
   return playbackRate * sampleRateFactor * detune;
 }
@@ -290,7 +327,7 @@ double AudioBufferSourceNode::getVirtualStartFrame() {
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {
-  auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
+  auto inputBufferLength = static_cast<double>(buffer_->bus_->getSize());
   auto loopEndFrame = loopEnd_ * context_->getSampleRate();
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_

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

@@ -2,11 +2,12 @@
 
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/types/TimeStretchType.h>
 
 #include <memory>
 #include <cstddef>
 #include <algorithm>
-#include <cassert>
+#include <string>
 
 namespace audioapi {
 
@@ -22,41 +23,68 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] double getLoopEnd() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getSemitonesParam() const;
   [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const;
+  [[nodiscard]] std::string getTimeStretchType() const;
 
   void setLoop(bool loop);
   void setLoopStart(double loopStart);
   void setLoopEnd(double loopEnd);
   void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+  void setTimeStretchType(const std::string &type);
 
   void start(double when, double offset, double duration = -1);
 
  protected:
   std::mutex &getBufferLock();
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  double getStopTime() const override;
 
  private:
+  static TimeStretchType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(
+        lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "linear")
+      return TimeStretchType::LINEAR;
+    if (lowerType == "speech-music")
+        return TimeStretchType::SPEECH_MUSIC;
+
+    throw std::invalid_argument("Unknown time stretch type: " + type);
+  }
+
+  static std::string toString(TimeStretchType type) {
+    switch (type) {
+      case TimeStretchType::LINEAR:
+        return "linear";
+      case TimeStretchType::SPEECH_MUSIC:
+        return "speech-music";
+    }
+
+    throw std::invalid_argument("Unknown time stretch type");
+  }
+
   // Looping related properties
   bool loop_;
   double loopStart_;
   double loopEnd_;
   std::mutex bufferLock_;
 
-  // playback rate aka pitch change params
+  // time-stretching and pitch-shifting
+  TimeStretchType timeStretchType_;
+
+  // k-rate params
   std::shared_ptr<AudioParam> detuneParam_;
   std::shared_ptr<AudioParam> playbackRateParam_;
 
+  std::shared_ptr<AudioBus> playbackRateBus_;
+
   // internal helper
   double vReadIndex_;
 
   // User provided buffer
   std::shared_ptr<AudioBuffer> buffer_;
-  std::shared_ptr<AudioBus> alignedBus_;
-
-  float getPlaybackRateValue(size_t &startOffset);
-
-  double getVirtualStartFrame();
-  double getVirtualEndFrame();
 
   void processWithoutInterpolation(
       const std::shared_ptr<AudioBus>& processingBus,
@@ -69,6 +97,11 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
       size_t startOffset,
       size_t offsetLength,
       float playbackRate);
+
+  float getComputedPlaybackRateValue();
+
+  double getVirtualStartFrame();
+  double getVirtualEndFrame();
 };
 
 } // namespace audioapi

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

@@ -1,9 +1,9 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -40,6 +40,11 @@ bool AudioScheduledSourceNode::isFinished() {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
+void AudioScheduledSourceNode::setOnendedCallback(
+    const std::function<void(double)> &onendedCallback) {
+  onendedCallback_ = onendedCallback;
+}
+
 void AudioScheduledSourceNode::updatePlaybackInfo(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess,
@@ -58,12 +63,11 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   size_t firstFrame = context_->getCurrentSampleFrame();
   size_t lastFrame = firstFrame + framesToProcess;
 
-  size_t startFrame = std::max(
-      AudioUtils::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t startFrame =
+      std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
-      : std::max(
-            AudioUtils::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+      : std::max(dsp::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
 
   if (isUnscheduled() || isFinished()) {
     startOffset = 0;
@@ -105,6 +109,11 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   if (stopFrame < firstFrame) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
+
+    if (onendedCallback_) {
+      onendedCallback_(getStopTime());
+    }
+
     playbackState_ = PlaybackState::FINISHED;
     disable();
     return;
@@ -117,6 +126,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
 void AudioScheduledSourceNode::handleStopScheduled() {
   if (isPlaying() && stopTime_ > 0 && context_->getCurrentTime() >= stopTime_) {
+    if (onendedCallback_) {
+      onendedCallback_(getStopTime());
+    }
     playbackState_ = PlaybackState::FINISHED;
     disable();
   }

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

@@ -12,6 +12,7 @@
 #include <thread>
 #include <cstddef>
 #include <cassert>
+#include <utility>
 
 namespace audioapi {
 
@@ -28,6 +29,10 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isPlaying();
   bool isFinished();
 
+  void setOnendedCallback(const std::function<void(double)> &onendedCallback);
+
+  virtual double getStopTime() const = 0;
+
  protected:
   PlaybackState playbackState_;
 
@@ -42,6 +47,8 @@ class AudioScheduledSourceNode : public AudioNode {
  private:
   double startTime_;
   double stopTime_;
+
+  std::function<void(double)> onendedCallback_;
 };
 
 } // namespace audioapi

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

@@ -1,7 +1,8 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/OscillatorNode.h>
-#include <audioapi/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -9,7 +10,10 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
       444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency());
-  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
+  detuneParam_ = std::make_shared<AudioParam>(
+      0.0,
+      -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
   isInitialized_ = true;
@@ -81,4 +85,9 @@ void OscillatorNode::processNode(
   handleStopScheduled();
 }
 
+double OscillatorNode::getStopTime() const {
+  return dsp::sampleFrameToTime(
+      static_cast<int>(phase_), context_->getSampleRate());
+}
+
 } // namespace audioapi

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

@@ -25,6 +25,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
 
  protected:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  double getStopTime() const override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;

package/common/cpp/audioapi/core/types/TimeStretchType.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace audioapi {
+
+enum class TimeStretchType { LINEAR, SPEECH_MUSIC };
+
+}

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

@@ -1,6 +1,6 @@
 #include <audioapi/dsp/AudioUtils.h>
 
-namespace audioapi::AudioUtils {
+namespace audioapi::dsp {
 size_t timeToSampleFrame(double time, float sampleRate) {
   return static_cast<size_t>(time * sampleRate);
 }
@@ -30,4 +30,4 @@ float linearToDecibels(float value) {
 float decibelsToLinear(float value) {
   return powf(10, value / 20);
 }
-} // namespace audioapi::AudioUtils
+} // namespace audioapi::dsp

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

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <cmath>
 
-namespace audioapi::AudioUtils {
+namespace audioapi::dsp {
 
 size_t timeToSampleFrame(double time, float sampleRate);
 double sampleFrameToTime(int sampleFrame, float sampleRate);
@@ -13,4 +13,4 @@ float linearInterpolate(const float *source, size_t firstIndex, size_t secondInd
 
 float linearToDecibels(float value);
 float decibelsToLinear(float value);
-} // namespace audioapi::AudioUtils
+} // namespace audioapi::dsp

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

@@ -0,0 +1,41 @@
+#include <audioapi/dsp/FFT.h>
+
+namespace audioapi::dsp {
+
+FFT::FFT(int size) : size_(size) {
+  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
+  work_ = (float *)pffft_aligned_malloc(size_ * sizeof(float));
+}
+
+FFT::~FFT() {
+  pffft_destroy_setup(pffftSetup_);
+  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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/libs/pffft/pffft.h>
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+#include <complex>
+#include <vector>
+
+namespace audioapi::dsp {
+
+class FFT {
+ public:
+  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);
+
+ private:
+  int size_;
+
+  PFFFT_Setup *pffftSetup_;
+  float *work_;
+};
+
+} // namespace audioapi::dsp

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

@@ -38,7 +38,7 @@
 #include <arm_neon.h>
 #endif
 
-namespace audioapi::VectorMath {
+namespace audioapi::dsp {
 
 #if defined(HAVE_ACCELERATE)
 
@@ -695,7 +695,7 @@ void linearToDecibels(
     float *outputVector,
     size_t numberOfElementsToProcess) {
   for (int i = 0; i < numberOfElementsToProcess; i++) {
-    outputVector[i] = AudioUtils::linearToDecibels(inputVector[i]);
+    outputVector[i] = dsp::linearToDecibels(inputVector[i]);
   }
 }
-} // namespace audioapi::VectorMath
+} // namespace audioapi::dsp

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

@@ -32,7 +32,7 @@
 #include <algorithm>
 #include <cmath>
 
-namespace audioapi::VectorMath {
+namespace audioapi::dsp {
 
 void multiplyByScalarThenAddToOutput(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
 
@@ -46,4 +46,4 @@ void multiply(const float *inputVector1, const float *inputVector2, float *outpu
 float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
 
 void linearToDecibels(const float *inputVector, float *outputVector, size_t numberOfElementsToProcess);
-} // namespace audioapi::VectorMath
+} // namespace audioapi::dsp

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

@@ -0,0 +1,80 @@
+#include <audioapi/core/Constants.h>
+#include <audioapi/dsp/Windows.h>
+
+namespace audioapi::dsp {
+
+void WindowFunction::forcePerfectReconstruction(
+    float *data,
+    int windowLength,
+    int interval) {
+  for (int i = 0; i < interval; ++i) {
+    float sum2 = 0;
+
+    for (int index = i; index < windowLength; index += interval) {
+      sum2 += data[index] * data[index];
+    }
+
+    float factor = 1 / std::sqrt(sum2);
+
+    for (int index = i; index < windowLength; index += interval) {
+      data[index] *= factor;
+    }
+  }
+}
+
+void Hann::apply(float *data, int size) const {
+  for (int i = 0; i < size; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(size - 1);
+    auto window = 0.5f - 0.5f * cos(2 * PI * x);
+    data[i] = window * amplitude_;
+  }
+}
+
+void Blackman::apply(float *data, int size) const {
+  for (int i = 0; i < size; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(size - 1);
+    auto window = 0.42f - 0.5f * cos(2 * PI * x) + 0.08f * cos(4 * PI * x);
+    data[i] = window * amplitude_;
+  }
+}
+
+void Kaiser::apply(float *data, int size) const {
+  for (int i = 0; i < size; ++i) {
+    auto r = static_cast<float>(2 * i + 1) / static_cast<float>(size) - 1.0f;
+    auto arg = std::sqrt(1 - r * r);
+    data[i] = bessel0(beta_ * arg) * invB0_ * amplitude_;
+  }
+}
+
+float Kaiser::bandwidthToBeta(float bandwidth, bool heuristicOptimal) {
+  if (heuristicOptimal) { // Heuristic based on numerical search
+    return bandwidth + 8.0f / (bandwidth + 3.0f) * (bandwidth + 3.0f) +
+        0.25f * std::max(3.0f - bandwidth, 0.0f);
+  }
+
+  bandwidth = std::max(bandwidth, 2.0f);
+  auto alpha = std::sqrt(bandwidth * bandwidth * 0.25f - 1.0f);
+  return alpha * PI;
+}
+
+void ApproximateConfinedGaussian::apply(float *data, int size) const {
+  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)));
+  }
+}
+
+float ApproximateConfinedGaussian::bandwidthToSigma(float bandwidth) {
+  return 0.3f / std::sqrt(bandwidth);
+}
+
+float ApproximateConfinedGaussian::getGaussian(float x) const {
+  return std::exp(-x * x * gaussianFactor_);
+}
+
+} // namespace audioapi::dsp