react-native-audio-api 0.1.0 → 0.3.0-rc1

package/common/cpp/utils/FFTFrame.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+#include "VectorMath.h"
+
+namespace audioapi {
+
+class FFTFrame {
+ public:
+  explicit FFTFrame(int size)
+      : size_(size),
+        log2Size_(static_cast<int>(log2(size))),
+        realData_(new float[size]),
+        imaginaryData_(new float[size]) {}
+  ~FFTFrame() {
+    delete[] realData_;
+    delete[] imaginaryData_;
+  }
+
+  [[nodiscard]] float *getRealData() const {
+    return realData_;
+  }
+  [[nodiscard]] float *getImaginaryData() const {
+    return imaginaryData_;
+  }
+
+  void inverse(float *data);
+
+ private:
+  int size_;
+  int log2Size_;
+  float *realData_;
+  float *imaginaryData_;
+};
+
+} // namespace audioapi

package/common/cpp/utils/JsiPromise.cpp

@@ -0,0 +1,59 @@
+#include "JsiPromise.h"
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <functional>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+jsi::Value PromiseVendor::createPromise(std::function<void(std::shared_ptr<Promise>)> func) {
+  if (_runtime == nullptr) {
+    throw new std::runtime_error("Runtime was null!");
+  }
+  auto& runtime = *_runtime;
+  auto callInvoker = _callInvoker;
+
+  // get Promise constructor
+  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+  // create a "run" function (first Promise arg)
+  auto runPromise = jsi::Function::createFromHostFunction(runtime,
+                                                          jsi::PropNameID::forUtf8(runtime, "runPromise"),
+                                                          2,
+                                                          [callInvoker, func](jsi::Runtime& runtime,
+                                                                              const jsi::Value& thisValue,
+                                                                              const jsi::Value* arguments,
+                                                                              size_t count) -> jsi::Value {
+    auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+    auto resolve = std::make_shared<jsi::Function>(std::move(resolveLocal));
+    auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+    auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
+
+    auto resolveWrapper = [resolve, &runtime, callInvoker](jsi::Value value) -> void {
+      auto valueShared = std::make_shared<jsi::Value>(std::move(value));
+      callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+        resolve->call(runtime, *valueShared);
+      });
+    };
+
+    auto rejectWrapper = [reject, &runtime, callInvoker](const std::string& errorMessage) -> void {
+      auto error = jsi::JSError(runtime, errorMessage);
+      auto errorShared = std::make_shared<jsi::JSError>(error);
+      callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
+        reject->call(runtime, errorShared->value());
+      });
+    };
+
+    auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
+    func(promise);
+
+    return jsi::Value::undefined();
+  });
+
+  // return new Promise((resolve, reject) => ...)
+  return promiseCtor.callAsConstructor(runtime, runPromise);
+}
+
+} // namespace JsiPromise

package/common/cpp/utils/JsiPromise.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <utility>
+#include <memory>
+#include <string>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+class Promise {
+ public:
+  Promise(std::function<void(jsi::Value)> resolve, std::function<void(const std::string&)> reject): _resolve(std::move(resolve)), _reject(std::move(reject)) {}
+
+  bool isResolved;
+  void resolve(jsi::Value&& value) {
+    _resolve(std::forward<jsi::Value>(value));
+  }
+  void reject(const std::string& errorMessage) {
+    _reject(errorMessage);
+  }
+
+ private:
+  std::function<void(jsi::Value)> _resolve;
+  std::function<void(const std::string&)> _reject;
+};
+
+class PromiseVendor {
+ public:
+  PromiseVendor(jsi::Runtime* runtime, std::shared_ptr<react::CallInvoker> callInvoker): _runtime(runtime), _callInvoker(callInvoker) {}
+
+ public:
+  jsi::Value createPromise(std::function<void(std::shared_ptr<Promise>)> func);
+
+ private:
+  jsi::Runtime* _runtime;
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace JsiPromise

package/common/cpp/utils/Locker.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <mutex>
+
+namespace audioapi {
+
+// Small easy interface to manage locking
+class Locker {
+ public:
+  Locker() : lockPtr_(0) {}
+  explicit Locker(std::mutex &lockPtr) : lockPtr_(&lockPtr) {
+    lock();
+  }
+
+  ~Locker() {
+    unlock();
+  }
+
+  explicit operator bool() const {
+    return !!lockPtr_;
+  }
+
+  void lock() {
+    if (lockPtr_) {
+      lockPtr_->lock();
+    }
+  }
+
+  void unlock() {
+    if (lockPtr_) {
+      lockPtr_->unlock();
+    }
+  }
+
+  static Locker tryLock(std::mutex &lock) {
+    Locker result = Locker();
+
+    if (lock.try_lock()) {
+      result.lockPtr_ = &lock;
+    }
+
+    return result;
+  }
+
+ private:
+  std::mutex *lockPtr_;
+};
+
+} // namespace audioapi

package/common/cpp/utils/VectorMath.cpp

@@ -77,7 +77,7 @@ void add(
       numberOfElementsToProcess);
 }
 
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,
@@ -115,6 +115,22 @@ float maximumMagnitude(
   return maximumValue;
 }
 
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  vDSP_vsma(
+      inputVector,
+      1,
+      &scalar,
+      outputVector,
+      1,
+      outputVector,
+      1,
+      numberOfElementsToProcess);
+}
+
 #else
 
 #if defined(HAVE_X86_SSE2)
