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

package/RNAudioAPI.podspec

@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
     end
   end
 
-  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate'
+  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate', 'MediaPlayer', 'AVFoundation'
 
   s.compiler_flags = "#{folly_flags}"
 

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -6,26 +6,6 @@
 
 namespace audioapi {
 
-AudioPlayer::AudioPlayer(
-    const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio)
-    : renderAudio_(renderAudio), channelCount_(2) {
-  AudioStreamBuilder builder;
-
-  builder.setSharingMode(SharingMode::Exclusive)
-      ->setFormat(AudioFormat::Float)
-      ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(PerformanceMode::None)
-      ->setChannelCount(channelCount_)
-      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
-      ->setDataCallback(this)
-      ->openStream(mStream_);
-
-  sampleRate_ = static_cast<float>(mStream_->getSampleRate());
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
-  isInitialized_ = true;
-}
-
 AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate)

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.h

@@ -14,8 +14,6 @@ class AudioBus;
 
 class AudioPlayer : public AudioStreamDataCallback {
  public:
-  explicit AudioPlayer(
-      const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio);
   AudioPlayer(
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);

package/android/src/main/java/com/swmansion/audioapi/AudioAPIPackage.kt

@@ -10,6 +10,7 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 @ReactModuleList(
   nativeModules = [
     AudioAPIModule::class,
+    AudioManagerModule::class,
   ],
 )
 class AudioAPIPackage : BaseReactPackage() {
@@ -19,6 +20,7 @@ class AudioAPIPackage : BaseReactPackage() {
   ): NativeModule? {
     when (name) {
       AudioAPIModule.NAME -> return AudioAPIModule(reactContext)
+      AudioManagerModule.NAME -> return AudioManagerModule(reactContext)
     }
     return null
   }
@@ -37,6 +39,17 @@ class AudioAPIPackage : BaseReactPackage() {
           isCxxModule = false,
           isTurboModule = isTurboModule,
         )
+
+      moduleInfos[AudioManagerModule.NAME] =
+        ReactModuleInfo(
+          AudioManagerModule.NAME,
+          AudioManagerModule.NAME,
+          canOverrideExistingModule = true,
+          needsEagerInit = false,
+          hasConstants = true,
+          isCxxModule = false,
+          isTurboModule = false,
+        )
       moduleInfos
     }
 }

package/android/src/main/java/com/swmansion/audioapi/AudioManagerModule.kt

@@ -0,0 +1,59 @@
+package com.swmansion.audioapi
+
+import android.content.Context
+import android.media.AudioManager
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+class AudioManagerModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  companion object {
+    const val NAME = "AudioManagerModule"
+  }
+
+  private val audioManager: AudioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+  init {
+    try {
+      System.loadLibrary("react-native-audio-api")
+    } catch (exception: UnsatisfiedLinkError) {
+      throw RuntimeException("Could not load native module AudioAPIModule", exception)
+    }
+  }
+
+  @ReactMethod
+  fun setLockScreenInfo(info: ReadableMap?) {
+  }
+
+  @ReactMethod
+  fun resetLockScreenInfo() {
+  }
+
+  @ReactMethod
+  fun enableRemoteCommand(
+    name: String?,
+    enabled: Boolean,
+  ) {
+  }
+
+  @ReactMethod
+  fun setAudioSessionOptions(
+    category: String?,
+    mode: String?,
+    options: ReadableArray?,
+    active: Boolean,
+  ) {
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getDevicePreferredSampleRate(): Double {
+    val sampleRate = this.audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)
+    return sampleRate.toDouble()
+  }
+
+  override fun getName(): String = NAME
+}

package/android/src/oldarch/NativeAudioManagerModuleSpec.java

@@ -0,0 +1,99 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.swmansion.audioapi;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAudioManagerModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "AudioManagerModule";
+
+  public NativeAudioManagerModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  protected final void emitOnRemotePlay() {
+    mEventEmitterCallback.invoke("onRemotePlay");
+  }
+
+  protected final void emitOnRemotePause() {
+    mEventEmitterCallback.invoke("onRemotePause");
+  }
+
+  protected final void emitOnStop() {
+    mEventEmitterCallback.invoke("onStop");
+  }
+
+  protected final void emitOnTogglePlayPause() {
+    mEventEmitterCallback.invoke("onTogglePlayPause");
+  }
+
+  protected final void emitOnChangePlaybackRate(double value) {
+    mEventEmitterCallback.invoke("onChangePlaybackRate", value);
+  }
+
+  protected final void emitOnNextTrack() {
+    mEventEmitterCallback.invoke("onNextTrack");
+  }
+
+  protected final void emitOnPreviousTrack() {
+    mEventEmitterCallback.invoke("onPreviousTrack");
+  }
+
+  protected final void emitOnSkipForward(double value) {
+    mEventEmitterCallback.invoke("onSkipForward", value);
+  }
+
+  protected final void emitOnSkipBackward(double value) {
+    mEventEmitterCallback.invoke("onSkipBackward", value);
+  }
+
+  protected final void emitOnSeekForward() {
+    mEventEmitterCallback.invoke("onSeekForward");
+  }
+
+  protected final void emitOnSeekBackward() {
+    mEventEmitterCallback.invoke("onSeekBackward");
+  }
+
+  protected final void emitOnChangePlaybackPosition(double value) {
+    mEventEmitterCallback.invoke("onChangePlaybackPosition", value);
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setLockScreenInfo(ReadableMap info);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void resetLockScreenInfo();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setSessionOptions(String category, String mode, ReadableArray options);
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double getDevicePreferredSampleRate();
+}

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -35,12 +35,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value *args,
             size_t count) -> jsi::Value {
           std::shared_ptr<AudioContext> audioContext;
-          if (args[0].isUndefined()) {
-            audioContext = std::make_shared<AudioContext>();
-          } else {
-            auto sampleRate = static_cast<float>(args[0].getNumber());
-            audioContext = std::make_shared<AudioContext>(sampleRate);
-          }
+          auto sampleRate = static_cast<float>(args[0].getNumber());
+          audioContext = std::make_shared<AudioContext>(sampleRate);
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -10,18 +10,6 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
-AudioContext::AudioContext() : BaseAudioContext() {
-#ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
-#else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
-#endif
-  sampleRate_ = audioPlayer_->getSampleRate();
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
-
-  audioPlayer_->start();
-}
-
 AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
@@ -29,6 +17,7 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
   audioPlayer_ =
       std::make_shared<IOSAudioPlayer>(this->renderAudio(), sampleRate);
 #endif
+
   sampleRate_ = audioPlayer_->getSampleRate();
   audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
 

package/common/cpp/audioapi/core/AudioContext.h

@@ -14,7 +14,6 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  AudioContext();
   explicit AudioContext(float sampleRate);
   ~AudioContext() override;
 

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

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

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