react-native-audio-api 0.5.5 → 0.6.0-rc.0

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

@@ -0,0 +1,625 @@
+#ifndef SIGNALSMITH_AUDIO_LINEAR_STFT_H
+#define SIGNALSMITH_AUDIO_LINEAR_STFT_H
+
+#include <audioapi/libs/signalsmith-stretch/fft.h>
+
+namespace signalsmith { namespace linear {
+
+/// A self-normalising STFT, with variable position/window for output blocks
+template<typename Sample, bool splitComputation=false, bool modified=false>
+struct DynamicSTFT {
+	RealFFT<Sample, splitComputation, modified> fft;
+
+	using Complex = std::complex<Sample>;
+
+	enum class WindowShape {ignore, acg, kaiser};
+	static constexpr WindowShape acg = WindowShape::acg;
+	static constexpr WindowShape kaiser = WindowShape::kaiser;
+
+	void configure(size_t inChannels, size_t outChannels, size_t blockSamples, size_t extraInputHistory=0, size_t intervalSamples=0) {
+		_analysisChannels = inChannels;
+		_synthesisChannels = outChannels;
+		_blockSamples = blockSamples;
+		_fftSamples = fft.fastSizeAbove((blockSamples + 1)/2)*2;
+		fft.resize(_fftSamples);
+		_fftBins = _fftSamples/2;
+
+		_inputLengthSamples = _blockSamples + extraInputHistory;
+		input.buffer.resize(_inputLengthSamples*_analysisChannels);
+
+		output.buffer.resize(_blockSamples*_synthesisChannels);
+		output.windowProducts.resize(_blockSamples);
+		spectrumBuffer.resize(_fftBins*std::max(_analysisChannels, _synthesisChannels));
+		timeBuffer.resize(_fftSamples);
+
+		_analysisWindow.resize(_blockSamples);
+		_synthesisWindow.resize(_blockSamples);
+		setInterval(intervalSamples ? intervalSamples : blockSamples/4, acg);
+
+		reset();
+	}
+
+	size_t blockSamples() const {
+		return _blockSamples;
+	}
+	size_t fftSamples() const {
+		return _fftSamples;
+	}
+	size_t defaultInterval() const {
+		return _defaultInterval;
+	}
+	size_t bands() const {
+		return _fftBins;
+	}
+	size_t analysisLatency() const {
+		return _blockSamples - _analysisOffset;
+	}
+	size_t synthesisLatency() const {
+		return _synthesisOffset;
+	}
+	size_t latency() const {
+		return synthesisLatency() + analysisLatency();
+	}
+	Sample binToFreq(Sample b) const {
+		return (modified ? b + Sample(0.5) : b)/_fftSamples;
+	}
+	Sample freqToBin(Sample f) const {
+		return modified ? f*_fftSamples - Sample(0.5) : f*_fftSamples;
+	}
+
+	void reset(Sample productWeight=1) {
+		input.pos = _blockSamples;
+		output.pos = 0;
+		for (auto &v : input.buffer) v = 0;
+		for (auto &v : output.buffer) v = 0;
+		for (auto &v : spectrumBuffer) v = 0;
+		for (auto &v : output.windowProducts) v = 0;
+		addWindowProduct();
+		for (int i = int(_blockSamples) - int(_defaultInterval) - 1; i >= 0; --i) {
+			output.windowProducts[i] += output.windowProducts[i + _defaultInterval];
+		}
+		for (auto &v : output.windowProducts) v = v*productWeight + almostZero;
+		moveOutput(_defaultInterval); // ready for first block immediately
+	}
+
+	void writeInput(size_t channel, size_t offset, size_t length, Sample *inputArray) {
+		Sample *buffer = input.buffer.data() + channel*_inputLengthSamples;
+
+		size_t offsetPos = (input.pos + offset)%_inputLengthSamples;
+		size_t inputWrapIndex = _inputLengthSamples - offsetPos;
+		size_t chunk1 = std::min(length, inputWrapIndex);
+		for (size_t i = 0; i < chunk1; ++i) {
+			size_t i2 = offsetPos + i;
+			buffer[i2] = inputArray[i];
+		}
+		for (size_t i = chunk1; i < length; ++i) {
+			size_t i2 = i + offsetPos -_inputLengthSamples;
+			buffer[i2] = inputArray[i];
+		}
+	}
+	void writeInput(size_t channel, size_t length, Sample *inputArray) {
+		writeInput(channel, 0, length, inputArray);
+	}
+	void moveInput(size_t samples, bool clearInput=false) {
+		if (clearInput) {
+			size_t inputWrapIndex = _inputLengthSamples - input.pos;
+			size_t chunk1 = std::min(samples, inputWrapIndex);
+			for (size_t c = 0; c < _analysisChannels; ++c) {
+				Sample *buffer = input.buffer.data() + c*_inputLengthSamples;
+				for (size_t i = 0; i < chunk1; ++i) {
+					size_t i2 = input.pos + i;
+					buffer[i2] = 0;
+				}
+				for (size_t i = chunk1; i < samples; ++i) {
+					size_t i2 = i + input.pos - _inputLengthSamples;
+					buffer[i2] = 0;
+				}
+			}
+		}
+
+		input.pos = (input.pos + samples)%_inputLengthSamples;
+		_samplesSinceAnalysis += samples;
+	}
+	size_t samplesSinceAnalysis() const {
+		return _samplesSinceAnalysis;
+	}
+
+	/// When no more synthesis is expected, let output taper away to 0 based on windowing.  Otherwise, the output will be scaled as if there's just a very long block interval, which can exaggerate artefacts and numerical errors.  You still can't read more than `blockSamples()` into the future.
+	void finishOutput(Sample strength=1, size_t offset=0) {
+		Sample maxWindowProduct = 0;
+
+		size_t chunk1 = std::max(offset, std::min(_blockSamples, _blockSamples - output.pos));
+
+		for (size_t i = offset; i < chunk1; ++i) {
+			size_t i2 = output.pos + i;
+			Sample &wp = output.windowProducts[i2];
+			maxWindowProduct = std::max(wp, maxWindowProduct);
+			wp += (maxWindowProduct - wp)*strength;
+		}
+		for (size_t i = chunk1; i < _blockSamples; ++i) {
+			size_t i2 = i + output.pos - _blockSamples;
+			Sample &wp = output.windowProducts[i2];
+			maxWindowProduct = std::max(wp, maxWindowProduct);
+			wp += (maxWindowProduct - wp)*strength;
+		}
+	}
+
+	void readOutput(size_t channel, size_t offset, size_t length, Sample *outputArray) {
+		Sample *buffer = output.buffer.data() + channel*_blockSamples;
+		size_t offsetPos = (output.pos + offset)%_blockSamples;
+		size_t outputWrapIndex = _blockSamples - offsetPos;
+		size_t chunk1 = std::min(length, outputWrapIndex);
+		for (size_t i = 0; i < chunk1; ++i) {
+			size_t i2 = offsetPos + i;
+			outputArray[i] = buffer[i2]/output.windowProducts[i2];
+		}
+		for (size_t i = chunk1; i < length; ++i) {
+			size_t i2 = i + offsetPos - _blockSamples;
+			outputArray[i] = buffer[i2]/output.windowProducts[i2];
+		}
+	}
+	void readOutput(size_t channel, size_t length, Sample *outputArray) {
+		return readOutput(channel, 0, length, outputArray);
+	}
+	void moveOutput(size_t samples) {
+		if (samples == 1) { // avoid all the loops/chunks if we can
+			for (size_t c = 0; c < _synthesisChannels; ++c) {
+				output.buffer[output.pos + c*_blockSamples] = 0;
+			}
+			output.windowProducts[output.pos] = almostZero;
+			if (++output.pos >= _blockSamples) output.pos = 0;
+			return;
+		}
+		// Zero the output buffer as we cross it
+		size_t outputWrapIndex = _blockSamples - output.pos;
+		size_t chunk1 = std::min(samples, outputWrapIndex);
+		for (size_t c = 0; c < _synthesisChannels; ++c) {
+			Sample *buffer = output.buffer.data() + c*_blockSamples;
+			for (size_t i = 0; i < chunk1; ++i) {
+				size_t i2 = output.pos + i;
+				buffer[i2] = 0;
+			}
+			for (size_t i = chunk1; i < samples; ++i) {
+				size_t i2 = i + output.pos - _blockSamples;
+				buffer[i2] = 0;
+			}
+		}
+		for (size_t i = 0; i < chunk1; ++i) {
+			size_t i2 = output.pos + i;
+			output.windowProducts[i2] = almostZero;
+		}
+		for (size_t i = chunk1; i < samples; ++i) {
+			size_t i2 = i + output.pos - _blockSamples;
+			output.windowProducts[i2] = almostZero;
+		}
+		output.pos = (output.pos + samples)%_blockSamples;
+		_samplesSinceSynthesis += samples;
+	}
+	size_t samplesSinceSynthesis() const {
+		return _samplesSinceSynthesis;
+	}
+
+	Complex * spectrum(size_t channel) {
+		return spectrumBuffer.data() + channel*_fftBins;
+	}
+	const Complex * spectrum(size_t channel) const {
+		return spectrumBuffer.data() + channel*_fftBins;
+	}
+
+	Sample * analysisWindow() {
+		return _analysisWindow.data();
+	}
+	const Sample * analysisWindow() const {
+		return _analysisWindow.data();
+	}
+	// Sets the centre index of the window
+	void analysisOffset(size_t offset) {
+		_analysisOffset = offset;
+	}
+	size_t analysisOffset() const {
+		return _analysisOffset;
+	}
+	Sample * synthesisWindow() {
+		return _synthesisWindow.data();
+	}
+	const Sample * synthesisWindow() const {
+		return _synthesisWindow.data();
+	}
+	// Sets the centre index of the window
+	void synthesisOffset(size_t offset) {
+		_synthesisOffset = offset;
+	}
+	size_t synthesisOffset() const {
+		return _synthesisOffset;
+	}
+
+	void setInterval(size_t defaultInterval, WindowShape windowShape=WindowShape::ignore) {
+		_defaultInterval = defaultInterval;
+		if (windowShape == WindowShape::ignore) return;
+
+		_analysisOffset = _synthesisOffset = _blockSamples/2;
+
+		if (windowShape == acg) {
+			auto window = ApproximateConfinedGaussian::withBandwidth(double(_blockSamples)/defaultInterval);
+			window.fill(_synthesisWindow, _blockSamples);
+		} else if (windowShape == kaiser) {
+			auto window = Kaiser::withBandwidth(double(_blockSamples)/defaultInterval, true);
+			window.fill(_synthesisWindow,  _blockSamples);
+		}
+
+		if (_analysisChannels == 0) {
+			for (auto &v : _analysisWindow) v = 1;
+		} else {
+			forcePerfectReconstruction(_synthesisWindow, _blockSamples, _defaultInterval);
+			for (size_t i = 0; i < _blockSamples; ++i) {
+				_analysisWindow[i] = _synthesisWindow[i];
+			}
+		}
+	}
+
+	void analyse(size_t samplesInPast=0) {
+		for (size_t s = 0; s < analyseSteps(); ++s) {
+			analyseStep(s, samplesInPast);
+		}
+	}
+	size_t analyseSteps() const {
+		return splitComputation ? _analysisChannels*(fft.steps() + 1) : _analysisChannels;
+	}
+	void analyseStep(size_t step, std::size_t samplesInPast=0) {
+		size_t fftSteps = splitComputation ? fft.steps() : 0;
+		size_t channel = step/(fftSteps + 1);
+		step -= channel*(fftSteps + 1);
+
+		if (step-- == 0) { // extra step at start of each channel: copy windowed input into buffer
+			size_t offsetPos = (_inputLengthSamples*2 + input.pos - _blockSamples - samplesInPast)%_inputLengthSamples;
+			size_t inputWrapIndex = _inputLengthSamples - offsetPos;
+			size_t chunk1 = std::min(_analysisOffset, inputWrapIndex);
+			size_t chunk2 = std::max(_analysisOffset, std::min(_blockSamples, inputWrapIndex));
+
+			_samplesSinceAnalysis = samplesInPast;
+			Sample *buffer = input.buffer.data() + channel*_inputLengthSamples;
+			for (size_t i = 0; i < chunk1; ++i) {
+				Sample w = modified ? -_analysisWindow[i] : _analysisWindow[i];
+				size_t ti = i + (_fftSamples - _analysisOffset);
+				size_t bi = offsetPos + i;
+				timeBuffer[ti] = buffer[bi]*w;
+			}
+			for (size_t i = chunk1; i < _analysisOffset; ++i) {
+				Sample w = modified ? -_analysisWindow[i] : _analysisWindow[i];
+				size_t ti = i + (_fftSamples - _analysisOffset);
+				size_t bi = i + offsetPos - _inputLengthSamples;
+				timeBuffer[ti] = buffer[bi]*w;
+			}
+			for (size_t i = _analysisOffset; i < chunk2; ++i) {
+				Sample w = _analysisWindow[i];
+				size_t ti = i - _analysisOffset;
+				size_t bi = offsetPos + i;
+				timeBuffer[ti] = buffer[bi]*w;
+			}
+			for (size_t i = chunk2; i < _blockSamples; ++i) {
+				Sample w = _analysisWindow[i];
+				size_t ti = i - _analysisOffset;
+				size_t bi = i + offsetPos - _inputLengthSamples;
+				timeBuffer[ti] = buffer[bi]*w;
+			}
+			for (size_t i = _blockSamples - _analysisOffset; i < _fftSamples - _analysisOffset; ++i) {
+				timeBuffer[i] = 0;
+			}
+			if (splitComputation) return;
+		}
+		if (splitComputation) {
+			fft.fft(step, timeBuffer.data(), spectrum(channel));
+		} else {
+			fft.fft(timeBuffer.data(), spectrum(channel));
+		}
+	}
+
+	void synthesise() {
+		for (size_t s = 0; s < synthesiseSteps(); ++s) {
+			synthesiseStep(s);
+		}
+	}
+	size_t synthesiseSteps() const {
+		return splitComputation ? (_synthesisChannels*(fft.steps() + 1) + 1) : _synthesisChannels;
+	}
+	void synthesiseStep(size_t step) {
+		if (step == 0) { // Extra first step which adds in the effective gain for a pure analysis-synthesis cycle
+			addWindowProduct();
+			if (splitComputation) return;
+		}
+		if (splitComputation) --step;
+
+		size_t fftSteps = splitComputation ? fft.steps() : 0;
+		size_t channel = step/(fftSteps + 1);
+		step -= channel*(fftSteps + 1);
+
+		if (splitComputation) {
+			if (step < fftSteps) {
+				fft.ifft(step, spectrum(channel), timeBuffer.data());
+				return;
+			}
+		} else {
+			fft.ifft(spectrum(channel), timeBuffer.data());
+		}
+
+		// extra step after each channel's FFT
+		Sample *buffer = output.buffer.data() + channel*_blockSamples;
+		size_t outputWrapIndex = _blockSamples - output.pos;
+		size_t chunk1 = std::min(_synthesisOffset, outputWrapIndex);
+		size_t chunk2 = std::min(_blockSamples, std::max(_synthesisOffset, outputWrapIndex));
+
+		for (size_t i = 0; i < chunk1; ++i) {
+			Sample w = modified ? -_synthesisWindow[i] : _synthesisWindow[i];
+			size_t ti = i + (_fftSamples - _synthesisOffset);
+			size_t bi = output.pos + i;
+			buffer[bi] += timeBuffer[ti]*w;
+		}
+		for (size_t i = chunk1; i < _synthesisOffset; ++i) {
+			Sample w = modified ? -_synthesisWindow[i] : _synthesisWindow[i];
+			size_t ti = i + (_fftSamples - _synthesisOffset);
+			size_t bi = i + output.pos - _blockSamples;
+			buffer[bi] += timeBuffer[ti]*w;
+		}
+		for (size_t i = _synthesisOffset; i < chunk2; ++i) {
+			Sample w = _synthesisWindow[i];
+			size_t ti = i - _synthesisOffset;
+			size_t bi = output.pos + i;
+			buffer[bi] += timeBuffer[ti]*w;
+		}
+		for (size_t i = chunk2; i < _blockSamples; ++i) {
+			Sample w = _synthesisWindow[i];
+			size_t ti = i - _synthesisOffset;
+			size_t bi = i + output.pos - _blockSamples;
+			buffer[bi] += timeBuffer[ti]*w;
+		}
+	}
+
+#define COMPAT_SPELLING(name, alt) \
+	template<class ...Args> \
+	void alt(Args &&...args) { \
+		name(std::forward<Args>(args)...); \
+	}
+	COMPAT_SPELLING(analyse, analyze);
+	COMPAT_SPELLING(analyseStep, analyseStep);
+	COMPAT_SPELLING(analyseSteps, analyzeSteps);
+	COMPAT_SPELLING(synthesise, synthesize);
+	COMPAT_SPELLING(synthesiseStep, synthesizeStep);
+	COMPAT_SPELLING(synthesiseSteps, synthesizeSteps);
+
+	/// Input (only available so we can save/restore the input state)
+	struct Input {
+		void swap(Input &other) {
+			std::swap(pos, other.pos);
+			std::swap(buffer, other.buffer);
+		}
+
+		Input & operator=(const Input &other) {
+			pos = other.pos;
+			buffer.assign(other.buffer.begin(), other.buffer.end());
+			return *this;
+		}
+	private:
+		friend struct DynamicSTFT;
+		size_t pos = 0;
+		std::vector<Sample> buffer;
+	};
+	Input input;
+
+	/// Output (only available so we can save/restore the output state)
+	struct Output {
+		void swap(Output &other) {
+			std::swap(pos, other.pos);
+			std::swap(buffer, other.buffer);
+			std::swap(windowProducts, other.windowProducts);
+		}
+
+		Output & operator=(const Output &other) {
+			pos = other.pos;
+			buffer.assign(other.buffer.begin(), other.buffer.end());
+			windowProducts.assign(other.windowProducts.begin(), other.windowProducts.end());
+			return *this;
+		}
+	private:
+		friend struct DynamicSTFT;
+		size_t pos = 0;
+		std::vector<Sample> buffer;
+		std::vector<Sample> windowProducts;
+	};
+	Output output;
+
+private:
+	static constexpr Sample almostZero = 1e-30;
+
+	size_t _analysisChannels, _synthesisChannels, _inputLengthSamples, _blockSamples, _fftSamples, _fftBins;
+	size_t _defaultInterval = 0;
+
+	std::vector<Sample> _analysisWindow, _synthesisWindow;
+	size_t _analysisOffset = 0, _synthesisOffset = 0;
+
+	std::vector<Complex> spectrumBuffer;
+	std::vector<Sample> timeBuffer;
+
+	size_t _samplesSinceSynthesis = 0, _samplesSinceAnalysis = 0;
+
+	void addWindowProduct() {
+		_samplesSinceSynthesis = 0;
+
+		int windowShift = int(_synthesisOffset) - int(_analysisOffset);
+		size_t wMin = std::max<ptrdiff_t>(0, windowShift);
+		size_t wMax = std::min<ptrdiff_t>(_blockSamples, int(_blockSamples) + windowShift);
+
+		Sample *windowProduct = output.windowProducts.data();
+		size_t outputWrapIndex = _blockSamples - output.pos;
+		size_t chunk1 = std::min<size_t>(wMax, std::max<size_t>(wMin, outputWrapIndex));
+		for (size_t i = wMin; i < chunk1; ++i) {
+			Sample wa = _analysisWindow[i - windowShift];
+			Sample ws = _synthesisWindow[i];
+			size_t bi = output.pos + i;
+			windowProduct[bi] += wa*ws*_fftSamples;
+		}
+		for (size_t i = chunk1; i < wMax; ++i) {
+			Sample wa = _analysisWindow[i - windowShift];
+			Sample ws = _synthesisWindow[i];
+			size_t bi = i + output.pos - _blockSamples;
+			windowProduct[bi] += wa*ws*_fftSamples;
+		}
+	}
+
+	// Copied from DSP library `windows.h`
+	class Kaiser {
+		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) {
+			return bandwidth + 8/((bandwidth + 3)*(bandwidth + 3)) + 0.25*std::max(3 - bandwidth, 0.0);
+		}
+	public:
+		Kaiser(double beta) : beta(beta), invB0(1/bessel0(beta)) {}
+
+		static Kaiser withBandwidth(double bandwidth, bool heuristicOptimal=false) {
+			return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal));
+		}
+		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);
+		}
+		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;
+		}
+		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;
+		}
+
+		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)));
+		}
+
+		double operator ()(double unit) {
+			double r = 2*unit - 1;
+			double arg = std::sqrt(1 - r*r);
+			return bessel0(beta*arg)*invB0;
+		}
+
+		template<typename Data>
+		void fill(Data &&data, size_t size) const {
+			double invSize = 1.0/size;
+			for (size_t 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;
+			}
+		}
+	};
+
+	class ApproximateConfinedGaussian {
+		double gaussianFactor;
+
+		double gaussian(double x) const {
+			return std::exp(-x*x*gaussianFactor);
+		}
+	public:
+		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, size_t 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 (size_t i = 0; i < size; ++i) {
+				double r = (2*i + 1)*invSize - 1;
+				data[i] = norm*(gaussian(r) - offsetScale*(gaussian(r - 2) + gaussian(r + 2)));
+			}
+		}
+	};
+
+	template<typename Data>
+	void forcePerfectReconstruction(Data &&data, size_t windowLength, size_t interval) {
+		for (size_t i = 0; i < interval; ++i) {
+			double sum2 = 0;
+			for (size_t index = i; index < windowLength; index += interval) {
+				sum2 += data[index]*data[index];
+			}
+			double factor = 1/std::sqrt(sum2);
+			for (size_t index = i; index < windowLength; index += interval) {
+				data[index] *= factor;
+			}
+		}
+	}
+};
+
+}} // namespace
+
+#endif // include guard

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -4,7 +4,6 @@
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvoker.h>
-#import <ReactCommon/RCTTurboModule.h>
 #endif // RCT_NEW_ARCH_ENABLED
 
 #include <audioapi/AudioAPIModuleInstaller.h>
@@ -16,9 +15,9 @@ using namespace facebook::react;
 - (void *)runtime;
 @end
 
-#if defined(RCT_NEW_ARCH_ENABLED) && REACT_NATIVE_MINOR_VERSION >= 75
+#if defined(RCT_NEW_ARCH_ENABLED)
 // nothing
-#else // defined(RCT_NEW_ARCH_ENABLED) && REACT_NATIVE_MINOR_VERSION >= 75
+#else // defined(RCT_NEW_ARCH_ENABLED)
 @interface RCTBridge (RCTTurboModule)
 - (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
 - (void)_tryAndHandleError:(dispatch_block_t)block;

package/ios/audioapi/ios/AudioManagerModule.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@class AudioEngine;
+@class NotificationManager;
+@class AudioSessionManager;
+@class LockScreenManager;
+
+@interface AudioManagerModule : RCTEventEmitter <RCTBridgeModule>
+
+@property (nonatomic, strong) AudioEngine *audioEngine;
+@property (nonatomic, strong) NotificationManager *notificationManager;
+@property (nonatomic, strong) AudioSessionManager *audioSessionManager;
+@property (nonatomic, strong) LockScreenManager *lockScreenManager;
+
+@end