@@ -363,7 +379,7 @@ void add(
   }
 }
 
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,
@@ -578,7 +594,7 @@ float maximumMagnitude(
   max = std::max(max, groupMaxP[3]);
 
   n = tailFrames;
-#elif defined(HAVE_ARM_NEON_INTRINSICS)
+#elif defined(c)
   size_t tailFrames = n % 4;
   const float *endP = inputVector + n - tailFrames;
 
@@ -605,5 +621,74 @@ float maximumMagnitude(
   return max;
 }
 
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  size_t n = numberOfElementsToProcess;
+
+#if HAVE_X86_SSE2
+  // If the inputVector address is not 16-byte aligned, the first several frames
+  // (at most three) should be processed separately.
+  while (!is16ByteAligned(inputVector) && n) {
+    *outputVector += scalar * *inputVector;
+    inputVector++;
+    outputVector++;
+    n--;
+  }
+
+  // Now the inputVector is aligned, use SSE.
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
+
+  __m128 pSource;
+  __m128 dest;
+  __m128 temp;
+  __m128 mScale = _mm_set_ps1(scalar);
+
+  bool destAligned = is16ByteAligned(outputVector);
+
+#define SSE2_MULT_ADD(loadInstr, storeInstr)   \
+  while (outputVector < endP) {                \
+    pSource = _mm_load_ps(inputVector);        \
+    temp = _mm_mul_ps(pSource, mScale);        \
+    dest = _mm_##loadInstr##_ps(outputVector); \
+    dest = _mm_add_ps(dest, temp);             \
+    _mm_##storeInstr##_ps(outputVector, dest); \
+    inputVector += 4;                          \
+    outputVector += 4;                         \
+  }
+
+  if (destAligned)
+    SSE2_MULT_ADD(load, store)
+  else
+    SSE2_MULT_ADD(loadu, storeu)
+
+  n = tailFrames;
+#elif HAVE_ARM_NEON_INTRINSICS
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
+
+  float32x4_t k = vdupq_n_f32(scalar);
+  while (outputVector < endP) {
+    float32x4_t source = vld1q_f32(inputVector);
+    float32x4_t dest = vld1q_f32(outputVector);
+
+    dest = vmlaq_f32(dest, source, k);
+    vst1q_f32(outputVector, dest);
+
+    inputVector += 4;
+    outputVector += 4;
+  }
+  n = tailFrames;
+#endif
+  while (n--) {
+    *outputVector += *inputVector * scalar;
+    ++inputVector;
+    ++outputVector;
+  }
+}
+
 #endif
 } // namespace audioapi::VectorMath

package/common/cpp/utils/VectorMath.h

