react-native-audio-api 0.4.13 → 0.4.15

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

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <cmath>
 
-namespace audioapi::dsp {
+namespace audioapi::AudioUtils {
 
 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::dsp
+} // namespace audioapi::AudioUtils

package/common/cpp/audioapi/dsp/FFTFrame.cpp

@@ -0,0 +1,100 @@
+#include <audioapi/dsp/FFTFrame.h>
+
+namespace audioapi {
+#if defined(HAVE_ACCELERATE)
+static std::unordered_map<size_t, FFTSetup> fftSetups_;
+
+FFTFrame::FFTFrame(int size)
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
+  fftSetup_ = getFFTSetupForSize(log2Size_);
+}
+
+FFTFrame::~FFTFrame() {}
+
+FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
+  if (!fftSetups_.contains(log2FFTSize)) {
+    fftSetups_.emplace(
+        log2FFTSize, vDSP_create_fftsetup(log2FFTSize, FFT_RADIX2));
+  }
+
+  return fftSetups_.at(log2FFTSize);
+}
+
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
+  vDSP_ctoz(reinterpret_cast<DSPComplex *>(data), 2, &frame_, 1, size_ / 2);
+  vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_FORWARD);
+
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
+}
+
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
+  vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_INVERSE);
+  vDSP_ztoc(&frame_, 1, reinterpret_cast<DSPComplex *>(data), 2, size_ / 2);
+
+  // Scale the FFT data, beacuse of
+  // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892
+  VectorMath::multiplyByScalar(
+      data, 1.0f / static_cast<float>(size_), data, size_);
+}
+
+#elif defined(ANDROID)
+
+FFTFrame::FFTFrame(int size)
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
+  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
+  work_ = (float *)pffft_aligned_malloc(size_ * sizeof(float));
+}
+
+FFTFrame::~FFTFrame() {
+  pffft_destroy_setup(pffftSetup_);
+  pffft_aligned_free(work_);
+}
+
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_);
+  pffft_transform_ordered(
+      pffftSetup_,
+      data,
+      reinterpret_cast<float *>(&out[0]),
+      work_,
+      PFFFT_FORWARD);
+
+  for (int i = 0; i < size_ / 2; ++i) {
+    realData[i] = out[i].real();
+    imaginaryData[i] = out[i].imag();
+  }
+
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
+}
+
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_ / 2);
+  for (int i = 0; i < size_ / 2; i++) {
+    out[i] = {realData[i], imaginaryData[i]};
+  }
+
+  pffft_transform_ordered(
+      pffftSetup_,
+      reinterpret_cast<float *>(&out[0]),
+      data,
+      work_,
+      PFFFT_BACKWARD);
+
+  VectorMath::multiplyByScalar(
+      data, 1.0f / static_cast<float>(size_), data, size_);
+}
+
+#endif
+} // namespace audioapi

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <audioapi/dsp/VectorMath.h>
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+#include <unordered_map>
+#include <complex>
+
+#if defined(HAVE_ACCELERATE)
+#include <Accelerate/Accelerate.h>
+#endif
+
+#if defined(ANDROID)
+#include <audioapi/android/libs/pffft.h>
+#endif
+
+namespace audioapi {
+
+class FFTFrame {
+ public:
+  explicit FFTFrame(int size);
+  ~FFTFrame();
+
+  void doFFT(float *data, float *realData, float *imaginaryData);
+  void doInverseFFT(float *data, float *realData, float *imaginaryData);
+
+ private:
+  int size_;
+  int log2Size_;
+
+#if defined(HAVE_ACCELERATE)
+    FFTSetup fftSetup_;
+    DSPSplitComplex frame_;
+
+    static FFTSetup getFFTSetupForSize(size_t log2FFTSize);
+#endif
+
+#if defined(ANDROID)
+    PFFFT_Setup *pffftSetup_;
+    float *work_;
+#endif
+};
+
+} // namespace audioapi

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

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

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

