react-native-audio-api 0.4.10 → 0.4.12-beta.1

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

@@ -0,0 +1,436 @@
+#include "./common.h"
+
+#ifndef SIGNALSMITH_DSP_FILTERS_H
+#define SIGNALSMITH_DSP_FILTERS_H
+
+#include "./perf.h"
+
+#include <cmath>
+#include <complex>
+
+namespace signalsmith {
+namespace filters {
+	/**	@defgroup Filters Basic filters
+		@brief Classes for some common filter types
+		
+		@{
+		@file
+	*/
+	
+	/** Filter design methods.
+		These differ mostly in how they handle frequency-warping near Nyquist:
+		\diagram{filters-lowpass.svg}
+		\diagram{filters-highpass.svg}
+		\diagram{filters-peak.svg}
+		\diagram{filters-bandpass.svg}
+		\diagram{filters-notch.svg}
+		\diagram{filters-high-shelf.svg}
+		\diagram{filters-low-shelf.svg}
+		\diagram{filters-allpass.svg}
+	*/
+	enum class BiquadDesign {
+		bilinear, ///< Bilinear transform, adjusting for centre frequency but not bandwidth
+ 		cookbook, ///< RBJ's "Audio EQ Cookbook".  Based on `bilinear`, adjusting bandwidth (for peak/notch/bandpass) to preserve the ratio between upper/lower boundaries.  This performs oddly near Nyquist.
+		oneSided, ///< Based on `bilinear`, adjusting bandwidth to preserve the lower boundary (leaving the upper one loose).
+		vicanek ///< From Martin Vicanek's [Matched Second Order Digital Filters](https://vicanek.de/articles/BiquadFits.pdf).  Falls back to `oneSided` for shelf and allpass filters.  This takes the poles from the impulse-invariant approach, and then picks the zeros to create a better match.  This means that Nyquist is not 0dB for peak/notch (or -Inf for lowpass), but it is a decent match to the analogue prototype.
+	};
+	
+	/** A standard biquad.
+
+		This is not guaranteed to be stable if modulated at audio rate.
+		
+		The default highpass/lowpass bandwidth (`defaultBandwidth`) produces a Butterworth filter when bandwidth-compensation is disabled.
+		
+		Bandwidth compensation defaults to `BiquadDesign::oneSided` (or `BiquadDesign::cookbook` if `cookbookBandwidth` is enabled) for all filter types aside from highpass/lowpass (which use `BiquadDesign::bilinear`).*/
+	template<typename Sample, bool cookbookBandwidth=false>
+	class BiquadStatic {
+		static constexpr BiquadDesign bwDesign = cookbookBandwidth ? BiquadDesign::cookbook : BiquadDesign::oneSided;
+		Sample a1 = 0, a2 = 0, b0 = 1, b1 = 0, b2 = 0;
+		Sample x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+		
+		enum class Type {highpass, lowpass, highShelf, lowShelf, bandpass, notch, peak, allpass};
+
+		struct FreqSpec {
+			double scaledFreq;
+			double w0, sinW0, cosW0;
+			double inv2Q;
+			
+			FreqSpec(double freq, BiquadDesign design) {
+				scaledFreq = std::max(1e-6, std::min(0.4999, freq));
+				if (design == BiquadDesign::cookbook) {
+					scaledFreq = std::min(0.45, scaledFreq);
+				}
+				w0 = 2*M_PI*scaledFreq;
+				cosW0 = std::cos(w0);
+				sinW0 = std::sin(w0);
+			}
+			
+			void oneSidedCompQ() {
+				// Ratio between our (digital) lower boundary f1 and centre f0
+				double f1Factor = std::sqrt(inv2Q*inv2Q + 1) - inv2Q;
+				// Bilinear means discrete-time freq f = continuous-time freq tan(pi*xf/pi)
+				double ctF1 = std::tan(M_PI*scaledFreq*f1Factor), invCtF0 = (1 + cosW0)/sinW0;
+				double ctF1Factor = ctF1*invCtF0;
+				inv2Q = 0.5/ctF1Factor - 0.5*ctF1Factor;
+			}
+		};
+		SIGNALSMITH_INLINE static FreqSpec octaveSpec(double scaledFreq, double octaves, BiquadDesign design) {
+			FreqSpec spec(scaledFreq, design);
+
+			if (design == BiquadDesign::cookbook) {
+				// Approximately preserves bandwidth between halfway points
+				octaves *= spec.w0/spec.sinW0;
+			}
+			spec.inv2Q = std::sinh(std::log(2)*0.5*octaves); // 1/(2Q)
+			if (design == BiquadDesign::oneSided) spec.oneSidedCompQ();
+			return spec;
+		}
+		SIGNALSMITH_INLINE static FreqSpec qSpec(double scaledFreq, double q, BiquadDesign design) {
+			FreqSpec spec(scaledFreq, design);
+
+			spec.inv2Q = 0.5/q;
+			if (design == BiquadDesign::oneSided) spec.oneSidedCompQ();
+			return spec;
+		}
+		
+		SIGNALSMITH_INLINE double dbToSqrtGain(double db) {
+			return std::pow(10, db*0.025);
+		}
+		
+		SIGNALSMITH_INLINE BiquadStatic & configure(Type type, FreqSpec calc, double sqrtGain, BiquadDesign design) {
+			double w0 = calc.w0;
+			
+			if (design == BiquadDesign::vicanek) {
+				if (type == Type::notch) { // Heuristic for notches near Nyquist
+					calc.inv2Q *= (1 - calc.scaledFreq*0.5);
+				}
+				double Q = (type == Type::peak ? 0.5*sqrtGain : 0.5)/calc.inv2Q;
+				double q = (type == Type::peak ? 1/sqrtGain : 1)*calc.inv2Q;
+				double expmqw = std::exp(-q*w0);
+				double da1, da2;
+				if (q <= 1) {
+					a1 = da1 = -2*expmqw*std::cos(std::sqrt(1 - q*q)*w0);
+				} else {
+					a1 = da1 = -2*expmqw*std::cosh(std::sqrt(q*q - 1)*w0);
+				}
+				a2 = da2 = expmqw*expmqw;
+				double sinpd2 = std::sin(w0/2);
+				double p0 = 1 - sinpd2*sinpd2, p1 = sinpd2*sinpd2, p2 = 4*p0*p1;
+				double A0 = 1 + da1 + da2, A1 = 1 - da1 + da2, A2 = -4*da2;
+				A0 *= A0;
+				A1 *= A1;
+				if (type == Type::lowpass) {
+					double R1 = (A0*p0 + A1*p1 + A2*p2)*Q*Q;
+					double B0 = A0, B1 = (R1 - B0*p0)/p1;
+					b0 = 0.5*(std::sqrt(B0) + std::sqrt(std::max(0.0, B1)));
+					b1 = std::sqrt(B0) - b0;
+					b2 = 0;
+					return *this;
+				} else if (type == Type::highpass) {
+					b2 = b0 = std::sqrt(A0*p0 + A1*p1 + A2*p2)*Q/(4*p1);
+					b1 = -2*b0;
+					return *this;
+				} else if (type == Type::bandpass) {
+					double R1 = A0*p0 + A1*p1 + A2*p2;
+					double R2 = -A0 + A1 + 4*(p0 - p1)*A2;
+					double B2 = (R1 - R2*p1)/(4*p1*p1);
+					double B1 = R2 + 4*(p1 - p0)*B2;
+					b1 = -0.5*std::sqrt(std::max(0.0, B1));
+					b0 = 0.5*(std::sqrt(std::max(0.0, B2 + 0.25*B1)) - b1);
+					b2 = -b0 - b1;
+					return *this;
+				} else if (type == Type::notch) {
+					// The Vicanek paper doesn't cover notches (band-stop), but we know where the zeros should be:
+					b0 = 1;
+					double db1 = -2*std::cos(w0); // might be higher precision
+					b1 = db1;
+					b2 = 1;
+					// Scale so that B0 == A0 to get 0dB at f=0
+					double scale = std::sqrt(A0)/(b0 + db1 + b2);
+					b0 *= scale;
+					b1 *= scale;
+					b2 *= scale;
+					return *this;
+				} else if (type == Type::peak) {
+					double G2 = (sqrtGain*sqrtGain)*(sqrtGain*sqrtGain);
+					double R1 = (A0*p0 + A1*p1 + A2*p2)*G2;
+					double R2 = (-A0 + A1 + 4*(p0 - p1)*A2)*G2;
+					double B0 = A0;
+					double B2 = (R1 - R2*p1 - B0)/(4*p1*p1);
+					double B1 = R2 + B0 + 4*(p1 - p0)*B2;
+					double W = 0.5*(std::sqrt(B0) + std::sqrt(std::max(0.0, B1)));
+					b0 = 0.5*(W + std::sqrt(std::max(0.0, W*W + B2)));
+					b1 = 0.5*(std::sqrt(B0) - std::sqrt(std::max(0.0, B1)));
+					b2 = -B2/(4*b0);
+					return *this;
+				}
+				// All others fall back to `oneSided`
+				design = BiquadDesign::oneSided;
+				calc.oneSidedCompQ();
+			}
+
+			double alpha = calc.sinW0*calc.inv2Q;
+			double A = sqrtGain, sqrtA2alpha = 2*std::sqrt(A)*alpha;
+
+			double a0;
+			if (type == Type::highpass) {
+				b1 = -1 - calc.cosW0;
+				b0 = b2 = (1 + calc.cosW0)*0.5;
+				a0 = 1 + alpha;
+				a1 = -2*calc.cosW0;
+				a2 = 1 - alpha;
+			} else if (type == Type::lowpass) {
+				b1 = 1 - calc.cosW0;
+				b0 = b2 = b1*0.5;
+				a0 = 1 + alpha;
+				a1 = -2*calc.cosW0;
+				a2 = 1 - alpha;
+			} else if (type == Type::highShelf) {
+				b0 = A*((A+1)+(A-1)*calc.cosW0+sqrtA2alpha);
+				b2 = A*((A+1)+(A-1)*calc.cosW0-sqrtA2alpha);
+				b1 = -2*A*((A-1)+(A+1)*calc.cosW0);
+				a0 = (A+1)-(A-1)*calc.cosW0+sqrtA2alpha;
+				a2 = (A+1)-(A-1)*calc.cosW0-sqrtA2alpha;
+				a1 = 2*((A-1)-(A+1)*calc.cosW0);
+			} else if (type == Type::lowShelf) {
+				b0 = A*((A+1)-(A-1)*calc.cosW0+sqrtA2alpha);
+				b2 = A*((A+1)-(A-1)*calc.cosW0-sqrtA2alpha);
+				b1 = 2*A*((A-1)-(A+1)*calc.cosW0);
+				a0 = (A+1)+(A-1)*calc.cosW0+sqrtA2alpha;
+				a2 = (A+1)+(A-1)*calc.cosW0-sqrtA2alpha;
+				a1 = -2*((A-1)+(A+1)*calc.cosW0);
+			} else if (type == Type::bandpass) {
+				b0 = alpha;
+				b1 = 0;
+				b2 = -alpha;
+				a0 = 1 + alpha;
+				a1 = -2*calc.cosW0;
+				a2 = 1 - alpha;
+			} else if (type == Type::notch) {
+				b0 = 1;
+				b1 = -2*calc.cosW0;
+				b2 = 1;
+				a0 = 1 + alpha;
+				a1 = b1;
+				a2 = 1 - alpha;
+			} else if (type == Type::peak) {
+				b0 = 1 + alpha*A;
+				b1 = -2*calc.cosW0;
+				b2 = 1 - alpha*A;
+				a0 = 1 + alpha/A;
+				a1 = b1;
+				a2 = 1 - alpha/A;
+			} else if (type == Type::allpass) {
+				a0 = b2 = 1 + alpha;
+				a1 = b1 = -2*calc.cosW0;
+				a2 = b0 = 1 - alpha;
+			} else {
+				// reset to neutral
+				a1 = a2 = b1 = b2 = 0;
+				a0 = b0 = 1;
+			}
+			double invA0 = 1/a0;
+			b0 *= invA0;
+			b1 *= invA0;
+			b2 *= invA0;
+			a1 *= invA0;
+			a2 *= invA0;
+			return *this;
+		}
+	public:
+		static constexpr double defaultQ = 0.7071067811865476; // sqrt(0.5)
+		static constexpr double defaultBandwidth = 1.8999686269529916; // equivalent to above Q
+
+		Sample operator ()(Sample x0) {
+			Sample y0 = x0*b0 + x1*b1 + x2*b2 - y1*a1 - y2*a2;
+			y2 = y1;
+			y1 = y0;
+			x2 = x1;
+			x1 = x0;
+			return y0;
+		}
+		
+		void reset() {
+			x1 = x2 = y1 = y2 = 0;
+		}
+		
+		std::complex<Sample> response(Sample scaledFreq) const {
+			Sample w = scaledFreq*Sample(2*M_PI);
+			std::complex<Sample> invZ = {std::cos(w), -std::sin(w)}, invZ2 = invZ*invZ;
+			return (b0 + invZ*b1 + invZ2*b2)/(Sample(1) + invZ*a1 + invZ2*a2);
+		}
+		Sample responseDb(Sample scaledFreq) const {
+			Sample w = scaledFreq*Sample(2*M_PI);
+			std::complex<Sample> invZ = {std::cos(w), -std::sin(w)}, invZ2 = invZ*invZ;
+			Sample energy = std::norm(b0 + invZ*b1 + invZ2*b2)/std::norm(Sample(1) + invZ*a1 + invZ2*a2);
+			return 10*std::log10(energy);
+		}
+
+		/// @name Lowpass
+		/// @{
+		BiquadStatic & lowpass(double scaledFreq, double octaves=defaultBandwidth, BiquadDesign design=BiquadDesign::bilinear) {
+			return configure(Type::lowpass, octaveSpec(scaledFreq, octaves, design), 0, design);
+		}
+		BiquadStatic & lowpassQ(double scaledFreq, double q, BiquadDesign design=BiquadDesign::bilinear) {
+			return configure(Type::lowpass, qSpec(scaledFreq, q, design), 0, design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		void lowpass(double scaledFreq, double octaves, bool correctBandwidth) {
+			lowpass(scaledFreq, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated By the time you care about `design`, you should care about the bandwidth
+		BiquadStatic & lowpass(double scaledFreq, BiquadDesign design) {
+			return lowpass(scaledFreq, defaultBandwidth, design);
+		}
+		/// @}
+		
+		/// @name Highpass
+		/// @{
+		BiquadStatic & highpass(double scaledFreq, double octaves=defaultBandwidth, BiquadDesign design=BiquadDesign::bilinear) {
+			return configure(Type::highpass, octaveSpec(scaledFreq, octaves, design), 0, design);
+		}
+		BiquadStatic & highpassQ(double scaledFreq, double q, BiquadDesign design=BiquadDesign::bilinear) {
+			return configure(Type::highpass, qSpec(scaledFreq, q, design), 0, design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		void highpass(double scaledFreq, double octaves, bool correctBandwidth) {
+			highpass(scaledFreq, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated By the time you care about `design`, you should care about the bandwidth
+		BiquadStatic & highpass(double scaledFreq, BiquadDesign design) {
+			return highpass(scaledFreq, defaultBandwidth, design);
+		}
+		/// @}
+
+		/// @name Bandpass
+		/// @{
+		BiquadStatic & bandpass(double scaledFreq, double octaves=defaultBandwidth, BiquadDesign design=bwDesign) {
+			return configure(Type::bandpass, octaveSpec(scaledFreq, octaves, design), 0, design);
+		}
+		BiquadStatic & bandpassQ(double scaledFreq, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::bandpass, qSpec(scaledFreq, q, design), 0, design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		void bandpass(double scaledFreq, double octaves, bool correctBandwidth) {
+			bandpass(scaledFreq, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated By the time you care about `design`, you should care about the bandwidth
+		BiquadStatic & bandpass(double scaledFreq, BiquadDesign design) {
+			return bandpass(scaledFreq, defaultBandwidth, design);
+		}
+		/// @}
+
+		/// @name Notch
+		/// @{
+		BiquadStatic & notch(double scaledFreq, double octaves=defaultBandwidth, BiquadDesign design=bwDesign) {
+			return configure(Type::notch, octaveSpec(scaledFreq, octaves, design), 0, design);
+		}
+		BiquadStatic & notchQ(double scaledFreq, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::notch, qSpec(scaledFreq, q, design), 0, design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		void notch(double scaledFreq, double octaves, bool correctBandwidth) {
+			notch(scaledFreq, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated By the time you care about `design`, you should care about the bandwidth
+		BiquadStatic & notch(double scaledFreq, BiquadDesign design) {
+			return notch(scaledFreq, defaultBandwidth, design);
+		}
+		/// @deprecated alias for `.notch()`
+		void bandStop(double scaledFreq, double octaves=1, bool correctBandwidth=true) {
+			notch(scaledFreq, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @}
+
+		/// @name Peak
+		/// @{
+		BiquadStatic & peak(double scaledFreq, double gain, double octaves=1, BiquadDesign design=bwDesign) {
+			return configure(Type::peak, octaveSpec(scaledFreq, octaves, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & peakDb(double scaledFreq, double db, double octaves=1, BiquadDesign design=bwDesign) {
+			return configure(Type::peak, octaveSpec(scaledFreq, octaves, design), dbToSqrtGain(db), design);
+		}
+		BiquadStatic & peakQ(double scaledFreq, double gain, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::peak, qSpec(scaledFreq, q, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & peakDbQ(double scaledFreq, double db, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::peak, qSpec(scaledFreq, q, design), dbToSqrtGain(db), design);
+		}
+		/// @deprecated By the time you care about `design`, you should care about the bandwidth
+		BiquadStatic & peak(double scaledFreq, double gain, BiquadDesign design) {
+			return peak(scaledFreq, gain, 1, design);
+		}
+		/// @}
+
+		/// @name High shelf
+		/// @{
+		BiquadStatic & highShelf(double scaledFreq, double gain, double octaves=defaultBandwidth, BiquadDesign design=bwDesign) {
+			return configure(Type::highShelf, octaveSpec(scaledFreq, octaves, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & highShelfDb(double scaledFreq, double db, double octaves=defaultBandwidth, BiquadDesign design=bwDesign) {
+			return configure(Type::highShelf, octaveSpec(scaledFreq, octaves, design), dbToSqrtGain(db), design);
+		}
+		BiquadStatic & highShelfQ(double scaledFreq, double gain, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::highShelf, qSpec(scaledFreq, q, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & highShelfDbQ(double scaledFreq, double db, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::highShelf, qSpec(scaledFreq, q, design), dbToSqrtGain(db), design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		BiquadStatic & highShelf(double scaledFreq, double gain, double octaves, bool correctBandwidth) {
+			return highShelf(scaledFreq, gain, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		BiquadStatic & highShelfDb(double scaledFreq, double db, double octaves, bool correctBandwidth) {
+			return highShelfDb(scaledFreq, db, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @}
+
+		/// @name Low shelf
+		/// @{
+		BiquadStatic & lowShelf(double scaledFreq, double gain, double octaves=2, BiquadDesign design=bwDesign) {
+			return configure(Type::lowShelf, octaveSpec(scaledFreq, octaves, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & lowShelfDb(double scaledFreq, double db, double octaves=2, BiquadDesign design=bwDesign) {
+			return configure(Type::lowShelf, octaveSpec(scaledFreq, octaves, design), dbToSqrtGain(db), design);
+		}
+		BiquadStatic & lowShelfQ(double scaledFreq, double gain, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::lowShelf, qSpec(scaledFreq, q, design), std::sqrt(gain), design);
+		}
+		BiquadStatic & lowShelfDbQ(double scaledFreq, double db, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::lowShelf, qSpec(scaledFreq, q, design), dbToSqrtGain(db), design);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		BiquadStatic & lowShelf(double scaledFreq, double gain, double octaves, bool correctBandwidth) {
+			return lowShelf(scaledFreq, gain, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @deprecated use `BiquadDesign` instead
+		BiquadStatic & lowShelfDb(double scaledFreq, double db, double octaves, bool correctBandwidth) {
+			return lowShelfDb(scaledFreq, db, octaves, correctBandwidth ? bwDesign : BiquadDesign::bilinear);
+		}
+		/// @}
+		
+		/// @name Allpass
+		/// @{
+		BiquadStatic & allpass(double scaledFreq, double octaves=1, BiquadDesign design=bwDesign) {
+			return configure(Type::allpass, octaveSpec(scaledFreq, octaves, design), 0, design);
+		}
+		BiquadStatic & allpassQ(double scaledFreq, double q, BiquadDesign design=bwDesign) {
+			return configure(Type::allpass, qSpec(scaledFreq, q, design), 0, design);
+		}
+		/// @}
+
+		BiquadStatic & addGain(double factor) {
+			b0 *= factor;
+			b1 *= factor;
+			b2 *= factor;
+			return *this;
+		}
+		BiquadStatic & addGainDb(double db) {
+			return addGain(std::pow(10, db*0.05));
+		}
+	};
+
+	/** @} */
+}} // signalsmith::filters::
+#endif // include guard

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

@@ -0,0 +1,218 @@
+#include "./common.h"
+
+#ifndef SIGNALSMITH_DSP_MULTI_CHANNEL_H
+#define SIGNALSMITH_DSP_MULTI_CHANNEL_H
+
+#include <array>
+
+namespace signalsmith {
+namespace mix {
+	/**	@defgroup Mix Multichannel mixing
+		@brief Utilities for stereo/multichannel mixing operations
+
+		@{
+		@file
+	*/
+
+	/** @defgroup Matrices Orthogonal matrices
+		@brief Some common matrices used for audio
+		@ingroup Mix
+		@{ */
+
+	/// @brief Hadamard: high mixing levels, N log(N) operations
+	template<typename Sample, int size=-1>
+	class Hadamard {
+	public:
+		static_assert(size >= 0, "Size must be positive (or -1 for dynamic)");
+		/// Applies the matrix, scaled so it's orthogonal
+		template<class Data>
+		static void inPlace(Data &&data) {
+			unscaledInPlace(data);
+			
+			Sample factor = scalingFactor();
+			for (int c = 0; c < size; ++c) {
+				data[c] *= factor;
+			}
+		}
+
+		/// Scaling factor applied to make it orthogonal
+		static Sample scalingFactor() {
+			/// TODO: test for C++20, or whatever makes this constexpr.  Maybe a `#define` in `common.h`?
+			return std::sqrt(Sample(1)/(size ? size : 1));
+		}
+
+		/// Skips the scaling, so it's a matrix full of `1`s
+		template<class Data, int startIndex=0>
+		static void unscaledInPlace(Data &&data) {
+			if (size <= 1) return;
+			constexpr int hSize = size/2;
+
+			Hadamard<Sample, hSize>::template unscaledInPlace<Data, startIndex>(data);
+			Hadamard<Sample, hSize>::template unscaledInPlace<Data, startIndex + hSize>(data);
+
+			for (int i = 0; i < hSize; ++i) {
+				Sample a = data[i + startIndex], b = data[i + startIndex + hSize];
+				data[i + startIndex] = (a + b);
+				data[i + startIndex + hSize] = (a - b);
+			}
+		}
+	};
+	/// @brief Hadamard with dynamic size
+	template<typename Sample>
+	class Hadamard<Sample, -1> {
+		int size;
+	public:
+		Hadamard(int size) : size(size) {}
+		
+		/// Applies the matrix, scaled so it's orthogonal
+		template<class Data>
+		void inPlace(Data &&data) const {
+			unscaledInPlace(data);
+			
+			Sample factor = scalingFactor();
+			for (int c = 0; c < size; ++c) {
+				data[c] *= factor;
+			}
+		}
+
+		/// Scaling factor applied to make it orthogonal
+		Sample scalingFactor() const {
+			return std::sqrt(Sample(1)/(size ? size : 1));
+		}
+
+		/// Skips the scaling, so it's a matrix full of `1`s
+		template<class Data>
+		void unscaledInPlace(Data &&data) const {
+			int hSize = size/2;
+			while (hSize > 0) {
+				for (int startIndex = 0; startIndex < size; startIndex += hSize*2) {
+					for (int i = startIndex; i < startIndex + hSize; ++i) {
+						Sample a = data[i], b = data[i + hSize];
+						data[i] = (a + b);
+						data[i + hSize] = (a - b);
+					}
+				}
+				hSize /= 2;
+			}
+		}
+	};
+	/// @brief Householder: moderate mixing, 2N operations
+	template<typename Sample, int size=-1>
+	class Householder {
+	public:
+		static_assert(size >= 0, "Size must be positive (or -1 for dynamic)");
+		template<class Data>
+		static void inPlace(Data &&data) {
+			if (size < 1) return;
+			/// TODO: test for C++20, which makes `std::complex::operator/` constexpr
+			const Sample factor = Sample(-2)/Sample(size ? size : 1);
+
+			Sample sum = data[0];
+			for (int i = 1; i < size; ++i) {
+				sum += data[i];
+			}
+			sum *= factor;
+			for (int i = 0; i < size; ++i) {
+				data[i] += sum;
+			}
+		}
+		/// @deprecated The matrix is already orthogonal, but this is here for compatibility with Hadamard
+		constexpr static Sample scalingFactor() {
+			return 1;
+		}
+	};
+	/// @brief Householder with dynamic size
+	template<typename Sample>
+	class Householder<Sample, -1> {
+		int size;
+	public:
+		Householder(int size) : size(size) {}
+	
+		template<class Data>
+		void inPlace(Data &&data) const {
+			if (size < 1) return;
+			const Sample factor = Sample(-2)/Sample(size ? size : 1);
+
+			Sample sum = data[0];
+			for (int i = 1; i < size; ++i) {
+				sum += data[i];
+			}
+			sum *= factor;
+			for (int i = 0; i < size; ++i) {
+				data[i] += sum;
+			}
+		}
+		/// @deprecated The matrix is already orthogonal, but this is here for compatibility with Hadamard
+		constexpr static Sample scalingFactor() {
+			return 1;
+		}
+	};
+	///  @}
+	
+	/** @brief Upmix/downmix a stereo signal to an (even) multi-channel signal
+		
+		When spreading out, it rotates the input by various amounts (e.g. a four-channel signal would produce `(left, right, mid side)`), such that energy is preserved for each pair.
+		
+		When mixing together, it uses the opposite rotations, such that upmix → downmix produces the same stereo signal (when scaled by `.scalingFactor1()`.
+	*/
+	template<typename Sample, int channels>
+	class StereoMultiMixer {
+		static_assert((channels/2)*2 == channels, "StereoMultiMixer must have an even number of channels");
+		static_assert(channels > 0, "StereoMultiMixer must have a positive number of channels");
+		static constexpr int hChannels = channels/2;
+		std::array<Sample, channels> coeffs;
+	public:
+		StereoMultiMixer() {
+			coeffs[0] = 1;
+			coeffs[1] = 0;
+			for (int i = 1; i < hChannels; ++i) {
+				double phase = M_PI*i/channels;
+				coeffs[2*i] = std::cos(phase);
+				coeffs[2*i + 1] = std::sin(phase);
+			}
+		}
+		
+		template<class In, class Out>
+		void stereoToMulti(In &input, Out &output) const {
+			output[0] = input[0];
+			output[1] = input[1];
+			for (int i = 2; i < channels; i += 2) {
+				output[i] = input[0]*coeffs[i] + input[1]*coeffs[i + 1];
+				output[i + 1] = input[1]*coeffs[i] - input[0]*coeffs[i + 1];
+			}
+		}
+		template<class In, class Out>
+		void multiToStereo(In &input, Out &output) const {
+			output[0] = input[0];
+			output[1] = input[1];
+			for (int i = 2; i < channels; i += 2) {
+				output[0] += input[i]*coeffs[i] - input[i + 1]*coeffs[i + 1];
+				output[1] += input[i + 1]*coeffs[i] + input[i]*coeffs[i + 1];
+			}
+		}
+		/// Scaling factor for the downmix, if channels are phase-aligned
+		static constexpr Sample scalingFactor1() {
+			return 2/Sample(channels);
+		}
+		/// Scaling factor for the downmix, if channels are independent
+		static Sample scalingFactor2() {
+			return std::sqrt(scalingFactor1());
+		}
+	};
+	
+	/// A cheap (polynomial) almost-energy-preserving crossfade
+	/// Maximum energy error: 1.06%, average 0.64%, curves overshoot by 0.3%
+	/// See: http://signalsmith-audio.co.uk/writing/2021/cheap-energy-crossfade/
+	template<typename Sample, typename Result>
+	void cheapEnergyCrossfade(Sample x, Result &toCoeff, Result &fromCoeff) {
+		Sample x2 = 1 - x;
+		// Other powers p can be approximated by: k = -6.0026608 + p*(6.8773512 - 1.5838104*p)
+		Sample A = x*x2, B = A*(1 + (Sample)1.4186*A);
+		Sample C = (B + x), D = (B + x2);
+		toCoeff = C*C;
+		fromCoeff = D*D;
+	}
+
+/** @} */
+}} // signalsmith::delay::
+#endif // include guard