react-native-audio-api 0.7.2-nightly-c06331b-20250824 → 0.7.2-nightly-799cc6b-20250826

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

@@ -14,7 +14,7 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
     BaseAudioContext *context)
     : AudioBufferBaseSourceNode(context) {
   buffers_ = {};
-  stretch_->presetDefault(channelCount_, context_->getSampleRate(), true);
+  stretch_->presetDefault(channelCount_, context_->getSampleRate());
 
   isInitialized_ = true;
 }

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

@@ -93,7 +93,7 @@ void AudioBufferSourceNode::setBuffer(
 
   loopEnd_ = buffer_->getDuration();
 
-  stretch_->presetDefault(channelCount_, buffer_->getSampleRate(), true);
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {

package/common/cpp/audioapi/libs/signalsmith-stretch/fft-pffft.h

@@ -0,0 +1,222 @@
+#ifndef SIGNALSMITH_LINEAR_PLATFORM_FFT_PFFFT_H
+#define SIGNALSMITH_LINEAR_PLATFORM_FFT_PFFFT_H
+
+#if defined(__has_include) && !__has_include("pffft/pffft.h")
+#	include <audioapi/libs/pffft/pffft.h>
+#else
+#	include "pffft/pffft.h"
+#endif
+
+#include <memory>
+#include <cmath>
+#include <complex>
+#include <cassert>
+#include <cstring>
+
+namespace signalsmith { namespace linear {
+
+template<>
+struct Pow2FFT<float> {
+	static constexpr bool prefersSplit = false;
+
+	using Complex = std::complex<float>;
+
+	Pow2FFT(size_t size=0) {
+		resize(size);
+	}
+	~Pow2FFT() {
+		resize(0); // frees everything
+	}
+	// Allow move, but not copy
+	Pow2FFT(const Pow2FFT &other) = delete;
+	Pow2FFT(Pow2FFT &&other) : _size(other._size), hasSetup(other.hasSetup), fftSetup(other.fftSetup), fallback(std::move(other.fallback)), work(other.work), tmpAligned(other.tmpAligned) {
+		// Avoid double-free
+		other.hasSetup = false;
+		other.work = nullptr;
+		other.tmpAligned = nullptr;
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		fallback = nullptr;
+		if (hasSetup) pffft_destroy_setup(fftSetup);
+		if (work) pffft_aligned_free(work);
+		work = nullptr;
+		if (tmpAligned) pffft_aligned_free(tmpAligned);
+		tmpAligned = nullptr;
+
+		// We use this for split-real, even if there's no PFFFT setup
+		tmpAligned = (float *)pffft_aligned_malloc(sizeof(float)*size*2);
+
+		if (size < 16) {
+			// PFFFT doesn't support smaller sizes
+			hasSetup = false;
+			fallback = std::unique_ptr<SimpleFFT<float>>{
+				new SimpleFFT<float>(size)
+			};
+			return;
+		}
+
+		work = (float *)pffft_aligned_malloc(sizeof(float)*size*2);
+		fftSetup = pffft_new_setup(int(size), PFFFT_COMPLEX);
+		hasSetup = fftSetup;
+	}
+
+	void fft(const Complex* input, Complex* output) {
+		if (fallback) return fallback->fft(input, output);
+		fftInner(input, output, PFFFT_FORWARD);
+	}
+	void fft(const float *inR, const float *inI, float *outR, float *outI) {
+		if (fallback) return fallback->fft(inR, inI, outR, outI);
+		fftInner(inR, inI, outR, outI, PFFFT_FORWARD);
+	}
+
+	void ifft(const Complex* input, Complex* output) {
+		if (fallback) return fallback->ifft(input, output);
+		fftInner(input, output, PFFFT_BACKWARD);
+	}
+	void ifft(const float *inR, const float *inI, float *outR, float *outI) {
+		if (fallback) return fallback->ifft(inR, inI, outR, outI);
+		fftInner(inR, inI, outR, outI, PFFFT_BACKWARD);
+	}
+
+private:
+	void fftInner(const Complex *input, Complex *output, pffft_direction_t direction) {
+		// 16-byte alignment
+		if (size_t(input)&0x0F) {
+			// `tmpAligned` is always aligned, so copy into that
+			std::memcpy(tmpAligned, input, sizeof(Complex)*_size);
+			input = (const Complex *)tmpAligned;
+		}
+		if (size_t(output)&0x0F) {
+			// Output to `tmpAligned` - might be in-place if input is unaligned, but that's fine
+			pffft_transform_ordered(fftSetup, (const float *)input, tmpAligned, work, direction);
+			std::memcpy(output, tmpAligned, sizeof(Complex)*_size);
+		} else {
+			pffft_transform_ordered(fftSetup, (const float *)input, (float *)output, work, direction);
+		}
+	}
+	void fftInner(const float *inR, const float *inI, float *outR, float *outI, pffft_direction_t direction) {
+		for (size_t i = 0; i < _size; ++i) {
+			tmpAligned[2*i] = inR[i];
+			tmpAligned[2*i + 1] = inI[i];
+		}
+		// PFFFT supports in-place transforms
+		fftInner((const Complex *)tmpAligned, (Complex *)tmpAligned, direction);
+		// Un-interleave
+		for (size_t i = 0; i < _size; ++i) {
+			outR[i] = tmpAligned[2*i];
+			outI[i] = tmpAligned[2*i + 1];
+		}
+	}
+
+	size_t _size = 0;
+	bool hasSetup = false;
+	PFFFT_Setup *fftSetup = nullptr;
+	std::unique_ptr<SimpleFFT<float>> fallback;
+	float *work = nullptr, *tmpAligned = nullptr;
+};
+
+template<>
+struct Pow2RealFFT<float> {
+private:
+	using FallbackFFT = SimpleRealFFT<float>; // this wraps the complex one
+public:
+	static constexpr bool prefersSplit = false;
+
+	using Complex = std::complex<float>;
+
+	Pow2RealFFT(size_t size=0) {
+		resize(size);
+	}
+	~Pow2RealFFT() {
+		resize(0);
+	}
+	// Allow move, but not copy
+	Pow2RealFFT(const Pow2RealFFT &other) = delete;
+	Pow2RealFFT(Pow2RealFFT &&other) : _size(other._size), hasSetup(other.hasSetup), fftSetup(other.fftSetup), fallback(std::move(other.fallback)), work(other.work), tmpAligned(other.tmpAligned) {
+		// Avoid double-free
+		other.hasSetup = false;
+		other.work = nullptr;
+		other.tmpAligned = nullptr;
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		fallback = nullptr;
+		if (hasSetup) pffft_destroy_setup(fftSetup);
+		if (work) pffft_aligned_free(work);
+		work = nullptr;
+		if (tmpAligned) pffft_aligned_free(tmpAligned);
+		tmpAligned = nullptr;
+
+		// We use this for split-real, even if there's no PFFFT setup
+		tmpAligned = (float *)pffft_aligned_malloc(sizeof(float)*size*2);
+
+		// TODO: just go for it, and check for success before allocating `work`
+		if (size < 32) {
+			// PFFFT doesn't support smaller sizes
+			hasSetup = false;
+			fallback = std::unique_ptr<FallbackFFT>{
+				new FallbackFFT(size)
+			};
+			return;
+		}
+
+		work = (float *)pffft_aligned_malloc(sizeof(float)*size);
+		fftSetup = pffft_new_setup(int(size), PFFFT_REAL);
+		hasSetup = fftSetup;
+	}
+
+	void fft(const float *input, Complex *output) {
+		if (fallback) return fallback->fft(input, output);
+		fftInner(input, (float *)output, PFFFT_FORWARD);
+	}
+	void fft(const float *inR, float *outR, float *outI) {
+		if (fallback) return fallback->fft(inR, outR, outI);
+		fftInner(inR, tmpAligned, PFFFT_FORWARD);
+		for (size_t i = 0; i < _size/2; ++i) {
+			outR[i] = tmpAligned[2*i];
+			outI[i] = tmpAligned[2*i + 1];
+		}
+	}
+
+	void ifft(const Complex *input, float *output) {
+		if (fallback) return fallback->ifft(input, output);
+		fftInner((const float *)input, output, PFFFT_BACKWARD);
+	}
+	void ifft(const float *inR, const float *inI, float *outR) {
+		if (fallback) return fallback->ifft(inR, inI, outR);
+		for (size_t i = 0; i < _size/2; ++i) {
+			tmpAligned[2*i] = inR[i];
+			tmpAligned[2*i + 1] = inI[i];
+		}
+		fftInner(tmpAligned, outR, PFFFT_BACKWARD);
+	}
+
+private:
+	void fftInner(const float *input, float *output, pffft_direction_t direction) {
+		// 16-byte alignment
+		if (size_t(input)&0x0F) {
+			// `tmpAligned` is always aligned, so copy into that
+			std::memcpy(tmpAligned, input, sizeof(float)*_size);
+			input = tmpAligned;
+		}
+		if (size_t(output)&0x0F) {
+			// Output to `tmpAligned` - might be in-place if input is unaligned, but that's fine
+			pffft_transform_ordered(fftSetup, input, tmpAligned, work, direction);
+			std::memcpy(output, tmpAligned, sizeof(float)*_size);
+		} else {
+			pffft_transform_ordered(fftSetup, input, output, work, direction);
+		}
+	}
+
+	size_t _size = 0;
+	bool hasSetup = false;
+	PFFFT_Setup *fftSetup = nullptr;
+	std::unique_ptr<FallbackFFT> fallback;
+	float *work = nullptr, *tmpAligned = nullptr;
+};
+
+}} // namespace
+#endif // include guard

package/common/cpp/audioapi/libs/signalsmith-stretch/fft.h

@@ -4,6 +4,7 @@
 #include <complex>
 #include <vector>
 #include <cmath>
+#include <cstring>
 
 #if defined(__FAST_MATH__) && (__apple_build_version__ >= 16000000) && (__apple_build_version__ <= 16000099) && !defined(SIGNALSMITH_IGNORE_BROKEN_APPLECLANG)
 #	error Apple Clang 16.0.0 generates incorrect SIMD for ARM. If you HAVE to use this version of Clang, turn off -ffast-math.
@@ -16,6 +17,7 @@
 namespace signalsmith { namespace linear {
 
 namespace _impl {
+	// Helpers for complex arithmetic, ignoring the NaN/Inf edge-cases you get without `-ffast-math`
 	template<class V>
 	void complexMul(std::complex<V> *a, const std::complex<V> *b, const std::complex<V> *c, size_t size) {
 		for (size_t i = 0; i < size; ++i) {
@@ -282,79 +284,6 @@ private:
 	}
 };
 
-// Wraps a complex FFT into a real one
-template<typename Sample, class ComplexFFT=SimpleFFT<Sample>>
-struct SimpleRealFFT {
-	using Complex = std::complex<Sample>;
-
-	SimpleRealFFT(size_t size=0) {
-		resize(size);
-	}
-
-	void resize(size_t size) {
-		complexFft.resize(size);
-		tmpTime.resize(size);
-		tmpFreq.resize(size);
-	}
-
-	void fft(const Sample *time, Complex *freq) {
-		for (size_t i = 0; i < tmpTime.size(); ++i) {
-			tmpTime[i] = time[i];
-		}
-		complexFft.fft(tmpTime.data(), tmpFreq.data());
-		for (size_t i = 0; i < tmpFreq.size()/2; ++i) {
-			freq[i] = tmpFreq[i];
-		}
-		freq[0] = {
-			tmpFreq[0].real(),
-			tmpFreq[tmpFreq.size()/2].real()
-		};
-	}
-	void fft(const Sample *inR, Sample *outR, Sample *outI) {
-		Sample *tmpFreqR = (Sample *)tmpFreq.data(), *tmpFreqI = tmpFreqR + tmpFreq.size();
-		for (size_t i = 0; i < tmpTime.size()/2; ++i) {
-			tmpTime[i] = 0;
-		}
-		complexFft.fft(inR, (const Sample *)tmpTime.data(), tmpFreqR, tmpFreqI);
-		for (size_t i = 0; i < tmpTime.size()/2; ++i) {
-			outR[i] = tmpFreqR[i];
-			outI[i] = tmpFreqI[i];
-		}
-		outI[0] = tmpFreqR[tmpFreq.size()/2];
-	}
-
-	void ifft(const Complex *freq, Sample *time) {
-		tmpFreq[0] = freq[0].real();
-		tmpFreq[tmpFreq.size()/2] = freq[0].imag();
-		for (size_t i = 1; i < tmpFreq.size()/2; ++i) {
-			tmpFreq[i] = freq[i];
-			tmpFreq[tmpFreq.size() - i] = std::conj(freq[i]);
-		}
-		complexFft.ifft(tmpFreq.data(), tmpTime.data());
-		for (size_t i = 0; i < tmpTime.size(); ++i) {
-			time[i] = tmpTime[i].real();
-		}
-	}
-	void ifft(const Sample *inR, const Sample *inI, Sample *outR) {
-		Sample *tmpFreqR = (Sample *)tmpFreq.data(), *tmpFreqI = tmpFreqR + tmpFreq.size();
-		tmpFreqR[0] = inR[0];
-		tmpFreqR[tmpFreq.size()/2] = inI[0];
-		tmpFreqI[0] = 0;
-		tmpFreqI[tmpFreq.size()/2] = 0;
-		for (size_t i = 1; i < tmpFreq.size()/2; ++i) {
-			tmpFreqR[i] = inR[i];
-			tmpFreqI[i] = inI[i];
-			tmpFreqR[tmpFreq.size() - i] = inR[i];
-			tmpFreqI[tmpFreq.size() - i] = -inI[i];
-		}
-		complexFft.ifft(tmpFreqR, tmpFreqI, outR, (Sample *)tmpTime.data());
-	}
-
-private:
-	ComplexFFT complexFft;
-	std::vector<Complex> tmpTime, tmpFreq;
-};
-
 /// A power-of-2 only FFT, specialised with platform-specific fast implementations where available
 template<typename Sample>
 struct Pow2FFT {
@@ -364,6 +293,9 @@ struct Pow2FFT {
 	Pow2FFT(size_t size=0) {
 		resize(size);
 	}
+	// Allow move, but not copy
+	Pow2FFT(const Pow2FFT &other) = delete;
+	Pow2FFT(Pow2FFT &&other) : tmp(std::move(other.tmp)), simpleFFT(std::move(other.simpleFFT)) {}
 
 	void resize(size_t size) {
 		simpleFFT.resize(size);
@@ -389,14 +321,6 @@ private:
 	SimpleFFT<Sample> simpleFFT;
 };
 
-/// A power-of-2 only Real FFT, specialised with platform-specific fast implementations where available
-template<typename Sample>
-struct Pow2RealFFT : public SimpleRealFFT<Sample, Pow2FFT<Sample>> {
-	static constexpr bool prefersSplit = Pow2FFT<Sample>::prefersSplit;
-
-	using SimpleRealFFT<Sample, Pow2FFT<Sample>>::SimpleRealFFT;
-};
-
 /// An FFT which can handle multiples of 3 and 5, and can be computed in chunks
 template<typename Sample, bool splitComputation=false>
 struct SplitFFT {
@@ -450,7 +374,6 @@ struct SplitFFT {
 			outerTwiddlesI[i] = outerTwiddles[i].imag();
 		}
 
-
 		StepType interleaveStep = StepType::interleaveOrderN;
 		StepType finalStep = StepType::finalOrderN;
 		if (outerSize == 2) {
@@ -942,6 +865,94 @@ private:
 template<typename Sample, bool splitComputation=false>
 using FFT = SplitFFT<Sample, splitComputation>;
 
+// Wraps a complex FFT into a real one
+template<typename Sample, class ComplexFFT=Pow2FFT<Sample>>
+struct SimpleRealFFT {
+	using Complex = std::complex<Sample>;
+
+	static constexpr bool prefersSplit = ComplexFFT::prefersSplit;
+
+	SimpleRealFFT(size_t size=0) {
+		resize(size);
+	}
+
+	void resize(size_t size) {
+		complexFft.resize(size);
+		tmpTime.resize(size);
+		tmpFreq.resize(size);
+	}
+
+	void fft(const Sample *time, Complex *freq) {
+		for (size_t i = 0; i < tmpTime.size(); ++i) {
+			tmpTime[i] = time[i];
+		}
+		complexFft.fft(tmpTime.data(), tmpFreq.data());
+		for (size_t i = 0; i < tmpFreq.size()/2; ++i) {
+			freq[i] = tmpFreq[i];
+		}
+		freq[0] = {
+			tmpFreq[0].real(),
+			tmpFreq[tmpFreq.size()/2].real()
+		};
+	}
+	void fft(const Sample *inR, Sample *outR, Sample *outI) {
+		Sample *tmpFreqR = (Sample *)tmpFreq.data(), *tmpFreqI = tmpFreqR + tmpFreq.size();
+		for (size_t i = 0; i < tmpTime.size()/2; ++i) {
+			tmpTime[i] = 0;
+		}
+		complexFft.fft(inR, (const Sample *)tmpTime.data(), tmpFreqR, tmpFreqI);
+		for (size_t i = 0; i < tmpTime.size()/2; ++i) {
+			outR[i] = tmpFreqR[i];
+			outI[i] = tmpFreqI[i];
+		}
+		outI[0] = tmpFreqR[tmpFreq.size()/2];
+	}
+
+	void ifft(const Complex *freq, Sample *time) {
+		tmpFreq[0] = freq[0].real();
+		tmpFreq[tmpFreq.size()/2] = freq[0].imag();
+		for (size_t i = 1; i < tmpFreq.size()/2; ++i) {
+			tmpFreq[i] = freq[i];
+			tmpFreq[tmpFreq.size() - i] = std::conj(freq[i]);
+		}
+		complexFft.ifft(tmpFreq.data(), tmpTime.data());
+		for (size_t i = 0; i < tmpTime.size(); ++i) {
+			time[i] = tmpTime[i].real();
+		}
+	}
+	void ifft(const Sample *inR, const Sample *inI, Sample *outR) {
+		Sample *tmpFreqR = (Sample *)tmpFreq.data(), *tmpFreqI = tmpFreqR + tmpFreq.size();
+		tmpFreqR[0] = inR[0];
+		tmpFreqR[tmpFreq.size()/2] = inI[0];
+		tmpFreqI[0] = 0;
+		tmpFreqI[tmpFreq.size()/2] = 0;
+		for (size_t i = 1; i < tmpFreq.size()/2; ++i) {
+			tmpFreqR[i] = inR[i];
+			tmpFreqI[i] = inI[i];
+			tmpFreqR[tmpFreq.size() - i] = inR[i];
+			tmpFreqI[tmpFreq.size() - i] = -inI[i];
+		}
+		complexFft.ifft(tmpFreqR, tmpFreqI, outR, (Sample *)tmpTime.data());
+	}
+
+private:
+	ComplexFFT complexFft;
+	std::vector<Complex> tmpTime, tmpFreq;
+};
+
+/// A default power-of-2 FFT, specialised with platform-specific fast implementations where available
+template<typename Sample>
+struct Pow2RealFFT : public SimpleRealFFT<Sample> {
+	static constexpr bool prefersSplit = SimpleRealFFT<Sample>::prefersSplit;
+
+	using SimpleRealFFT<Sample>::SimpleRealFFT;
+
+	// Prevent copying, since it might be a problem for specialisations
+	Pow2RealFFT(const Pow2RealFFT &other) = delete;
+	// Pass move-constructor through, just to be explicit about it
+	Pow2RealFFT(Pow2RealFFT &&other) : SimpleRealFFT<Sample>(std::move(other)) {}
+};
+
 /// A Real FFT which can handle multiples of 3 and 5, and can be computed in chunks
 template<typename Sample, bool splitComputation=false, bool halfBinShift=false>
 struct RealFFT {
@@ -1048,6 +1059,7 @@ struct RealFFT {
 				}
 			}
 		} else {
+			bool canUseTime = !halfBinShift && !(size_t(time)%alignof(Complex));
 			if (step-- == 0) {
 				size_t hSize = complexFft.size();
 				if (halfBinShift) {
@@ -1059,13 +1071,11 @@ struct RealFFT {
 							ti*twist.real() + tr*twist.imag()
 						};
 					}
-				} else {
-					for (size_t i = 0; i < hSize; ++i) {
-						tmpTime[i] = {time[2*i], time[2*i + 1]};
-					}
+				} else if (!canUseTime) {
+					std::memcpy(tmpTime.data(), time, sizeof(Complex)*hSize);
 				}
 			} else if (step < complexFft.steps()) {
-				complexFft.fft(step, tmpTime.data(), tmpFreq.data());
+				complexFft.fft(step, canUseTime ? (const Complex *)time : tmpTime.data(), tmpFreq.data());
 			} else {
 				if (!halfBinShift) {
 					Complex bin0 = tmpFreq[0];
@@ -1225,6 +1235,7 @@ struct RealFFT {
 				}
 			}
 		} else {
+			bool canUseTime = !halfBinShift && !(size_t(time)%alignof(Complex));
 			bool splitFirst = splitComputation && (step-- == 0);
 			if (splitFirst || step-- == 0) {
 				Complex bin0 = freq[0];
@@ -1260,7 +1271,7 @@ struct RealFFT {
 				}
 			} else if (step < complexFft.steps()) {
 				// Can't just use time as (Complex *), since it might not be aligned properly
-				complexFft.ifft(step, tmpFreq.data(), tmpTime.data());
+				complexFft.ifft(step, tmpFreq.data(), canUseTime ? (Complex *)time : tmpTime.data());
 			} else {
 				size_t hSize = complexFft.size();
 				if (halfBinShift) {
@@ -1270,11 +1281,8 @@ struct RealFFT {
 						time[2*i] = 	t.real()*twist.real() + t.imag()*twist.imag();
 						time[2*i + 1] = t.imag()*twist.real() - t.real()*twist.imag();
 					}
-				} else {
-					for (size_t i = 0; i < hSize; ++i) {
-						time[2*i] = tmpTime[i].real();
-						time[2*i + 1] = tmpTime[i].imag();
-					}
+				} else if (!canUseTime) {
+					std::memcpy(time, tmpTime.data(), sizeof(Complex)*hSize);
 				}
 			}
 		}
@@ -1343,12 +1351,12 @@ struct RealFFT {
 		}
 	}
 private:
-	static constexpr bool complexPrefersSplit = SplitFFT<Sample, splitComputation>::prefersSplit;
-	std::vector<Complex> tmpFreq, tmpTime;
-	std::vector<Complex> twiddles, halfBinTwists;
-
 	using ComplexFFT = SplitFFT<Sample, splitComputation>;
 	ComplexFFT complexFft;
+
+	static constexpr bool complexPrefersSplit = ComplexFFT::prefersSplit;
+	std::vector<Complex> tmpFreq, tmpTime;
+	std::vector<Complex> twiddles, halfBinTwists;
 };
 
 template<typename Sample, bool splitComputation=false>
@@ -1356,9 +1364,17 @@ using ModifiedRealFFT = RealFFT<Sample, splitComputation, true>;
 
 }} // namespace
 
-// Platform-specific
-#if defined(HAVE_ACCELERATE)
-#	include <audioapi/libs/signalsmith-stretch/fft-accelerate.h>
+// Override `Pow2FFT` / `Pow2RealFFT` templates with faster implementations
+#include <audioapi/libs/signalsmith-stretch/fft-pffft.h>
+#if defined(SIGNALSMITH_USE_PFFFT) || defined(SIGNALSMITH_USE_PFFFT_DOUBLE)
+#	if defined(SIGNALSMITH_USE_PFFFT)
+#		include "./platform/fft-pffft.h"
+#	endif
+#	if defined(SIGNALSMITH_USE_PFFFT_DOUBLE)
+#		include "./platform/fft-pffft-double.h"
+#	endif
+#elif defined(SIGNALSMITH_USE_ACCELERATE)
+#	include "./platform/fft-accelerate.h"
 #elif defined(SIGNALSMITH_USE_IPP)
 #	include "./platform/fft-ipp.h"
 #endif