@@ -32,7 +32,7 @@
 #include <algorithm>
 #include <cmath>
 
-namespace audioapi::dsp {
+namespace audioapi::VectorMath {
 
 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::dsp
+} // namespace audioapi::VectorMath

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

@@ -0,0 +1,47 @@
+#ifndef SIGNALSMITH_DSP_COMMON_H
+#define SIGNALSMITH_DSP_COMMON_H
+
+#if defined(__FAST_MATH__) && (__apple_build_version__ >= 16000000) && (__apple_build_version__ <= 16000099)
+#	error Apple Clang 16.0.0 generates incorrect SIMD for ARM. If you HAVE to use this version of Clang, turn off -ffast-math.
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327950288
+#endif
+
+namespace signalsmith {
+	/**	@defgroup Common Common
+		@brief Definitions and helper classes used by the rest of the library
+		
+		@{
+		@file
+	*/
+
+#define SIGNALSMITH_DSP_VERSION_MAJOR 1
+#define SIGNALSMITH_DSP_VERSION_MINOR 6
+#define SIGNALSMITH_DSP_VERSION_PATCH 1
+#define SIGNALSMITH_DSP_VERSION_STRING "1.6.1"
+
+	/** Version compatability check.
+	\code{.cpp}
+		static_assert(signalsmith::version(1, 4, 1), "version check");
+	\endcode
+	... or use the equivalent `SIGNALSMITH_DSP_VERSION_CHECK`.
+	Major versions are not compatible with each other.  Minor and patch versions are backwards-compatible.
+	*/
+	constexpr bool versionCheck(int major, int minor, int patch=0) {
+		return major == SIGNALSMITH_DSP_VERSION_MAJOR
+			&& (SIGNALSMITH_DSP_VERSION_MINOR > minor
+				|| (SIGNALSMITH_DSP_VERSION_MINOR == minor && SIGNALSMITH_DSP_VERSION_PATCH >= patch));
+	}
+
+/// Check the library version is compatible (semver).
+#define SIGNALSMITH_DSP_VERSION_CHECK(major, minor, patch) \
+	static_assert(::signalsmith::versionCheck(major, minor, patch), "signalsmith library version is " SIGNALSMITH_DSP_VERSION_STRING);
+
+/** @} */
+} // signalsmith::
+#else
+// If we've already included it, check it's the same version
+static_assert(SIGNALSMITH_DSP_VERSION_MAJOR == 1 && SIGNALSMITH_DSP_VERSION_MINOR == 6 && SIGNALSMITH_DSP_VERSION_PATCH == 1, "multiple versions of the Signalsmith DSP library");
+#endif // include guard

package/common/cpp/audioapi/libs/{signalsmith-stretch → dsp}/delay.h

@@ -1,3 +1,5 @@
+#include <audioapi/libs/dsp/common.h>
+
 #ifndef SIGNALSMITH_DSP_DELAY_H
 #define SIGNALSMITH_DSP_DELAY_H
 
@@ -5,10 +7,10 @@
 #include <array>
 #include <cmath> // for std::ceil()
 #include <type_traits>
-#include <complex>
 
-#include <audioapi/libs/signalsmith-stretch/fft.h>
-#include <audioapi/dsp/Windows.h>
+#include <complex>
+#include <audioapi/libs/dsp/fft.h>
+#include <audioapi/libs/dsp/windows.h>
 
 namespace signalsmith {
 namespace delay {
@@ -480,14 +482,14 @@ namespace delay {
 		InterpolatorKaiserSincN(double passFreq) : InterpolatorKaiserSincN(passFreq, 1 - passFreq) {}
 		InterpolatorKaiserSincN(double passFreq, double stopFreq) {
 			subSampleSteps = 2*n; // Heuristic again.  Really it depends on the bandwidth as well.
-			float kaiserBandwidth = (stopFreq - passFreq)*(n + 1.0/subSampleSteps);
-			kaiserBandwidth += 1.25f / kaiserBandwidth; // We want to place the first zero, but (because using this to window a sinc essentially integrates it in the freq-domain), our ripples (and therefore zeroes) are out of phase.  This is a heuristic fix.
-			double sincScale = audioapi::PI*(passFreq + stopFreq);
+			double kaiserBandwidth = (stopFreq - passFreq)*(n + 1.0/subSampleSteps);
+			kaiserBandwidth += 1.25/kaiserBandwidth; // We want to place the first zero, but (because using this to window a sinc essentially integrates it in the freq-domain), our ripples (and therefore zeroes) are out of phase.  This is a heuristic fix.
+			double sincScale = M_PI*(passFreq + stopFreq);
 
 			double centreIndex = n*subSampleSteps*0.5, scaleFactor = 1.0/subSampleSteps;
 			std::vector<Sample> windowedSinc(subSampleSteps*n + 1);
 
-            audioapi::dsp::Kaiser::withBandwidth(kaiserBandwidth, false).apply(windowedSinc.data(), windowedSinc.size());
+			::signalsmith::windows::Kaiser::withBandwidth(kaiserBandwidth, false).fill(windowedSinc, windowedSinc.size());
 
 			for (size_t i = 0; i < windowedSinc.size(); ++i) {
 				double x = (i - centreIndex)*scaleFactor;
@@ -502,7 +504,7 @@ namespace delay {
 			}
 
 			if (minimumPhase) {
-				signalsmith::fft::FFT<Sample> fft(windowedSinc.getSize()*2, 1);
+				signalsmith::fft::FFT<Sample> fft(windowedSinc.size()*2, 1);
 				windowedSinc.resize(fft.size(), 0);
 				std::vector<std::complex<Sample>> spectrum(fft.size());
 				std::vector<std::complex<Sample>> cepstrum(fft.size());
@@ -527,7 +529,7 @@ namespace delay {
 				}
 				fft.ifft(spectrum, cepstrum);
 				windowedSinc.resize(subSampleSteps*n + 1);
-                windowedSinc.shrink_to_fit();
+				windowedSinc.shrink_to_fit();
 				for (size_t i = 0; i < windowedSinc.size(); ++i) {
 					windowedSinc[i] = cepstrum[i].real()*scaling;
 				}

package/common/cpp/audioapi/libs/{signalsmith-stretch → dsp}/fft.h

@@ -1,8 +1,9 @@
+#include <audioapi/libs/dsp/common.h>
+
 #ifndef SIGNALSMITH_FFT_V5
 #define SIGNALSMITH_FFT_V5
 
-#include <audioapi/libs/signalsmith-stretch/perf.h>
-#include <audioapi/core/Constants.h>
+#include <audioapi/libs/dsp/perf.h>
 
 #include <vector>
 #include <complex>
@@ -128,7 +129,7 @@ namespace signalsmith { namespace fft {
 			if (!foundStep) {
 				for (size_t i = 0; i < subLength; ++i) {
 					for (size_t f = 0; f < factor; ++f) {
-						double phase = 2*audioapi::PI*i*f/length;
+						double phase = 2*M_PI*i*f/length;
 						complex twiddle = {V(std::cos(phase)), V(-std::sin(phase))};
 						twiddleVector.push_back(twiddle);
 					}
@@ -211,7 +212,7 @@ namespace signalsmith { namespace fft {
 					for (size_t f = 0; f < factor; ++f) {
 						complex sum = working[0];
 						for (size_t i = 1; i < factor; ++i) {
-							double phase = 2*audioapi::PI*f*i/factor;
+							double phase = 2*M_PI*f*i/factor;
 							complex twiddle = {V(std::cos(phase)), V(-std::sin(phase))};
 							sum += _fft_impl::complexMul<inverse>(working[i], twiddle);
 						}
@@ -430,13 +431,13 @@ namespace signalsmith { namespace fft {
 			size_t hhSize = size/4 + 1;
 			twiddlesMinusI.resize(hhSize);
 			for (size_t i = 0; i < hhSize; ++i) {
-				V rotPhase = -2*audioapi::PI*(modified ? i + 0.5 : i)/size;
+				V rotPhase = -2*M_PI*(modified ? i + 0.5 : i)/size;
 				twiddlesMinusI[i] = {std::sin(rotPhase), -std::cos(rotPhase)};
 			}
 			if (modified) {
 				modifiedRotations.resize(size/2);
 				for (size_t i = 0; i < size/2; ++i) {
-					V rotPhase = -2*audioapi::PI*i/size;
+					V rotPhase = -2*M_PI*i/size;
 					modifiedRotations[i] = {std::cos(rotPhase), std::sin(rotPhase)};
 				}
 			}

package/common/cpp/audioapi/libs/{signalsmith-stretch → dsp}/perf.h

@@ -1,3 +1,5 @@
+#include <audioapi/libs/dsp/common.h>
+
 #ifndef SIGNALSMITH_DSP_PERF_H
 #define SIGNALSMITH_DSP_PERF_H
 

package/common/cpp/audioapi/libs/{signalsmith-stretch → dsp}/spectral.h

@@ -1,13 +1,12 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/libs/dsp/common.h>
 
 #ifndef SIGNALSMITH_DSP_SPECTRAL_H
 #define SIGNALSMITH_DSP_SPECTRAL_H
 
-#include <audioapi/libs/signalsmith-stretch/perf.h>
-#include <audioapi/libs/signalsmith-stretch/fft.h>
-#include <audioapi/libs/signalsmith-stretch/delay.h>
-
-#include <audioapi/dsp/Windows.h>
+#include <audioapi/libs/dsp/perf.h>
+#include <audioapi/libs/dsp/fft.h>
+#include <audioapi/libs/dsp/windows.h>
+#include <audioapi/libs/dsp/delay.h>
 
 #include <cmath>
 
@@ -77,7 +76,7 @@ namespace spectral {
 		/// Sets the size (using the default Blackman-Harris window)
 		void setSize(int size, int rotateSamples=0) {
 			setSize(size, [](double x) {
-				double phase = 2 * audioapi::PI * x;
+				double phase = 2*M_PI*x;
 				// Blackman-Harris
 				return 0.35875 - 0.48829*std::cos(phase) + 0.14128*std::cos(phase*2) - 0.01168*std::cos(phase*3);
 			}, Sample(0.5), rotateSamples);
@@ -250,12 +249,16 @@ namespace spectral {
 
 			auto &window = fft.setSizeWindow(_fftSize, rotateToZero ? _windowSize/2 : 0);
 			if (windowShape == Window::kaiser) {
+				using Kaiser = ::signalsmith::windows::Kaiser;
 				/// Roughly optimal Kaiser for STFT analysis (forced to perfect reconstruction)
-				audioapi::dsp::Kaiser::withBandwidth(_windowSize/_interval, true).apply(window.data(), _windowSize);
+				auto kaiser_ = Kaiser::withBandwidth(_windowSize/double(_interval), true);
+				kaiser_.fill(window, _windowSize);
 			} else {
-				audioapi::dsp::ApproximateConfinedGaussian::withBandwidth(_windowSize/_interval).apply(window.data(), _windowSize);
+				using Confined = ::signalsmith::windows::ApproximateConfinedGaussian;
+				auto confined = Confined::withBandwidth(_windowSize/double(_interval));
+				confined.fill(window, _windowSize);
 			}
-            audioapi::dsp::WindowFunction::forcePerfectReconstruction(window.data(), _windowSize, _interval);
+			::signalsmith::windows::forcePerfectReconstruction(window, _windowSize, _interval);
 
 			// TODO: fill extra bits of an input buffer with NaN/Infinity, to break this, and then fix by adding zero-padding to WindowedFFT (as opposed to zero-valued window sections)
 			for (int i = _windowSize; i < _fftSize; ++i) {

package/common/cpp/audioapi/libs/dsp/windows.h

@@ -0,0 +1,219 @@
+#include <audioapi/libs/dsp/common.h>
+
+#ifndef SIGNALSMITH_DSP_WINDOWS_H
+#define SIGNALSMITH_DSP_WINDOWS_H
+
+#include <cmath>
+#include <algorithm>
+
+namespace signalsmith {
+namespace windows {
+	/**	@defgroup Windows Window functions
+		@brief Windows for spectral analysis
+
+		These are generally double-precision, because they are mostly calculated during setup/reconfiguring, not real-time code.
+
+		@{
+		@file
+	*/
+
+	/** @brief The Kaiser window (almost) maximises the energy in the main-lobe compared to the side-lobes.
+
+		Kaiser windows can be constructing using the shape-parameter (beta) or using the static `with???()` methods.*/
+	class Kaiser {
+		// I_0(x)=\sum_{k=0}^{N}\frac{x^{2k}}{(k!)^2\cdot4^k}
+		inline static double bessel0(double x) {
+			const double significanceLimit = 1e-4;
+			double result = 0;
+			double term = 1;
+			double m = 0;
+			while (term > significanceLimit) {
+				result += term;
+				++m;
+				term *= (x*x)/(4*m*m);
+			}
+
+			return result;
+		}
+		double beta;
+		double invB0;
+
+		static double heuristicBandwidth(double bandwidth) {
+			// Good peaks
+			//return bandwidth + 8/((bandwidth + 3)*(bandwidth + 3));
+			// Good average
+			//return bandwidth + 14/((bandwidth + 2.5)*(bandwidth + 2.5));
+			// Compromise
+			return bandwidth + 8/((bandwidth + 3)*(bandwidth + 3)) + 0.25*std::max(3 - bandwidth, 0.0);
+		}
+	public:
+		/// Set up a Kaiser window with a given shape.  `beta` is `pi*alpha` (since there is ambiguity about shape parameters)
+		Kaiser(double beta) : beta(beta), invB0(1/bessel0(beta)) {}
+
+		/// @name Bandwidth methods
+		/// @{
+		static Kaiser withBandwidth(double bandwidth, bool heuristicOptimal=false) {
+			return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal));
+		}
+
+		/** Returns the Kaiser shape where the main lobe has the specified bandwidth (as a factor of 1/window-length).
+		\diagram{kaiser-windows.svg,You can see that the main lobe matches the specified bandwidth.}
+		If `heuristicOptimal` is enabled, the main lobe width is _slightly_ wider, improving both the peak and total energy - see `bandwidthToEnergyDb()` and `bandwidthToPeakDb()`.
+		\diagram{kaiser-windows-heuristic.svg, The main lobe extends to ±bandwidth/2.} */
+		static double bandwidthToBeta(double bandwidth, bool heuristicOptimal=false) {
+			if (heuristicOptimal) { // Heuristic based on numerical search
+				bandwidth = heuristicBandwidth(bandwidth);
+			}
+			bandwidth = std::max(bandwidth, 2.0);
+			double alpha = std::sqrt(bandwidth*bandwidth*0.25 - 1);
+			return alpha*M_PI;
+		}
+
+		static double betaToBandwidth(double beta) {
+			double alpha = beta*(1.0/M_PI);
+			return 2*std::sqrt(alpha*alpha + 1);
+		}
+		/// @}
+
+		/// @name Performance methods
+		/// @{
+		/** @brief Total energy ratio (in dB) between side-lobes and the main lobe.
+			\diagram{windows-kaiser-sidelobe-energy.svg,Measured main/side lobe energy ratio.  You can see that the heuristic improves performance for all bandwidth values.}
+			This function uses an approximation which is accurate to ±0.5dB for 2 ⩽ bandwidth ≤ 10, or 1 ⩽ bandwidth ≤ 10 when `heuristicOptimal`is enabled.
+		*/
+		static double bandwidthToEnergyDb(double bandwidth, bool heuristicOptimal=false) {
+			// Horrible heuristic fits
+			if (heuristicOptimal) {
+				if (bandwidth < 3) bandwidth += (3 - bandwidth)*0.5;
+				return 12.9 + -3/(bandwidth + 0.4) - 13.4*bandwidth + (bandwidth < 3)*-9.6*(bandwidth - 3);
+			}
+			return 10.5 + 15/(bandwidth + 0.4) - 13.25*bandwidth + (bandwidth < 2)*13*(bandwidth - 2);
+		}
+		static double energyDbToBandwidth(double energyDb, bool heuristicOptimal=false) {
+			double bw = 1;
+			while (bw < 20 && bandwidthToEnergyDb(bw, heuristicOptimal) > energyDb) {
+				bw *= 2;
+			}
+			double step = bw/2;
+			while (step > 0.0001) {
+				if (bandwidthToEnergyDb(bw, heuristicOptimal) > energyDb) {
+					bw += step;
+				} else {
+					bw -= step;
+				}
+				step *= 0.5;
+			}
+			return bw;
+		}
+		/** @brief Peak ratio (in dB) between side-lobes and the main lobe.
+			\diagram{windows-kaiser-sidelobe-peaks.svg,Measured main/side lobe peak ratio.  You can see that the heuristic improves performance, except in the bandwidth range 1-2 where peak ratio was sacrificed to improve total energy ratio.}
+			This function uses an approximation which is accurate to ±0.5dB for 2 ⩽ bandwidth ≤ 9, or 0.5 ⩽ bandwidth ≤ 9 when `heuristicOptimal`is enabled.
+		*/
+		static double bandwidthToPeakDb(double bandwidth, bool heuristicOptimal=false) {
+			// Horrible heuristic fits
+			if (heuristicOptimal) {
+				return 14.2 - 20/(bandwidth + 1) - 13*bandwidth + (bandwidth < 3)*-6*(bandwidth - 3) + (bandwidth < 2.25)*5.8*(bandwidth - 2.25);
+			}
+			return 10 + 8/(bandwidth + 2) - 12.75*bandwidth + (bandwidth < 2)*4*(bandwidth - 2);
+		}
+		static double peakDbToBandwidth(double peakDb, bool heuristicOptimal=false) {
+			double bw = 1;
+			while (bw < 20 && bandwidthToPeakDb(bw, heuristicOptimal) > peakDb) {
+				bw *= 2;
+			}
+			double step = bw/2;
+			while (step > 0.0001) {
+				if (bandwidthToPeakDb(bw, heuristicOptimal) > peakDb) {
+					bw += step;
+				} else {
+					bw -= step;
+				}
+				step *= 0.5;
+			}
+			return bw;
+		}
+		/** @} */
+
+		/** Equivalent noise bandwidth (ENBW), a measure of frequency resolution.
+			\diagram{windows-kaiser-enbw.svg,Measured ENBW\, with and without the heuristic bandwidth adjustment.}
+			This approximation is accurate to ±0.05 up to a bandwidth of 22.
+		*/
+		static double bandwidthToEnbw(double bandwidth, bool heuristicOptimal=false) {
+			if (heuristicOptimal) bandwidth = heuristicBandwidth(bandwidth);
+			double b2 = std::max<double>(bandwidth - 2, 0);
+			return 1 + b2*(0.2 + b2*(-0.005 + b2*(-0.000005 + b2*0.0000022)));
+		}
+
+		/// Return the window's value for position in the range [0, 1]
+		double operator ()(double unit) {
+			double r = 2*unit - 1;
+			double arg = std::sqrt(1 - r*r);
+			return bessel0(beta*arg)*invB0;
+		}
+
+		/// Fills an arbitrary container with a Kaiser window
+		template<typename Data>
+		void fill(Data &&data, int size) const {
+			double invSize = 1.0/size;
+			for (int i = 0; i < size; ++i) {
+				double r = (2*i + 1)*invSize - 1;
+				double arg = std::sqrt(1 - r*r);
+				data[i] = bessel0(beta*arg)*invB0;
+			}
+		}
+	};
+
+	/** @brief The Approximate Confined Gaussian window is (almost) optimal
+
+		ACG windows can be constructing using the shape-parameter (sigma) or using the static `with???()` methods.*/
+	class ApproximateConfinedGaussian {
+		double gaussianFactor;
+
+		double gaussian(double x) const {
+			return std::exp(-x*x*gaussianFactor);
+		}
+	public:
+		/// Heuristic map from bandwidth to the appropriately-optimal sigma
+		static double bandwidthToSigma(double bandwidth) {
+			return 0.3/std::sqrt(bandwidth);
+		}
+		static ApproximateConfinedGaussian withBandwidth(double bandwidth) {
+			return ApproximateConfinedGaussian(bandwidthToSigma(bandwidth));
+		}
+
+		ApproximateConfinedGaussian(double sigma) : gaussianFactor(0.0625/(sigma*sigma)) {}
+
+		/// Fills an arbitrary container
+		template<typename Data>
+		void fill(Data &&data, int size) const {
+			double invSize = 1.0/size;
+			double offsetScale = gaussian(1)/(gaussian(3) + gaussian(-1));
+			double norm = 1/(gaussian(0) - 2*offsetScale*(gaussian(2)));
+			for (int i = 0; i < size; ++i) {
+				double r = (2*i + 1)*invSize - 1;
+				data[i] = norm*(gaussian(r) - offsetScale*(gaussian(r - 2) + gaussian(r + 2)));
+			}
+		}
+	};
+
+	/** Forces STFT perfect-reconstruction (WOLA) on an existing window, for a given STFT interval.
+	For example, here are perfect-reconstruction versions of the approximately-optimal @ref Kaiser windows:
+	\diagram{kaiser-windows-heuristic-pr.svg,Note the lower overall energy\, and the pointy top for 2x bandwidth. Spectral performance is about the same\, though.}
+	*/
+	template<typename Data>
+	void forcePerfectReconstruction(Data &&data, int windowLength, int interval) {
+		for (int i = 0; i < interval; ++i) {
+			double sum2 = 0;
+			for (int index = i; index < windowLength; index += interval) {
+				sum2 += data[index]*data[index];
+			}
+			double factor = 1/std::sqrt(sum2);
+			for (int index = i; index < windowLength; index += interval) {
+				data[index] *= factor;
+			}
+		}
+	}
+
+/** @} */
+}} // signalsmith::windows
+#endif // include guard

package/common/cpp/audioapi/libs/{signalsmith-stretch/signalsmith-stretch.h → signalsmith-stretch.h}

@@ -1,9 +1,10 @@
 #ifndef SIGNALSMITH_STRETCH_H
 #define SIGNALSMITH_STRETCH_H
 
-#include <audioapi/libs/signalsmith-stretch/spectral.h>
-#include <audioapi/libs/signalsmith-stretch/delay.h>
-#include <audioapi/libs/signalsmith-stretch/perf.h>
+#include <audioapi/libs/dsp/spectral.h>
+#include <audioapi/libs/dsp/delay.h>
+#include <audioapi/libs/dsp/perf.h>
+SIGNALSMITH_DSP_VERSION_CHECK(1, 6, 0); // Check version is compatible
 #include <vector>
 #include <algorithm>
 #include <functional>

package/ios/audioapi/ios/core/AudioDecoder.mm

@@ -1,9 +1,9 @@
 #define MINIAUDIO_IMPLEMENTATION
-#import <audioapi/libs/miniaudio/miniaudio.h>
+#import <audioapi/libs/miniaudio.h>
 
+#include <audioapi/core/utils/AudioArray.h>
+#include <audioapi/core/utils/AudioBus.h>
 #include <audioapi/core/utils/AudioDecoder.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {