react-native-audio-api 0.4.13 → 0.4.14

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -1,18 +1,17 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
-#include <audioapi/dsp/Windows.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
     : AudioNode(context),
-      fftSize_(2048),
-      minDecibels_(-100),
-      maxDecibels_(-30),
-      smoothingTimeConstant_(0.8),
+      fftSize_(DEFAULT_FFT_SIZE),
+      minDecibels_(DEFAULT_MIN_DECIBELS),
+      maxDecibels_(DEFAULT_MAX_DECIBELS),
+      smoothingTimeConstant_(DEFAULT_SMOOTHING_TIME_CONSTANT),
       windowType_(WindowType::BLACKMAN),
       vWriteIndex_(0) {
   inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
@@ -20,10 +19,9 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
   downMixBus_ = std::make_unique<AudioBus>(
       RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
-  fft_ = std::make_unique<dsp::FFT>(fftSize_);
-  complexData_ = std::vector<std::complex<float>>(fftSize_);
-
-  setWindowData(windowType_, fftSize_);
+  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
 
   isInitialized_ = true;
 }
@@ -58,10 +56,10 @@ void AnalyserNode::setFftSize(int fftSize) {
   }
 
   fftSize_ = fftSize;
-  fft_ = std::make_unique<dsp::FFT>(fftSize_);
-  complexData_ = std::vector<std::complex<float>>(fftSize_);
+  fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
+  realData_ = std::make_shared<AudioArray>(fftSize_);
+  imaginaryData_ = std::make_shared<AudioArray>(fftSize_);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
-  setWindowData(windowType_, fftSize_);
 }
 
 void AnalyserNode::setMinDecibels(float minDecibels) {
@@ -77,7 +75,6 @@ void AnalyserNode::setSmoothingTimeConstant(float smoothingTimeConstant) {
 }
 
 void AnalyserNode::setWindowType(const std::string &type) {
-  setWindowData(windowType_, fftSize_);
   windowType_ = AnalyserNode::fromString(type);
 }
 
@@ -85,7 +82,7 @@ void AnalyserNode::getFloatFrequencyData(float *data, int length) {
   doFFTAnalysis();
 
   length = std::min(static_cast<int>(magnitudeBuffer_->getSize()), length);
-  dsp::linearToDecibels(magnitudeBuffer_->getData(), data, length);
+  VectorMath::linearToDecibels(magnitudeBuffer_->getData(), data, length);
 }
 
 void AnalyserNode::getByteFrequencyData(uint8_t *data, int length) {
@@ -100,7 +97,7 @@ void AnalyserNode::getByteFrequencyData(uint8_t *data, int length) {
   for (int i = 0; i < length; i++) {
     auto dbMag = magnitudeBufferData[i] == 0
         ? minDecibels_
-        : dsp::linearToDecibels(magnitudeBufferData[i]);
+        : AudioUtils::linearToDecibels(magnitudeBufferData[i]);
     auto scaledValue = UINT8_MAX * (dbMag - minDecibels_) * rangeScaleFactor;
 
     if (scaledValue < 0) {
@@ -205,49 +202,55 @@ void AnalyserNode::doFFTAnalysis() {
     tempBuffer.copy(inputBuffer_.get(), vWriteIndex_ - fftSize_, 0, fftSize_);
   }
 
-  dsp::multiply(
-      tempBuffer.getData(),
-      windowData_->getData(),
-      tempBuffer.getData(),
-      fftSize_);
+  switch (windowType_) {
+    case WindowType::BLACKMAN:
+      AnalyserNode::applyBlackManWindow(tempBuffer.getData(), fftSize_);
+      break;
+    case WindowType::HANN:
+      AnalyserNode::applyHannWindow(tempBuffer.getData(), fftSize_);
+      break;
+  }
+
+  auto *realFFTFrameData = realData_->getData();
+  auto *imaginaryFFTFrameData = imaginaryData_->getData();
 
   // do fft analysis - get frequency domain data
-  fft_->doFFT(tempBuffer.getData(), complexData_);
+  fftFrame_->doFFT(
+      tempBuffer.getData(), realFFTFrameData, imaginaryFFTFrameData);
 
   // Zero out nquist component
-  complexData_[0] = std::complex<float>(complexData_[0].real(), 0);
+  imaginaryFFTFrameData[0] = 0.0f;
 
   const float magnitudeScale = 1.0f / static_cast<float>(fftSize_);
   auto magnitudeBufferData = magnitudeBuffer_->getData();
 
   for (int i = 0; i < magnitudeBuffer_->getSize(); i++) {
-    auto scalarMagnitude = std::abs(complexData_[i]) * magnitudeScale;
+    std::complex<float> c(realFFTFrameData[i], imaginaryFFTFrameData[i]);
+    auto scalarMagnitude = std::abs(c) * magnitudeScale;
     magnitudeBufferData[i] = static_cast<float>(
         smoothingTimeConstant_ * magnitudeBufferData[i] +
         (1 - smoothingTimeConstant_) * scalarMagnitude);
   }
 }
 
-void AnalyserNode::setWindowData(
-    audioapi::AnalyserNode::WindowType type,
-    int size) {
-  if (windowType_ == type && windowData_ && windowData_->getSize() == size) {
-    return;
-  }
+void AnalyserNode::applyBlackManWindow(float *data, int length) {
+  // 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
 
-  if (!windowData_ || windowData_->getSize() != size) {
-    windowData_ = std::make_shared<AudioArray>(size);
+  for (int i = 0; i < length; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(length);
+    auto window = 0.42f - 0.5f * cos(2 * PI * x) + 0.08f * cos(4 * PI * x);
+    data[i] *= window;
   }
+}
 
-  switch (windowType_) {
-    case WindowType::BLACKMAN:
-      dsp::Blackman().apply(
-          windowData_->getData(), static_cast<int>(windowData_->getSize()));
-      break;
-    case WindowType::HANN:
-      dsp::Hann().apply(
-          windowData_->getData(), static_cast<int>(windowData_->getSize()));
-      break;
+void AnalyserNode::applyHannWindow(float *data, int length) {
+  // 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
+  for (int i = 0; i < length; ++i) {
+    auto x = static_cast<float>(i) / static_cast<float>(length - 1);
+    auto window = 0.5f - 0.5f * cos(2 * PI * x);
+    data[i] *= window;
   }
 }
 } // namespace audioapi

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -1,13 +1,12 @@
 #pragma once
 
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/dsp/FFT.h>
+#include <audioapi/dsp/FFTFrame.h>
 
 #include <memory>
 #include <cstddef>
 #include <string>
 #include <complex>
-#include <vector>
 
 namespace audioapi {
 
@@ -45,16 +44,15 @@ class AnalyserNode : public AudioNode {
   float minDecibels_;
   float maxDecibels_;
   float smoothingTimeConstant_;
-
   WindowType windowType_;
-  std::shared_ptr<AudioArray> windowData_;
 
   std::unique_ptr<AudioArray> inputBuffer_;
   std::unique_ptr<AudioBus> downMixBus_;
   int vWriteIndex_;
 
-  std::unique_ptr<dsp::FFT> fft_;
-  std::vector<std::complex<float>> complexData_;
+  std::unique_ptr<FFTFrame> fftFrame_;
+  std::shared_ptr<AudioArray> realData_;
+  std::shared_ptr<AudioArray> imaginaryData_;
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_ { true };
 
@@ -84,8 +82,8 @@ class AnalyserNode : public AudioNode {
   }
 
   void doFFTAnalysis();
-
-  void setWindowData(WindowType type, int size);
+  static void applyBlackManWindow(float *data, int length);
+  static void applyHannWindow(float *data, int length);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp

@@ -1,8 +1,8 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
-#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -1,7 +1,7 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
 // formulas for filters
@@ -10,16 +10,12 @@ namespace audioapi {
 
 BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
     : AudioNode(context) {
-  frequencyParam_ =
-      std::make_shared<AudioParam>(350.0, 0.0f, context->getNyquistFrequency());
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0,
-      -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
-  QParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
-  gainParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, 40 * LOG10_MOST_POSITIVE_SINGLE_FLOAT);
+  frequencyParam_ = std::make_shared<AudioParam>(
+      350.0, MIN_FILTER_FREQUENCY, context->getNyquistFrequency());
+  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
+  QParam_ = std::make_shared<AudioParam>(1.0, MIN_FILTER_Q, MAX_FILTER_Q);
+  gainParam_ =
+      std::make_shared<AudioParam>(0.0, MIN_FILTER_GAIN, MAX_FILTER_GAIN);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
 }

package/common/cpp/audioapi/core/effects/GainNode.cpp

@@ -1,13 +1,12 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 
 namespace audioapi {
 
 GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+  gainParam_ = std::make_shared<AudioParam>(1.0, MIN_GAIN, MAX_GAIN);
   isInitialized_ = true;
 }
 

package/common/cpp/audioapi/core/effects/PeriodicWave.cpp

@@ -28,6 +28,7 @@
 
 #include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/dsp/FFTFrame.h>
 #include <audioapi/dsp/VectorMath.h>
 
 constexpr unsigned NumberOfOctaveBands = 3;
@@ -46,8 +47,6 @@ PeriodicWave::PeriodicWave(float sampleRate, bool disableNormalization)
   scale_ = static_cast<float>(getPeriodicWaveSize()) /
       static_cast<float>(sampleRate_);
   bandLimitedTables_ = new float *[numberOfRanges_];
-
-  fft_ = std::make_unique<dsp::FFT>(getPeriodicWaveSize());
 }
 
 PeriodicWave::PeriodicWave(
@@ -60,18 +59,12 @@ PeriodicWave::PeriodicWave(
 
 PeriodicWave::PeriodicWave(
     float sampleRate,
-    const std::vector<std::complex<float>> &complexData,
+    float *real,
+    float *imaginary,
     int length,
     bool disableNormalization)
     : PeriodicWave(sampleRate, disableNormalization) {
-  createBandLimitedTables(complexData, length);
-}
-
-PeriodicWave::~PeriodicWave() {
-  for (int i = 0; i < numberOfRanges_; i++) {
-    delete[] bandLimitedTables_[i];
-  }
-  delete[] bandLimitedTables_;
+  createBandLimitedTables(real, imaginary, length);
 }
 
 int PeriodicWave::getPeriodicWaveSize() const {
@@ -137,9 +130,15 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
    * real and imaginary can finely shape which harmonic content is retained or
    * discarded.
    */
-
   auto halfSize = fftSize / 2;
-  auto complexData = std::vector<std::complex<float>>(halfSize);
+
+  auto *real = new float[halfSize];
+  auto *imaginary = new float[halfSize];
+
+  // Reset Direct Current (DC) component. First element of frequency domain
+  // representation - c0. https://math24.net/complex-form-fourier-series.html
+  real[0] = 0.0f;
+  imaginary[0] = 0.0f;
 
   for (int i = 1; i < halfSize; i++) {
     // All waveforms are odd functions with a positive slope at time 0.
@@ -181,14 +180,16 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
         throw std::invalid_argument("Custom waveforms are not supported.");
     }
 
-    complexData[i] = std::complex<float>(0.0f, b);
+    real[i] = 0.0f;
+    imaginary[i] = b;
   }
 
-  createBandLimitedTables(complexData, halfSize);
+  createBandLimitedTables(real, imaginary, halfSize);
 }
 
 void PeriodicWave::createBandLimitedTables(
-    const std::vector<std::complex<float>> &complexData,
+    const float *realData,
+    const float *imaginaryData,
     int size) {
   float normalizationFactor = 0.5f;
 
@@ -198,7 +199,19 @@ void PeriodicWave::createBandLimitedTables(
   size = std::min(size, halfSize);
 
   for (int rangeIndex = 0; rangeIndex < numberOfRanges_; rangeIndex++) {
-    auto complexFFTData = std::vector<std::complex<float>>(halfSize);
+    FFTFrame fftFrame(fftSize);
+
+    auto *realFFTFrameData = new float[fftSize];
+    auto *imaginaryFFTFrameData = new float[fftSize];
+
+    // copy real and imaginary data to the FFT frame and scale it
+    VectorMath::multiplyByScalar(
+        realData, static_cast<float>(fftSize), realFFTFrameData, size);
+    VectorMath::multiplyByScalar(
+        imaginaryData,
+        -static_cast<float>(fftSize),
+        imaginaryFFTFrameData,
+        size);
 
     // Find the starting partial where we should start culling.
     // We need to clear out the highest frequencies to band-limit the waveform.
@@ -206,37 +219,41 @@ void PeriodicWave::createBandLimitedTables(
 
     // Clamp the size to the number of partials.
     auto clampedSize = std::min(size, numberOfPartials);
-
-    // copy real and imaginary data to the FFT frame, scale it and set the
-    // higher frequencies to zero.
-    for (int i = 0; i < size; i++) {
-      if (i >= clampedSize && i < halfSize) {
-        complexFFTData[i] = std::complex<float>(0.0f, 0.0f);
-      } else {
-        complexFFTData[i] = {
-            complexData[i].real() * static_cast<float>(fftSize),
-            complexData[i].imag() * -static_cast<float>(fftSize)};
-      }
+    if (clampedSize < halfSize) {
+      // Zero out the higher frequencies for certain range.
+      std::fill(
+          realFFTFrameData + clampedSize, realFFTFrameData + halfSize, 0.0f);
+      std::fill(
+          imaginaryFFTFrameData + clampedSize,
+          imaginaryFFTFrameData + halfSize,
+          0.0f);
     }
 
     // Zero out the DC and nquist components.
-    complexFFTData[0] = {0.0f, 0.0f};
+    realFFTFrameData[0] = 0.0f;
+    imaginaryFFTFrameData[0] = 0.0f;
 
     bandLimitedTables_[rangeIndex] = new float[fftSize];
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fft_->doInverseFFT(complexFFTData, bandLimitedTables_[rangeIndex]);
+    fftFrame.doInverseFFT(
+        bandLimitedTables_[rangeIndex],
+        realFFTFrameData,
+        imaginaryFFTFrameData);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =
-          dsp::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
+          VectorMath::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
       if (maxValue != 0) {
         normalizationFactor = 1.0f / maxValue;
       }
     }
 
-    dsp::multiplyByScalar(
+    delete[] realFFTFrameData;
+    delete[] imaginaryFFTFrameData;
+
+    VectorMath::multiplyByScalar(
         bandLimitedTables_[rangeIndex],
         normalizationFactor,
         bandLimitedTables_[rangeIndex],

package/common/cpp/audioapi/core/effects/PeriodicWave.h

@@ -29,13 +29,10 @@
 #pragma once
 
 #include <audioapi/core/types/OscillatorType.h>
-#include <audioapi/dsp/FFT.h>
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
-#include <vector>
-#include <complex>
 
 namespace audioapi {
 class PeriodicWave {
@@ -46,10 +43,10 @@ class PeriodicWave {
       bool disableNormalization);
   explicit PeriodicWave(
       float sampleRate,
-      const std::vector<std::complex<float>> &complexData,
+      float *real,
+      float *imaginary,
       int length,
       bool disableNormalization);
-  ~PeriodicWave();
 
   [[nodiscard]] int getPeriodicWaveSize() const;
   [[nodiscard]] float getScale() const;
@@ -81,7 +78,7 @@ class PeriodicWave {
   // For each range, the inverse FFT is performed to get the time domain
   // representation of the band-limited waveform.
   void
-  createBandLimitedTables(const std::vector<std::complex<float>> &complexData, int size);
+  createBandLimitedTables(const float *real, const float *imaginary, int size);
 
   // This function returns the interpolation factor between the lower and higher
   // range data and sets the lower and higher wave data for the given
@@ -114,8 +111,6 @@ class PeriodicWave {
   float scale_;
   // array of band-limited waveforms.
   float **bandLimitedTables_;
-  //
-  std::unique_ptr<dsp::FFT> fft_;
   // if true, the waveTable is not normalized.
   bool disableNormalization_;
 };

package/common/cpp/audioapi/core/effects/StereoPannerNode.cpp

@@ -1,8 +1,8 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 
 // https://webaudio.github.io/web-audio-api/#stereopanner-algorithm
 
@@ -11,7 +11,7 @@ namespace audioapi {
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
   channelCountMode_ = ChannelCountMode::EXPLICIT;
-  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f);
+  panParam_ = std::make_shared<AudioParam>(0.0, MIN_PAN, MAX_PAN);
   isInitialized_ = true;
 }
 

package/common/cpp/audioapi/core/effects/StretcherNode.cpp

@@ -0,0 +1,94 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/StretcherNode.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
+
+namespace audioapi {
+
+StretcherNode::StretcherNode(BaseAudioContext *context) : AudioNode(context) {
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  rate_ = std::make_shared<AudioParam>(1.0, 0.0, 3.0);
+  semitones_ = std::make_shared<AudioParam>(0.0, -12.0, 12.0);
+
+  stretch_ =
+      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+  stretch_->presetDefault(channelCount_, context->getSampleRate());
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
+  isInitialized_ = true;
+}
+
+std::shared_ptr<AudioParam> StretcherNode::getRateParam() const {
+  return rate_;
+}
+
+std::shared_ptr<AudioParam> StretcherNode::getSemitonesParam() const {
+  return semitones_;
+}
+
+void StretcherNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  auto time = context_->getCurrentTime();
+  auto semitones = semitones_->getValueAtTime(time);
+
+  stretch_->setTransposeSemitones(semitones);
+  stretch_->process(
+      playbackRateBus_.get()[0],
+      framesNeededToStretch_,
+      audioBus_.get()[0],
+      framesToProcess);
+}
+
+std::shared_ptr<AudioBus> StretcherNode::processAudio(
+    std::shared_ptr<AudioBus> outputBus,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (!isInitialized_) {
+    return outputBus;
+  }
+
+  if (isAlreadyProcessed()) {
+    return audioBus_;
+  }
+
+  auto time = context_->getCurrentTime();
+
+  auto rate = rate_->getValueAtTime(time);
+  framesNeededToStretch_ =
+      static_cast<int>(rate * static_cast<float>(framesToProcess));
+
+  playbackRateBus_->zero();
+  auto writeIndex = 0;
+  auto framesNeededToStretch = framesNeededToStretch_;
+
+  // Collecting frames needed to stretch
+  while (framesNeededToStretch > 0) {
+    auto framesToCopy = std::min(framesNeededToStretch, framesToProcess);
+
+    // Process inputs and return the bus with the most channels. We must not
+    // check if the node has already been processed, cause we need to process it
+    // multiple times in this case.
+    auto processingBus = processInputs(outputBus, framesToCopy, false);
+
+    // Apply channel count mode.
+    processingBus = applyChannelCountMode(processingBus);
+
+    // Mix all input buses into the processing bus.
+    mixInputsBuses(processingBus);
+
+    assert(processingBus != nullptr);
+
+    playbackRateBus_->copy(processingBus.get(), 0, writeIndex, framesToCopy);
+
+    writeIndex += framesToCopy;
+    framesNeededToStretch -= framesToCopy;
+  }
+
+  processNode(audioBus_, framesToProcess);
+
+  return audioBus_;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/effects/StretcherNode.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <audioapi/libs/signalsmith-stretch.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+
+#include <memory>
+#include <string>
+#include <cassert>
+
+namespace audioapi {
+class AudioBus;
+
+class StretcherNode : public AudioNode {
+ public:
+    explicit StretcherNode(BaseAudioContext *context);
+
+    [[nodiscard]] std::shared_ptr<AudioParam> getRateParam() const;
+    [[nodiscard]] std::shared_ptr<AudioParam> getSemitonesParam() const;
+
+ protected:
+    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<AudioBus> processAudio(std::shared_ptr<AudioBus> outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+
+ private:
+    // k-rate params
+    std::shared_ptr<AudioParam> rate_;
+    std::shared_ptr<AudioParam> semitones_;
+
+    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+    std::shared_ptr<AudioBus> playbackRateBus_;
+    int framesNeededToStretch_ = RENDER_QUANTUM_SIZE;
+};
+
+} // namespace audioapi

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

@@ -1,6 +1,6 @@
 #include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 
 #include <utility>
 
@@ -11,17 +11,10 @@ AudioBuffer::AudioBuffer(
     size_t length,
     float sampleRate) {
   bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
-  stretch_->presetDefault(numberOfChannels, sampleRate);
 }
 
 AudioBuffer::AudioBuffer(std::shared_ptr<AudioBus> bus) {
   bus_ = std::move(bus);
-
-  stretch_ =
-      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
-  stretch_->presetDefault(bus_->getNumberOfChannels(), bus_->getSampleRate());
 }
 
 size_t AudioBuffer::getLength() const {

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

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
-
 #include <algorithm>
 #include <memory>
 #include <string>
@@ -36,10 +34,9 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
       size_t startInChannel);
 
  private:
-  friend class AudioBufferSourceNode;
-
   std::shared_ptr<AudioBus> bus_;
-  std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+
+  friend class AudioBufferSourceNode;
 };
 
 } // namespace audioapi