react-native-audio-api 0.3.1 → 0.3.2

package/common/cpp/core/{ParamChange.h → ParamChangeEvent.h}

@@ -2,18 +2,19 @@
 
 #include <functional>
 #include <memory>
+#include "ParamChangeEventType.h"
 
 namespace audioapi {
 
-class ParamChange {
+class ParamChangeEvent {
  public:
-  explicit ParamChange(
+  explicit ParamChangeEvent(
       double startTime,
       double endTime,
       float startValue,
       float endValue,
-      std::function<float(double, double, float, float, double)>
-          calculateValue);
+      std::function<float(double, double, float, float, double)> calculateValue,
+      ParamChangeEventType type);
 
   [[nodiscard]] double getEndTime() const;
   [[nodiscard]] double getStartTime() const;
@@ -21,7 +22,11 @@ class ParamChange {
   [[nodiscard]] float getStartValue() const;
   [[nodiscard]] std::function<float(double, double, float, float, double)>
   getCalculateValue() const;
-  bool operator<(const ParamChange &other) const;
+  [[nodiscard]] ParamChangeEventType getType() const;
+
+  void setEndTime(double endTime);
+  void setStartValue(float startValue);
+  void setEndValue(float endValue);
 
  private:
   double startTime_;
@@ -29,6 +34,7 @@ class ParamChange {
   float startValue_;
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
+  ParamChangeEventType type_;
 };
 
 } // namespace audioapi

package/common/cpp/core/StereoPannerNode.cpp

@@ -11,7 +11,7 @@ namespace audioapi {
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  panParam_ = std::make_shared<AudioParam>(context, 0.0, -MAX_PAN, MAX_PAN);
+  panParam_ = std::make_shared<AudioParam>(0.0, -MAX_PAN, MAX_PAN);
   isInitialized_ = true;
 }
 

package/common/cpp/jsi/JsiHostObject.cpp

@@ -2,14 +2,14 @@
 
 namespace audioapi {
 JsiHostObject::JsiHostObject() {
-  propertyGetters_ = std::make_unique<std::unordered_map<
+  getters_ = std::make_unique<std::unordered_map<
       std::string,
       jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
-  propertyFunctions_ = std::make_unique<std::unordered_map<
+  functions_ = std::make_unique<std::unordered_map<
       std::string,
       jsi::Value (JsiHostObject::*)(
           jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>>();
-  propertySetters_ = std::make_unique<std::unordered_map<
+  setters_ = std::make_unique<std::unordered_map<
       std::string,
       void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
 }
@@ -17,18 +17,17 @@ JsiHostObject::JsiHostObject() {
 std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> propertyNames;
   propertyNames.reserve(
-      propertyGetters_->size() + propertyFunctions_->size() +
-      propertySetters_->size());
+      getters_->size() + functions_->size() + setters_->size());
 
-  for (const auto &it : *propertyGetters_) {
+  for (const auto &it : *getters_) {
     propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
   }
 
-  for (const auto &it : *propertyFunctions_) {
+  for (const auto &it : *functions_) {
     propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
   }
 
-  for (const auto &it : *propertySetters_) {
+  for (const auto &it : *setters_) {
     propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
   }
 
@@ -39,27 +38,35 @@ jsi::Value JsiHostObject::get(
     jsi::Runtime &runtime,
     const jsi::PropNameID &name) {
   auto nameAsString = name.utf8(runtime);
+  auto &hostFunctionCache = hostFunctionCache_.get(runtime);
 
-  auto propertyGetter = propertyGetters_->find(nameAsString);
-  if (propertyGetter != propertyGetters_->end()) {
-    auto dispatcher = [this, &propertyGetter](jsi::Runtime &runtime) {
-      return (this->*(propertyGetter->second))(runtime);
-    };
+  auto cachedFunction = hostFunctionCache.find(nameAsString);
+  if (cachedFunction != hostFunctionCache.end()) {
+    return cachedFunction->second.asFunction(runtime);
+  }
+
+  auto getter = getters_->find(nameAsString);
+  if (getter != getters_->end()) {
+    auto dispatcher = std::bind(getter->second, this, std::placeholders::_1);
 
     return dispatcher(runtime);
   }
 
-  auto propertyFunction = propertyFunctions_->find(nameAsString);
-  if (propertyFunction != propertyFunctions_->end()) {
-    auto dispatcher = [this, &propertyFunction](
-                          jsi::Runtime &runtime,
-                          const jsi::Value &thisVal,
-                          const jsi::Value *args,
-                          size_t count) -> jsi::Value {
-      return (this->*(propertyFunction->second))(runtime, thisVal, args, count);
-    };
-
-    return jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher);
+  auto function = functions_->find(nameAsString);
+  if (function != functions_->end()) {
+    auto dispatcher = std::bind(
+        function->second,
+        reinterpret_cast<JsiHostObject *>(this),
+        std::placeholders::_1,
+        std::placeholders::_2,
+        std::placeholders::_3,
+        std::placeholders::_4);
+
+    return hostFunctionCache
+        .emplace(
+            nameAsString,
+            jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher))
+        .first->second.asFunction(runtime);
   }
 
   return jsi::Value::undefined();
@@ -71,13 +78,11 @@ void JsiHostObject::set(
     const jsi::Value &value) {
   auto nameAsString = name.utf8(runtime);
 
-  auto propertySetter = propertySetters_->find(nameAsString);
+  auto setter = setters_->find(nameAsString);
 
-  if (propertySetter != propertySetters_->end()) {
-    auto dispatcher = [this, &propertySetter](
-                          jsi::Runtime &runtime, const jsi::Value &value) {
-      return (this->*(propertySetter->second))(runtime, value);
-    };
+  if (setter != setters_->end()) {
+    auto dispatcher = std::bind(
+        setter->second, this, std::placeholders::_1, std::placeholders::_2);
 
     return dispatcher(runtime, value);
   }

package/common/cpp/jsi/JsiHostObject.h

@@ -1,12 +1,15 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
+#include "RuntimeAwareCache.h"
+
 #define JSI_HOST_FUNCTION(NAME)  \
   jsi::Value NAME(               \
       jsi::Runtime &runtime,     \
@@ -57,24 +60,24 @@ class JsiHostObject : public jsi::HostObject {
 
   template <typename... Args>
   void addGetters(Args... args) {
-    (propertyGetters_->insert(args), ...);
+    (getters_->insert(args), ...);
   }
 
   template <typename... Args>
   void addSetters(Args... args) {
-    (propertySetters_->insert(args), ...);
+    (setters_->insert(args), ...);
   }
 
   template <typename... Args>
   void addFunctions(Args... args) {
-    (propertyFunctions_->insert(args), ...);
+    (functions_->insert(args), ...);
   }
 
  protected:
   std::unique_ptr<std::unordered_map<
       std::string,
       jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
-      propertyGetters_;
+      getters_;
 
   std::unique_ptr<std::unordered_map<
       std::string,
@@ -83,12 +86,15 @@ class JsiHostObject : public jsi::HostObject {
           const jsi::Value &,
           const jsi::Value *,
           size_t)>>
-      propertyFunctions_;
+      functions_;
 
   std::unique_ptr<std::unordered_map<
       std::string,
       void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
-      propertySetters_;
+      setters_;
+
+ private:
+  RuntimeAwareCache<std::map<std::string, jsi::Function>> hostFunctionCache_;
 };
 
 } // namespace audioapi

package/common/cpp/jsi/RuntimeAwareCache.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+#include "RuntimeLifecycleMonitor.h"
+
+namespace audioapi {
+
+using namespace facebook;
+
+/**
+ * Provides a way to keep data specific to a jsi::Runtime instance that gets
+ * cleaned up when that runtime is destroyed. This is necessary because JSI does
+ * not allow for its associated objects to be retained past the runtime
+ * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
+ * after the runtime is torn down, its destructor (once it is destroyed
+ * eventually) will result in a crash (JSI objects keep a pointer to memory
+ * managed by the runtime, accessing that portion of the memory after runtime is
+ * deleted is the root cause of that crash).
+ */
+template <typename T>
+class RuntimeAwareCache : public RuntimeLifecycleListener {
+ public:
+  void onRuntimeDestroyed(jsi::Runtime *rt) override {
+    // A runtime has been destroyed, so destroy the related cache.
+    runtimeCaches_.erase(rt);
+  }
+
+  ~RuntimeAwareCache() override {
+    for (auto &cache : runtimeCaches_) {
+      // remove all `onRuntimeDestroyed` listeners.
+      RuntimeLifecycleMonitor::removeListener(*cache.first, this);
+    }
+  }
+
+  T &get(jsi::Runtime &rt) {
+    if (runtimeCaches_.count(&rt) == 0) {
+      // This is the first time this Runtime has been accessed.
+      // We set up a `onRuntimeDestroyed` listener for it and
+      // initialize the cache map.
+      RuntimeLifecycleMonitor::addListener(rt, this);
+
+      T cache;
+      runtimeCaches_.emplace(&rt, std::move(cache));
+    }
+    return runtimeCaches_.at(&rt);
+  }
+
+ private:
+  std::unordered_map<jsi::Runtime *, T> runtimeCaches_;
+};
+
+} // namespace audioapi

package/common/cpp/jsi/RuntimeLifecycleMonitor.cpp

@@ -0,0 +1,61 @@
+#include "RuntimeLifecycleMonitor.h"
+
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace audioapi {
+
+static std::unordered_map<
+    jsi::Runtime *,
+    std::unordered_set<RuntimeLifecycleListener *>>
+    listeners;
+
+struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
+  jsi::Runtime *rt_;
+  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : rt_(rt) {}
+  ~RuntimeLifecycleMonitorObject() override {
+    auto listenersSet = listeners.find(rt_);
+    if (listenersSet != listeners.end()) {
+      for (auto listener : listenersSet->second) {
+        listener->onRuntimeDestroyed(rt_);
+      }
+      listeners.erase(listenersSet);
+    }
+  }
+};
+
+void RuntimeLifecycleMonitor::addListener(
+    jsi::Runtime &rt,
+    RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // We install a global host object in the provided runtime, this way we can
+    // use that host object destructor to get notified when the runtime is being
+    // terminated. We use a unique name for the object as it gets saved with the
+    // runtime's global object.
+    rt.global().setProperty(
+        rt,
+        "__rnaudioapi_runtime_lifecycle_monitor",
+        jsi::Object::createFromHostObject(
+            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
+    std::unordered_set<RuntimeLifecycleListener *> newSet;
+    newSet.insert(listener);
+    listeners.emplace(&rt, std::move(newSet));
+  } else {
+    listenersSet->second.insert(listener);
+  }
+}
+
+void RuntimeLifecycleMonitor::removeListener(
+    jsi::Runtime &rt,
+    RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // nothing to do here
+  } else {
+    listenersSet->second.erase(listener);
+  }
+}
+
+} // namespace audioapi

package/common/cpp/jsi/RuntimeLifecycleMonitor.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace audioapi {
+
+using namespace facebook;
+
+/**
+ * Listener interface that allows for getting notified when a jsi::Runtime
+ * instance is destroyed.
+ */
+struct RuntimeLifecycleListener {
+  virtual ~RuntimeLifecycleListener() = default;
+  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
+};
+
+/**
+ * This class provides an API via static methods for registering and
+ * unregistering runtime lifecycle listeners. The listeners can be used to
+ * cleanup any data that references a given jsi::Runtime instance before it gets
+ * destroyed.
+ */
+struct RuntimeLifecycleMonitor {
+  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
+  static void removeListener(
+      jsi::Runtime &rt,
+      RuntimeLifecycleListener *listener);
+};
+
+} // namespace audioapi

package/common/cpp/types/BiquadFilterType.h

@@ -1,9 +1,5 @@
 #pragma once
 
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
 namespace audioapi {
 
 enum class BiquadFilterType {

package/common/cpp/types/ChannelCountMode.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <stdexcept>
-#include <string>
-
 namespace audioapi {
 
 enum class ChannelCountMode { MAX, CLAMPED_MAX, EXPLICIT };

package/common/cpp/types/ChannelInterpretation.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <stdexcept>
-#include <string>
-
 namespace audioapi {
 
 enum class ChannelInterpretation { SPEAKERS, DISCRETE };

package/common/cpp/types/ContextState.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <stdexcept>
-#include <string>
-
 namespace audioapi {
 
 enum class ContextState { SUSPENDED, RUNNING, CLOSED };

package/common/cpp/types/OscillatorType.h

@@ -1,9 +1,5 @@
 #pragma once
 
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
 namespace audioapi {
 
 enum class OscillatorType { SINE, SQUARE, SAWTOOTH, TRIANGLE, CUSTOM };

package/common/cpp/types/ParamChangeEventType.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace audioapi {
+
+enum class ParamChangeEventType {
+  LINEAR_RAMP,
+  EXPONENTIAL_RAMP,
+  SET_VALUE,
+  SET_TARGET,
+  SET_VALUE_CURVE,
+};
+
+} // namespace audioapi

package/common/cpp/utils/AudioUtils.h

@@ -7,10 +7,6 @@ size_t timeToSampleFrame(double time, int sampleRate);
 
 double sampleFrameToTime(int sampleFrame, int sampleRate);
 
-float linearInterpolate(
-    const float *source,
-    size_t firstIndex,
-    size_t secondIndex,
-    float factor);
+float linearInterpolate(const float *source, size_t firstIndex, size_t secondIndex, float factor);
 
 } // namespace audioapi::AudioUtils

package/common/cpp/utils/{ios/FFTFrame.cpp → FFTFrame.cpp}

@@ -1,8 +1,15 @@
-#if defined(HAVE_ACCELERATE)
 #include "FFTFrame.h"
-#include "Accelerate/Accelerate.h"
+
+#if defined(HAVE_ACCELERATE)
+#include <Accelerate/Accelerate.h>
+#endif
+
+#if defined(ANDROID)
+#include <fftw3.h>
+#endif
 
 namespace audioapi {
+#if defined(HAVE_ACCELERATE)
 
 void FFTFrame::inverse(float *timeDomainData) {
   FFTSetup fftSetup_ = vDSP_create_fftsetup(log2Size_, FFT_RADIX2);
@@ -25,5 +32,25 @@ void FFTFrame::inverse(float *timeDomainData) {
 
   vDSP_destroy_fftsetup(fftSetup_);
 }
-} // namespace audioapi
+
+#elif defined(ANDROID)
+
+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_);
+}
+
 #endif
+} // namespace audioapi

package/common/cpp/utils/VectorMath.h

@@ -32,40 +32,14 @@
 
 namespace audioapi::VectorMath {
 
-void multiplyByScalarThenAddToOutput(
-    const float *inputVector,
-    float scalar,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
 
-void multiplyByScalar(
-    const float *inputVector,
-    float scalar,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
-void addScalar(
-    const float *inputVector,
-    float scalar,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
-void add(
-    const float *inputVector1,
-    const float *inputVector2,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
-void subtract(
-    const float *inputVector1,
-    const float *inputVector2,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
-void multiply(
-    const float *inputVector1,
-    const float *inputVector2,
-    float *outputVector,
-    size_t numberOfElementsToProcess);
+void multiplyByScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
+void addScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
+void add(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
+void subtract(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
+void multiply(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
 
 // Finds the maximum magnitude of a float vector.
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess);
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
 } // namespace audioapi::VectorMath

package/ios/AudioAPIModule.h

@@ -1,9 +1,6 @@
 #ifdef RCT_NEW_ARCH_ENABLED
-#import <React/RCTInitializing.h>
-#if REACT_NATIVE_MINOR_VERSION >= 74
-#import <React/RCTRuntimeExecutorModule.h>
-#import <ReactCommon/RCTRuntimeExecutor.h>
-#endif // REACT_NATIVE_MINOR_VERSION >= 74
+#import <React/RCTCallInvokerModule.h>
+#import <rnaudioapi/rnaudioapi.h>
 #else // RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridgeModule.h>
 #endif // RCT_NEW_ARCH_ENABLED
@@ -12,13 +9,8 @@
 
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
-                            <RCTInitializing
-#if REACT_NATIVE_MINOR_VERSION >= 74
-                             ,
-                             RCTRuntimeExecutorModule
-#endif // REACT_NATIVE_MINOR_VERSION >= 74
+                            <RCTCallInvokerModule>
 #else
-                            <RCTBridgeModule
+                            <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED
-                             >
 @end

package/ios/AudioAPIModule.mm

@@ -1,39 +1,44 @@
 #import "AudioAPIModule.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridge+Private.h>
-#import <React/RCTBridge.h>
-#import <React/RCTUtils.h>
+#import <React/RCTCallInvoker.h>
 #import <ReactCommon/RCTTurboModule.h>
-#import <jsi/jsi.h>
+#endif // RCT_NEW_ARCH_ENABLED
 
 #import "AudioAPIInstallerHostObject.h"
 
 @implementation AudioAPIModule
 
+#if defined(RCT_NEW_ARCH_ENABLED)
+// nothing
+#else // defined(RCT_NEW_ARCH_ENABLED)
+@interface RCTBridge (RCTTurboModule)
+- (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
+- (void)_tryAndHandleError:(dispatch_block_t)block;
+@end
+#endif // RCT_NEW_ARCH_ENABLED
+
+#if defined(RCT_NEW_ARCH_ENABLED)
+@synthesize callInvoker = _callInvoker;
+#endif // defined(RCT_NEW_ARCH_ENABLED)
+
 RCT_EXPORT_MODULE(AudioAPIModule)
 
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
-  NSLog(@"Installing JSI bindings for react-native-audio-api...");
-  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
-
-  if (cxxBridge == nil) {
-    NSLog(@"Error during getting bridge!");
-    return @false;
-  }
-
-  using namespace facebook;
-
-  auto jsRuntime = (jsi::Runtime *)cxxBridge.runtime;
+  auto *cxxBridge = reinterpret_cast<RCTCxxBridge *>(self.bridge);
+  auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(cxxBridge.runtime);
 
-  if (jsRuntime == nil) {
-    NSLog(@"Error during getting jsRuntime!");
-    return @false;
-  }
+#if defined(RCT_NEW_ARCH_ENABLED)
+  auto jsCallInvoker = _callInvoker.callInvoker;
+#else // defined(RCT_NEW_ARCH_ENABLED)
+  auto jsCallInvoker = self.bridge.jsCallInvoker;
+#endif // defined(RCT_NEW_ARCH_ENABLED)
 
-  auto &runtime = *jsRuntime;
+  assert(jsiRuntime != nullptr);
 
-  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(jsRuntime, cxxBridge.jsCallInvoker);
+  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(jsiRuntime, jsCallInvoker);
   hostObject->install();
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");