@@ -32,6 +32,12 @@
 
 namespace audioapi::VectorMath {
 
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+
 void multiplyByScalar(
     const float *inputVector,
     float scalar,
@@ -47,7 +53,7 @@ void add(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess);
-void substract(
+void subtract(
     const float *inputVector1,
     const float *inputVector2,
     float *outputVector,

package/common/cpp/utils/android/FFTFrame.cpp

@@ -0,0 +1,23 @@
+#if defined(ANDROID)
+#include "FFTFrame.h"
+#include <fftw3.h>
+
+namespace audioapi {
+void FFTFrame::inverse(float *timeDomainData) {
+  fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+  for (int i = 0; i < size_ / 2; i++) {
+    freqDomainData[i][0] = realData_[i];
+    freqDomainData[i][1] = imaginaryData_[i];
+  }
+
+  auto plan = fftwf_plan_dft_c2r_1d(
+      size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+  fftwf_execute(plan);
+  fftwf_destroy_plan(plan);
+  fftwf_free(freqDomainData);
+
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/utils/ios/FFTFrame.cpp

@@ -0,0 +1,29 @@
+#if defined(HAVE_ACCELERATE)
+#include "FFTFrame.h"
+#include "Accelerate/Accelerate.h"
+
+namespace audioapi {
+
+void FFTFrame::inverse(float *timeDomainData) {
+  FFTSetup fftSetup_ = vDSP_create_fftsetup(log2Size_, FFT_RADIX2);
+  DSPSplitComplex freqDomainData;
+  freqDomainData.realp = realData_;
+  freqDomainData.imagp = imaginaryData_;
+
+  vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
+  vDSP_ztoc(
+      &freqDomainData,
+      1,
+      reinterpret_cast<DSPComplex *>(timeDomainData),
+      2,
+      size_ / 2);
+
+  // Scale the FFT data, beacuse of
+  // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+
+  vDSP_destroy_fftsetup(fftSetup_);
+}
+} // namespace audioapi
+#endif

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.cpp

@@ -24,12 +24,22 @@ void AudioBufferSourceNodeWrapper::setLoop(bool loop) {
 std::shared_ptr<AudioBufferWrapper> AudioBufferSourceNodeWrapper::getBuffer() {
   auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
   auto buffer = audioBufferSourceNode->getBuffer();
+
+  if (!buffer) {
+    return {nullptr};
+  }
+
   return std::make_shared<AudioBufferWrapper>(buffer);
 }
 
 void AudioBufferSourceNodeWrapper::setBuffer(
     const std::shared_ptr<AudioBufferWrapper> &buffer) {
   auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
+  if (!buffer) {
+    audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+    return;
+  }
+
   audioBufferSourceNode->setBuffer(buffer->audioBuffer_);
 }
 } // namespace audioapi

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 
 #include "AudioBufferSourceNode.h"
 #include "AudioBufferWrapper.h"
@@ -14,8 +15,8 @@ class AudioBufferSourceNodeWrapper : public AudioScheduledSourceNodeWrapper {
       const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode);
 
   void setLoop(bool loop);
-  bool getLoop();
-  std::shared_ptr<AudioBufferWrapper> getBuffer();
+  [[nodiscard]] bool getLoop();
+  [[nodiscard]] std::shared_ptr<AudioBufferWrapper> getBuffer();
   void setBuffer(const std::shared_ptr<AudioBufferWrapper> &buffer);
 
  private:

package/common/cpp/wrappers/AudioBufferWrapper.h

@@ -11,11 +11,11 @@ class AudioBufferWrapper {
   explicit AudioBufferWrapper(const std::shared_ptr<AudioBuffer> &audioBuffer);
 
   std::shared_ptr<AudioBuffer> audioBuffer_;
-  int getNumberOfChannels() const;
-  int getLength() const;
-  double getDuration() const;
-  int getSampleRate() const;
-  float *getChannelData(int channel) const;
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] int getLength() const;
+  [[nodiscard]] double getDuration() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] float *getChannelData(int channel) const;
   void copyFromChannel(
       float *destination,
       int destinationLength,

package/common/cpp/wrappers/AudioContextWrapper.cpp

@@ -3,68 +3,15 @@
 namespace audioapi {
 
 AudioContextWrapper::AudioContextWrapper(
-    const std::shared_ptr<AudioContext> &audiocontext)
-    : audioContext_(audiocontext) {
-  auto destination = audioContext_->getDestination();
-  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
-}
-
-std::shared_ptr<AudioDestinationNodeWrapper>
-AudioContextWrapper::getDestination() const {
-  return destination_;
-}
-
-std::shared_ptr<OscillatorNodeWrapper> AudioContextWrapper::createOscillator()
-    const {
-  auto oscillator = audioContext_->createOscillator();
-  return std::make_shared<OscillatorNodeWrapper>(oscillator);
-}
-
-std::shared_ptr<GainNodeWrapper> AudioContextWrapper::createGain() const {
-  auto gain = audioContext_->createGain();
-  return std::make_shared<GainNodeWrapper>(gain);
-}
-
-std::shared_ptr<StereoPannerNodeWrapper>
-AudioContextWrapper::createStereoPanner() const {
-  auto panner = audioContext_->createStereoPanner();
-  return std::make_shared<StereoPannerNodeWrapper>(panner);
-}
-
-std::shared_ptr<BiquadFilterNodeWrapper>
-AudioContextWrapper::createBiquadFilter() const {
-  auto filter = audioContext_->createBiquadFilter();
-  return std::make_shared<BiquadFilterNodeWrapper>(filter);
-}
-
-std::shared_ptr<AudioBufferSourceNodeWrapper>
-AudioContextWrapper::createBufferSource() const {
-  auto bufferSource = audioContext_->createBufferSource();
-  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
-}
-
-std::shared_ptr<AudioBufferWrapper> AudioContextWrapper::createBuffer(
-    int numberOfChannels,
-    int length,
-    int sampleRate) const {
-  auto buffer =
-      audioContext_->createBuffer(numberOfChannels, length, sampleRate);
-  return std::make_shared<AudioBufferWrapper>(buffer);
-}
-
-std::string AudioContextWrapper::getState() const {
-  return audioContext_->getState();
-}
-
-int AudioContextWrapper::getSampleRate() const {
-  return audioContext_->getSampleRate();
-}
+    const std::shared_ptr<AudioContext> &context)
+    : BaseAudioContextWrapper(context) {}
 
-double AudioContextWrapper::getCurrentTime() const {
-  return audioContext_->getCurrentTime();
+void AudioContextWrapper::close() {
+  getAudioContextFromBaseAudioContext()->close();
 }
 
-void AudioContextWrapper::close() const {
-  audioContext_->close();
+std::shared_ptr<AudioContext>
+AudioContextWrapper::getAudioContextFromBaseAudioContext() {
+  return std::static_pointer_cast<AudioContext>(context_);
 }
 } // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.h

@@ -1,40 +1,19 @@
 #pragma once
 
 #include <memory>
-#include <string>
-#include <utility>
 
-#include "AudioBufferSourceNodeWrapper.h"
-#include "AudioBufferWrapper.h"
 #include "AudioContext.h"
-#include "AudioDestinationNodeWrapper.h"
-#include "BiquadFilterNodeWrapper.h"
-#include "GainNodeWrapper.h"
-#include "OscillatorNodeWrapper.h"
-#include "StereoPannerNodeWrapper.h"
+#include "BaseAudioContextWrapper.h"
 
 namespace audioapi {
 
-class AudioContextWrapper {
+class AudioContextWrapper : public BaseAudioContextWrapper {
  public:
-  explicit AudioContextWrapper(
-      const std::shared_ptr<AudioContext> &audiocontext);
+  explicit AudioContextWrapper(const std::shared_ptr<AudioContext> &context);
 
-  std::shared_ptr<AudioDestinationNodeWrapper> getDestination() const;
-  std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
-  std::shared_ptr<GainNodeWrapper> createGain() const;
-  std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner() const;
-  std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter() const;
-  std::shared_ptr<AudioBufferSourceNodeWrapper> createBufferSource() const;
-  std::shared_ptr<AudioBufferWrapper>
-  createBuffer(int numberOfChannels, int length, int sampleRate) const;
-  std::string getState() const;
-  int getSampleRate() const;
-  double getCurrentTime() const;
-  void close() const;
+  void close();
 
  private:
-  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
-  std::shared_ptr<AudioContext> audioContext_;
+  std::shared_ptr<AudioContext> getAudioContextFromBaseAudioContext();
 };
 } // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.h

@@ -11,11 +11,11 @@ class AudioNodeWrapper {
  public:
   explicit AudioNodeWrapper(const std::shared_ptr<AudioNode> &node);
 
-  int getNumberOfInputs() const;
-  int getNumberOfOutputs() const;
-  int getChannelCount() const;
-  std::string getChannelCountMode() const;
-  std::string getChannelInterpretation() const;
+  [[nodiscard]] int getNumberOfInputs() const;
+  [[nodiscard]] int getNumberOfOutputs() const;
+  [[nodiscard]] int getChannelCount() const;
+  [[nodiscard]] std::string getChannelCountMode() const;
+  [[nodiscard]] std::string getChannelInterpretation() const;
   void connect(const std::shared_ptr<AudioNodeWrapper> &node) const;
   void disconnect(const std::shared_ptr<AudioNodeWrapper> &node) const;
 

package/common/cpp/wrappers/AudioParamWrapper.h

@@ -10,11 +10,11 @@ class AudioParamWrapper {
  public:
   explicit AudioParamWrapper(const std::shared_ptr<AudioParam> &param);
 
-  float getValue() const;
+  [[nodiscard]] float getValue() const;
   void setValue(float value) const;
-  float getDefaultValue() const;
-  float getMinValue() const;
-  float getMaxValue() const;
+  [[nodiscard]] float getDefaultValue() const;
+  [[nodiscard]] float getMinValue() const;
+  [[nodiscard]] float getMaxValue() const;
   void setValueAtTime(float value, double startTime) const;
   void linearRampToValueAtTime(float value, double endTime) const;
   void exponentialRampToValueAtTime(float value, double endTime) const;