react-native-audio-api 0.4.12-beta.5 → 0.4.13

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

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

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

@@ -1,12 +1,13 @@
 #pragma once
 
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/dsp/FFTFrame.h>
+#include <audioapi/dsp/FFT.h>
 
 #include <memory>
 #include <cstddef>
 #include <string>
 #include <complex>
+#include <vector>
 
 namespace audioapi {
 
@@ -44,15 +45,16 @@ 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<FFTFrame> fftFrame_;
-  std::shared_ptr<AudioArray> realData_;
-  std::shared_ptr<AudioArray> imaginaryData_;
+  std::unique_ptr<dsp::FFT> fft_;
+  std::vector<std::complex<float>> complexData_;
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_ { true };
 
@@ -82,8 +84,8 @@ class AnalyserNode : public AudioNode {
   }
 
   void doFFTAnalysis();
-  static void applyBlackManWindow(float *data, int length);
-  static void applyHannWindow(float *data, int length);
+
+  void setWindowData(WindowType type, int size);
 };
 
 } // 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/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
 // formulas for filters
@@ -10,12 +10,16 @@ namespace audioapi {
 
 BiquadFilterNode::BiquadFilterNode(BaseAudioContext *context)
     : AudioNode(context) {
-  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);
+  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);
   type_ = BiquadFilterType::LOWPASS;
   isInitialized_ = true;
 }

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

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

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

@@ -28,7 +28,6 @@
 
 #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;
@@ -47,6 +46,8 @@ 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(
@@ -59,12 +60,18 @@ PeriodicWave::PeriodicWave(
 
 PeriodicWave::PeriodicWave(
     float sampleRate,
-    float *real,
-    float *imaginary,
+    const std::vector<std::complex<float>> &complexData,
     int length,
     bool disableNormalization)
     : PeriodicWave(sampleRate, disableNormalization) {
-  createBandLimitedTables(real, imaginary, length);
+  createBandLimitedTables(complexData, length);
+}
+
+PeriodicWave::~PeriodicWave() {
+  for (int i = 0; i < numberOfRanges_; i++) {
+    delete[] bandLimitedTables_[i];
+  }
+  delete[] bandLimitedTables_;
 }
 
 int PeriodicWave::getPeriodicWaveSize() const {
@@ -130,15 +137,9 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
    * real and imaginary can finely shape which harmonic content is retained or
    * discarded.
    */
-  auto halfSize = fftSize / 2;
-
-  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;
+  auto halfSize = fftSize / 2;
+  auto complexData = std::vector<std::complex<float>>(halfSize);
 
   for (int i = 1; i < halfSize; i++) {
     // All waveforms are odd functions with a positive slope at time 0.
@@ -180,16 +181,14 @@ void PeriodicWave::generateBasicWaveForm(OscillatorType type) {
         throw std::invalid_argument("Custom waveforms are not supported.");
     }
 
-    real[i] = 0.0f;
-    imaginary[i] = b;
+    complexData[i] = std::complex<float>(0.0f, b);
   }
 
-  createBandLimitedTables(real, imaginary, halfSize);
+  createBandLimitedTables(complexData, halfSize);
 }
 
 void PeriodicWave::createBandLimitedTables(
-    const float *realData,
-    const float *imaginaryData,
+    const std::vector<std::complex<float>> &complexData,
     int size) {
   float normalizationFactor = 0.5f;
 
@@ -199,19 +198,7 @@ void PeriodicWave::createBandLimitedTables(
   size = std::min(size, halfSize);
 
   for (int rangeIndex = 0; rangeIndex < numberOfRanges_; rangeIndex++) {
-    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);
+    auto complexFFTData = std::vector<std::complex<float>>(halfSize);
 
     // Find the starting partial where we should start culling.
     // We need to clear out the highest frequencies to band-limit the waveform.
@@ -219,41 +206,37 @@ void PeriodicWave::createBandLimitedTables(
 
     // Clamp the size to the number of partials.
     auto clampedSize = std::min(size, numberOfPartials);
-    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);
+
+    // 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)};
+      }
     }
 
     // Zero out the DC and nquist components.
-    realFFTFrameData[0] = 0.0f;
-    imaginaryFFTFrameData[0] = 0.0f;
+    complexFFTData[0] = {0.0f, 0.0f};
 
     bandLimitedTables_[rangeIndex] = new float[fftSize];
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fftFrame.doInverseFFT(
-        bandLimitedTables_[rangeIndex],
-        realFFTFrameData,
-        imaginaryFFTFrameData);
+    fft_->doInverseFFT(complexFFTData, bandLimitedTables_[rangeIndex]);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =
-          VectorMath::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
+          dsp::maximumMagnitude(bandLimitedTables_[rangeIndex], fftSize);
       if (maxValue != 0) {
         normalizationFactor = 1.0f / maxValue;
       }
     }
 
-    delete[] realFFTFrameData;
-    delete[] imaginaryFFTFrameData;
-
-    VectorMath::multiplyByScalar(
+    dsp::multiplyByScalar(
         bandLimitedTables_[rangeIndex],
         normalizationFactor,
         bandLimitedTables_[rangeIndex],

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

@@ -29,10 +29,13 @@
 #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 {
@@ -43,10 +46,10 @@ class PeriodicWave {
       bool disableNormalization);
   explicit PeriodicWave(
       float sampleRate,
-      float *real,
-      float *imaginary,
+      const std::vector<std::complex<float>> &complexData,
       int length,
       bool disableNormalization);
+  ~PeriodicWave();
 
   [[nodiscard]] int getPeriodicWaveSize() const;
   [[nodiscard]] float getScale() const;
@@ -78,7 +81,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 float *real, const float *imaginary, int size);
+  createBandLimitedTables(const std::vector<std::complex<float>> &complexData, 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
@@ -111,6 +114,8 @@ 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/core/utils/AudioArray.h>
-#include <audioapi/core/utils/AudioBus.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/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, MIN_PAN, MAX_PAN);
+  panParam_ = std::make_shared<AudioParam>(0.0, -1.0f, 1.0f);
   isInitialized_ = true;
 }
 

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

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