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

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.cpp

@@ -0,0 +1,53 @@
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/utils/AudioNodeDestructor.h>
+#include <audioapi/core/utils/Locker.h>
+
+namespace audioapi {
+
+AudioNodeDestructor::AudioNodeDestructor()
+    : thread_(std::thread(&AudioNodeDestructor::process, this)),
+      isExiting_(false) {}
+
+AudioNodeDestructor::~AudioNodeDestructor() {
+  isExiting_ = true;
+
+  cv_.notify_one(); // call process for the last time
+  if (thread_.joinable()) {
+    thread_.join();
+  }
+}
+
+void AudioNodeDestructor::tryCallWithLock(
+    const std::function<void()> &callback) {
+  if (auto lock = Locker::tryLock(mutex_)) {
+    callback();
+  }
+}
+
+void AudioNodeDestructor::addNodeForDeconstruction(
+    const std::shared_ptr<AudioNode> &node) {
+  // NOTE: this method must be called within `tryCallWithLock`
+  nodesForDeconstruction_.emplace_back(node);
+}
+
+void AudioNodeDestructor::notify() {
+  cv_.notify_one();
+}
+
+void AudioNodeDestructor::process() {
+  std::unique_lock<std::mutex> lock(mutex_);
+  while (!isExiting_) {
+    cv_.wait(lock, [this] {
+      return isExiting_ || !nodesForDeconstruction_.empty();
+    });
+
+    if (isExiting_)
+      break;
+
+    if (!isExiting_ && !nodesForDeconstruction_.empty()) {
+      nodesForDeconstruction_.clear();
+    }
+  }
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <atomic>
+#include <vector>
+#include <memory>
+
+namespace audioapi {
+
+class AudioNode;
+
+class AudioNodeDestructor {
+ public:
+  AudioNodeDestructor();
+  ~AudioNodeDestructor();
+
+  void tryCallWithLock(const std::function<void()> &callback);
+  void addNodeForDeconstruction(const std::shared_ptr<AudioNode> &node);
+  void notify();
+
+ private:
+  mutable std::mutex mutex_;
+  std::thread thread_;
+  std::condition_variable cv_;
+  std::vector<std::shared_ptr<AudioNode>> nodesForDeconstruction_;
+
+  std::atomic<bool> isExiting_;
+
+  void process();
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -55,17 +55,20 @@ void AudioNodeManager::settlePendingConnections() {
 }
 
 void AudioNodeManager::prepareNodesForDestruction() {
-  auto it = nodes_.begin();
-
-  while (it != nodes_.end()) {
-    if (it->use_count() == 1) {
-      assert(it->get()->inputNodes_.empty());
-      it->get()->cleanup();
-      it = nodes_.erase(it);
-    } else {
-      ++it;
+  nodeDeconstructor_.tryCallWithLock([this]() {
+    auto it = nodes_.begin();
+
+    while (it != nodes_.end()) {
+      if (it->use_count() == 1) {
+        nodeDeconstructor_.addNodeForDeconstruction(*it);
+        it->get()->cleanup();
+        it = nodes_.erase(it);
+      } else {
+        ++it;
+      }
     }
-  }
+  });
+  nodeDeconstructor_.notify();
 }
 
 void AudioNodeManager::cleanup() {

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/AudioNodeDestructor.h>
+
 #include <memory>
 #include <mutex>
 #include <tuple>
@@ -31,6 +33,7 @@ class AudioNodeManager {
 
  private:
   std::mutex graphLock_;
+  AudioNodeDestructor nodeDeconstructor_;
 
   // all nodes created in the context
   std::unordered_set<std::shared_ptr<AudioNode>> nodes_;

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

@@ -0,0 +1,326 @@
+// If possible, only include vecLib, since JUCE has conflicts with vImage
+#if defined(HAVE_ACCELERATE)
+#include <Accelerate/Accelerate.h>
+
+namespace signalsmith { namespace linear {
+
+namespace _impl {
+	template<>
+	inline void complexMul<float>(std::complex<float> *a, const std::complex<float> *b, const std::complex<float> *c, size_t size) {
+		DSPSplitComplex aSplit = {(float *)a, (float *)a + 1};
+		DSPSplitComplex bSplit = {(float *)b, (float *)b + 1};
+		DSPSplitComplex cSplit = {(float *)c, (float *)c + 1};
+		vDSP_zvmul(&cSplit, 2, &bSplit, 2, &aSplit, 2, size, 1);
+	}
+	template<>
+	inline void complexMulConj<float>(std::complex<float> *a, const std::complex<float> *b, const std::complex<float> *c, size_t size) {
+		DSPSplitComplex aSplit = {(float *)a, (float *)a + 1};
+		DSPSplitComplex bSplit = {(float *)b, (float *)b + 1};
+		DSPSplitComplex cSplit = {(float *)c, (float *)c + 1};
+		vDSP_zvmul(&cSplit, 2, &bSplit, 2, &aSplit, 2, size, -1);
+	}
+	template<>
+	inline void complexMul<float>(float *ar, float *ai, const float *br, const float *bi, const float *cr, const float *ci, size_t size) {
+		DSPSplitComplex aSplit = {ar, ai};
+		DSPSplitComplex bSplit = {(float *)br, (float *)bi};
+		DSPSplitComplex cSplit = {(float *)cr, (float *)ci};
+		vDSP_zvmul(&cSplit, 1, &bSplit, 1, &aSplit, 1, size, 1);
+	}
+	template<>
+	inline void complexMulConj<float>(float *ar, float *ai, const float *br, const float *bi, const float *cr, const float *ci, size_t size) {
+		DSPSplitComplex aSplit = {ar, ai};
+		DSPSplitComplex bSplit = {(float *)br, (float *)bi};
+		DSPSplitComplex cSplit = {(float *)cr, (float *)ci};
+		vDSP_zvmul(&cSplit, 1, &bSplit, 1, &aSplit, 1, size, -1);
+	}
+
+	// doubles
+	template<>
+	inline void complexMul<double>(std::complex<double> *a, const std::complex<double> *b, const std::complex<double> *c, size_t size) {
+		DSPDoubleSplitComplex aSplit = {(double *)a, (double *)a + 1};
+		DSPDoubleSplitComplex bSplit = {(double *)b, (double *)b + 1};
+		DSPDoubleSplitComplex cSplit = {(double *)c, (double *)c + 1};
+		vDSP_zvmulD(&cSplit, 2, &bSplit, 2, &aSplit, 2, size, 1);
+	}
+	template<>
+	inline void complexMulConj<double>(std::complex<double> *a, const std::complex<double> *b, const std::complex<double> *c, size_t size) {
+		DSPDoubleSplitComplex aSplit = {(double *)a, (double *)a + 1};
+		DSPDoubleSplitComplex bSplit = {(double *)b, (double *)b + 1};
+		DSPDoubleSplitComplex cSplit = {(double *)c, (double *)c + 1};
+		vDSP_zvmulD(&cSplit, 2, &bSplit, 2, &aSplit, 2, size, -1);
+	}
+	template<>
+	inline void complexMul<double>(double *ar, double *ai, const double *br, const double *bi, const double *cr, const double *ci, size_t size) {
+		DSPDoubleSplitComplex aSplit = {ar, ai};
+		DSPDoubleSplitComplex bSplit = {(double *)br, (double *)bi};
+		DSPDoubleSplitComplex cSplit = {(double *)cr, (double *)ci};
+		vDSP_zvmulD(&cSplit, 1, &bSplit, 1, &aSplit, 1, size, 1);
+	}
+	template<>
+	inline void complexMulConj<double>(double *ar, double *ai, const double *br, const double *bi, const double *cr, const double *ci, size_t size) {
+		DSPDoubleSplitComplex aSplit = {ar, ai};
+		DSPDoubleSplitComplex bSplit = {(double *)br, (double *)bi};
+		DSPDoubleSplitComplex cSplit = {(double *)cr, (double *)ci};
+		vDSP_zvmulD(&cSplit, 1, &bSplit, 1, &aSplit, 1, size, -1);
+	}
+}
+
+template<>
+struct Pow2FFT<float> {
+	static constexpr bool prefersSplit = true;
+
+	using Complex = std::complex<float>;
+
+	Pow2FFT(size_t size = 0) {
+		resize(size);
+	}
+	~Pow2FFT() {
+		if (hasSetup) vDSP_destroy_fftsetup(fftSetup);
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		if (hasSetup) vDSP_destroy_fftsetup(fftSetup);
+		if (!size) {
+			hasSetup = false;
+			return;
+		}
+
+		splitReal.resize(size);
+		splitImag.resize(size);
+		log2 = std::round(std::log2(size));
+		fftSetup = vDSP_create_fftsetup(log2, FFT_RADIX2);
+		hasSetup = true;
+	}
+
+	void fft(const Complex* input, Complex* output) {
+		DSPSplitComplex splitComplex{ splitReal.data(), splitImag.data() };
+		vDSP_ctoz((DSPComplex*)input, 2, &splitComplex, 1, _size);
+		vDSP_fft_zip(fftSetup, &splitComplex, 1, log2, kFFTDirection_Forward);
+		vDSP_ztoc(&splitComplex, 1, (DSPComplex*)output, 2, _size);
+	}
+	void fft(const float *inR, const float *inI, float *outR, float *outI) {
+		DSPSplitComplex inSplit{(float *)inR, (float *)inI};
+		DSPSplitComplex outSplit{outR, outI};
+		vDSP_fft_zop(fftSetup, &inSplit, 1, &outSplit, 1, log2, kFFTDirection_Forward);
+	}
+
+	void ifft(const Complex* input, Complex* output) {
+		DSPSplitComplex splitComplex{ splitReal.data(), splitImag.data() };
+		vDSP_ctoz((DSPComplex*)input, 2, &splitComplex, 1, _size);
+		vDSP_fft_zip(fftSetup, &splitComplex, 1, log2, kFFTDirection_Inverse);
+		vDSP_ztoc(&splitComplex, 1, (DSPComplex*)output, 2, _size);
+	}
+	void ifft(const float *inR, const float *inI, float *outR, float *outI) {
+		DSPSplitComplex inSplit{(float *)inR, (float *)inI};
+		DSPSplitComplex outSplit{outR, outI};
+		vDSP_fft_zop(fftSetup, &inSplit, 1, &outSplit, 1, log2, kFFTDirection_Inverse);
+	}
+
+private:
+	size_t _size = 0;
+	bool hasSetup = false;
+	FFTSetup fftSetup;
+	int log2 = 0;
+	std::vector<float> splitReal, splitImag;
+};
+
+template<>
+struct Pow2RealFFT<float> {
+	static constexpr bool prefersSplit = true;
+
+	using Complex = std::complex<float>;
+
+	Pow2RealFFT(size_t size = 0) {
+		resize(size);
+	}
+	~Pow2RealFFT() {
+		if (hasSetup) vDSP_destroy_fftsetup(fftSetup);
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		if (hasSetup) vDSP_destroy_fftsetup(fftSetup);
+		if (!size) {
+			hasSetup = false;
+			return;
+		}
+
+		splitReal.resize(size);
+		splitImag.resize(size);
+		log2 = std::log2(size);
+		fftSetup = vDSP_create_fftsetup(log2, FFT_RADIX2);
+		hasSetup = true;
+	}
+
+	void fft(const float* input, Complex* output) {
+		float mul = 0.5f;
+		vDSP_vsmul(input, 2, &mul, splitReal.data(), 1, _size/2);
+		vDSP_vsmul(input + 1, 2, &mul, splitImag.data(), 1, _size/2);
+		DSPSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_fft_zrip(fftSetup, &tmpSplit, 1, log2, kFFTDirection_Forward);
+		vDSP_ztoc(&tmpSplit, 1, (DSPComplex *)output, 2, _size/2);
+	}
+	void fft(const float *inR, float *outR, float *outI) {
+		DSPSplitComplex outputSplit{outR, outI};
+		float mul = 0.5f;
+		vDSP_vsmul(inR, 2, &mul, outR, 1, _size/2);
+		vDSP_vsmul(inR + 1, 2, &mul, outI, 1, _size/2);
+		vDSP_fft_zrip(fftSetup, &outputSplit, 1, log2, kFFTDirection_Forward);
+	}
+
+	void ifft(const Complex * input, float * output) {
+		DSPSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_ctoz((DSPComplex*)input, 2, &tmpSplit, 1, _size/2);
+		vDSP_fft_zrip(fftSetup, &tmpSplit, 1, log2, kFFTDirection_Inverse);
+		DSPSplitComplex outputSplit{output, output + 1};
+		vDSP_zvmov(&tmpSplit, 1, &outputSplit, 2, _size/2);
+	}
+	void ifft(const float *inR, const float *inI, float *outR) {
+		DSPSplitComplex inputSplit{(float *)inR, (float *)inI};
+		DSPSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_fft_zrop(fftSetup, &inputSplit, 1, &tmpSplit, 1, log2, kFFTDirection_Inverse);
+		DSPSplitComplex outputSplit{outR, outR + 1};
+		// We can't use vDSP_ztoc without knowing the alignment
+		vDSP_zvmov(&tmpSplit, 1, &outputSplit, 2, _size/2);
+	}
+
+private:
+	size_t _size = 0;
+	bool hasSetup = false;
+	FFTSetup fftSetup;
+	int log2 = 0;
+	std::vector<float> splitReal, splitImag;
+};
+
+template<>
+struct Pow2FFT<double> {
+	static constexpr bool prefersSplit = true;
+
+	using Complex = std::complex<double>;
+
+	Pow2FFT(size_t size=0) {
+		resize(size);
+	}
+	~Pow2FFT() {
+		if (hasSetup) vDSP_destroy_fftsetupD(fftSetup);
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		if (hasSetup) vDSP_destroy_fftsetupD(fftSetup);
+		if (!size) {
+			hasSetup = false;
+			return;
+		}
+
+		log2 = std::round(std::log2(size));
+		fftSetup = vDSP_create_fftsetupD(log2, FFT_RADIX2);
+		hasSetup = true;
+
+		splitReal.resize(size);
+		splitImag.resize(size);
+	}
+
+	void fft(const Complex* input, Complex* output) {
+		DSPDoubleSplitComplex splitComplex{ splitReal.data(), splitImag.data() };
+		vDSP_ctozD((DSPDoubleComplex*)input, 2, &splitComplex, 1, _size);
+		vDSP_fft_zipD(fftSetup, &splitComplex, 1, log2, kFFTDirection_Forward);
+		vDSP_ztocD(&splitComplex, 1, (DSPDoubleComplex*)output, 2, _size);
+	}
+	void fft(const double *inR, const double *inI, double *outR, double *outI) {
+		DSPDoubleSplitComplex inSplit{(double *)inR, (double *)inI};
+		DSPDoubleSplitComplex outSplit{outR, outI};
+		vDSP_fft_zopD(fftSetup, &inSplit, 1, &outSplit, 1, log2, kFFTDirection_Forward);
+	}
+
+	void ifft(const Complex* input, Complex* output) {
+		DSPDoubleSplitComplex splitComplex{ splitReal.data(), splitImag.data() };
+		vDSP_ctozD((DSPDoubleComplex*)input, 2, &splitComplex, 1, _size);
+		vDSP_fft_zipD(fftSetup, &splitComplex, 1, log2, kFFTDirection_Inverse);
+		vDSP_ztocD(&splitComplex, 1, (DSPDoubleComplex*)output, 2, _size);
+	}
+	void ifft(const double *inR, const double *inI, double *outR, double *outI) {
+		DSPDoubleSplitComplex inSplit{(double *)inR, (double *)inI};
+		DSPDoubleSplitComplex outSplit{outR, outI};
+		vDSP_fft_zopD(fftSetup, &inSplit, 1, &outSplit, 1, log2, kFFTDirection_Inverse);
+	}
+
+private:
+	size_t _size = 0;
+	bool hasSetup = false;
+	FFTSetupD fftSetup;
+	int log2 = 0;
+	std::vector<double> splitReal, splitImag;
+};
+
+template<>
+struct Pow2RealFFT<double> {
+	static constexpr bool prefersSplit = true;
+
+	using Complex = std::complex<double>;
+
+	Pow2RealFFT(size_t size = 0) {
+		resize(size);
+	}
+	~Pow2RealFFT() {
+		if (hasSetup) vDSP_destroy_fftsetupD(fftSetup);
+	}
+
+	void resize(size_t size) {
+		_size = size;
+		if (hasSetup) vDSP_destroy_fftsetupD(fftSetup);
+		if (!size) {
+			hasSetup = false;
+			return;
+		}
+
+		splitReal.resize(size);
+		splitImag.resize(size);
+		log2 = std::log2(size);
+		fftSetup = vDSP_create_fftsetupD(log2, FFT_RADIX2);
+		hasSetup = true;
+	}
+
+	void fft(const double* input, Complex* output) {
+		double mul = 0.5f;
+		vDSP_vsmulD(input, 2, &mul, splitReal.data(), 1, _size/2);
+		vDSP_vsmulD(input + 1, 2, &mul, splitImag.data(), 1, _size/2);
+		DSPDoubleSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_fft_zripD(fftSetup, &tmpSplit, 1, log2, kFFTDirection_Forward);
+		vDSP_ztocD(&tmpSplit, 1, (DSPDoubleComplex *)output, 2, _size/2);
+	}
+	void fft(const double *inR, double *outR, double *outI) {
+		DSPDoubleSplitComplex outputSplit{outR, outI};
+		double mul = 0.5f;
+		vDSP_vsmulD(inR, 2, &mul, outR, 1, _size/2);
+		vDSP_vsmulD(inR + 1, 2, &mul, outI, 1, _size/2);
+		vDSP_fft_zripD(fftSetup, &outputSplit, 1, log2, kFFTDirection_Forward);
+	}
+
+	void ifft(const Complex * input, double * output) {
+		DSPDoubleSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_ctozD((DSPDoubleComplex*)input, 2, &tmpSplit, 1, _size/2);
+		vDSP_fft_zripD(fftSetup, &tmpSplit, 1, log2, kFFTDirection_Inverse);
+		DSPDoubleSplitComplex outputSplit{output, output + 1};
+		vDSP_zvmovD(&tmpSplit, 1, &outputSplit, 2, _size/2);
+	}
+	void ifft(const double *inR, const double *inI, double *outR) {
+		DSPDoubleSplitComplex inputSplit{(double *)inR, (double *)inI};
+		DSPDoubleSplitComplex tmpSplit{splitReal.data(), splitImag.data()};
+		vDSP_fft_zropD(fftSetup, &inputSplit, 1, &tmpSplit, 1, log2, kFFTDirection_Inverse);
+		DSPDoubleSplitComplex outputSplit{outR, outR + 1};
+		// We can't use vDSP_ztoc without knowing the alignment
+		vDSP_zvmovD(&tmpSplit, 1, &outputSplit, 2, _size/2);
+	}
+
+private:
+	size_t _size = 0;
+	bool hasSetup = false;
+	FFTSetupD fftSetup;
+	int log2 = 0;
+	std::vector<double> splitReal, splitImag;
+};
+
+}} // namespace
+#endif