react-native-audio-api 0.3.0-rc2 → 0.3.2

package/common/cpp/{HostObjects → core}/Constants.h

@@ -8,8 +8,8 @@
 namespace audioapi {
 constexpr int SAMPLE_RATE = 44100;
 constexpr int CHANNEL_COUNT = 2;
-constexpr float MOST_POSITIVE_SINGLE_FLOAT =
-    static_cast<float>(std::numeric_limits<float>::max());
+constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
+constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
 constexpr float NYQUIST_FREQUENCY = SAMPLE_RATE / 2.0;
 static float MAX_DETUNE = 1200 * std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 constexpr float MAX_GAIN = MOST_POSITIVE_SINGLE_FLOAT;

package/common/cpp/core/GainNode.cpp

@@ -6,7 +6,7 @@
 namespace audioapi {
 
 GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
-  gainParam_ = std::make_shared<AudioParam>(context, 1.0, -MAX_GAIN, MAX_GAIN);
+  gainParam_ = std::make_shared<AudioParam>(1.0, -MAX_GAIN, MAX_GAIN);
   isInitialized_ = true;
 }
 

package/common/cpp/core/OscillatorNode.cpp

@@ -8,9 +8,8 @@ namespace audioapi {
 OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      context, 444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
-  detuneParam_ =
-      std::make_shared<AudioParam>(context, 0.0, -MAX_DETUNE, MAX_DETUNE);
+      444.0, -NYQUIST_FREQUENCY, NYQUIST_FREQUENCY);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
   isInitialized_ = true;
@@ -40,15 +39,20 @@ void OscillatorNode::setPeriodicWave(
 }
 
 void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
   if (!isPlaying()) {
     processingBus->zero();
     return;
   }
 
-  double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
+  double time = context_->getCurrentTime() + startOffset * deltaTime;
 
-  for (int i = 0; i < framesToProcess; i += 1) {
+  for (size_t i = startOffset; i < offsetLength; i += 1) {
     auto detuneRatio =
         std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
     auto detunedFrequency =
@@ -70,6 +74,8 @@ void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
 
     time += deltaTime;
   }
+
+  handleStopScheduled();
 }
 
 } // namespace audioapi

package/common/cpp/core/ParamChangeEvent.cpp

@@ -0,0 +1,58 @@
+#include "ParamChangeEvent.h"
+
+#include <utility>
+
+namespace audioapi {
+
+ParamChangeEvent::ParamChangeEvent(
+    double startTime,
+    double endTime,
+    float startValue,
+    float endValue,
+    std::function<float(double, double, float, float, double)> calculateValue,
+    ParamChangeEventType type)
+    : startTime_(startTime),
+      endTime_(endTime),
+      startValue_(startValue),
+      endValue_(endValue),
+      calculateValue_(std::move(calculateValue)),
+      type_(type) {}
+
+double ParamChangeEvent::getEndTime() const {
+  return endTime_;
+}
+
+double ParamChangeEvent::getStartTime() const {
+  return startTime_;
+}
+
+float ParamChangeEvent::getEndValue() const {
+  return endValue_;
+}
+
+float ParamChangeEvent::getStartValue() const {
+  return startValue_;
+}
+
+std::function<float(double, double, float, float, double)>
+ParamChangeEvent::getCalculateValue() const {
+  return calculateValue_;
+}
+
+ParamChangeEventType ParamChangeEvent::getType() const {
+  return type_;
+}
+
+void ParamChangeEvent::setEndTime(double endTime) {
+  endTime_ = endTime;
+}
+
+void ParamChangeEvent::setStartValue(float startValue) {
+  startValue_ = startValue;
+}
+
+void ParamChangeEvent::setEndValue(float endValue) {
+  endValue_ = endValue;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,90 @@
+#include "JsiHostObject.h"
+
+namespace audioapi {
+JsiHostObject::JsiHostObject() {
+  getters_ = std::make_unique<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  functions_ = std::make_unique<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>>();
+  setters_ = std::make_unique<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
+}
+
+std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.reserve(
+      getters_->size() + functions_->size() + setters_->size());
+
+  for (const auto &it : *getters_) {
+    propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
+  }
+
+  for (const auto &it : *functions_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  for (const auto &it : *setters_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  return propertyNames;
+}
+
+jsi::Value JsiHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &name) {
+  auto nameAsString = name.utf8(runtime);
+  auto &hostFunctionCache = hostFunctionCache_.get(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 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();
+}
+
+void JsiHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &name,
+    const jsi::Value &value) {
+  auto nameAsString = name.utf8(runtime);
+
+  auto setter = setters_->find(nameAsString);
+
+  if (setter != setters_->end()) {
+    auto dispatcher = std::bind(
+        setter->second, this, std::placeholders::_1, std::placeholders::_2);
+
+    return dispatcher(runtime, value);
+  }
+}
+} // namespace audioapi

package/common/cpp/jsi/JsiHostObject.h

@@ -0,0 +1,100 @@
+#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,     \
+      const jsi::Value &thisVal, \
+      const jsi::Value *args,    \
+      size_t count)
+
+#define JSI_EXPORT_FUNCTION(CLASS, FUNCTION)                                \
+  std::make_pair(                                                           \
+      std::string(#FUNCTION),                                               \
+      static_cast<jsi::Value (JsiHostObject::*)(                            \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
+
+#define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)               \
+  std::make_pair(                                                 \
+      std::string(#FUNCTION),                                     \
+      static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>( \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_SETTER(name) \
+  void name(jsi::Runtime &runtime, const jsi::Value &value)
+
+#define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION) \
+  std::make_pair(                                   \
+      std::string(#FUNCTION),                       \
+      static_cast<void (JsiHostObject::*)(          \
+          jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+
+namespace audioapi {
+
+using namespace facebook;
+
+class JsiHostObject : public jsi::HostObject {
+ public:
+  JsiHostObject();
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  template <typename... Args>
+  void addGetters(Args... args) {
+    (getters_->insert(args), ...);
+  }
+
+  template <typename... Args>
+  void addSetters(Args... args) {
+    (setters_->insert(args), ...);
+  }
+
+  template <typename... Args>
+  void addFunctions(Args... args) {
+    (functions_->insert(args), ...);
+  }
+
+ protected:
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
+      getters_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(
+          jsi::Runtime &,
+          const jsi::Value &,
+          const jsi::Value *,
+          size_t)>>
+      functions_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+      setters_;
+
+ private:
+  RuntimeAwareCache<std::map<std::string, jsi::Function>> hostFunctionCache_;
+};
+
+} // namespace audioapi

package/common/cpp/{utils → jsi}/JsiPromise.cpp

@@ -4,17 +4,18 @@
 #include <jsi/jsi.h>
 #include <functional>
 
-namespace JsiPromise {
+namespace audioapi {
 
 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!");
+    const std::function<void(std::shared_ptr<Promise>)> &function) {
+  if (runtime_ == nullptr) {
+    throw std::runtime_error("Runtime was null!");
   }
-  auto &runtime = *_runtime;
-  auto callInvoker = _callInvoker;
+
+  auto &runtime = *runtime_;
+  auto callInvoker = callInvoker_;
 
   // get Promise constructor
   auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
@@ -24,7 +25,7 @@ jsi::Value PromiseVendor::createPromise(
       runtime,
       jsi::PropNameID::forUtf8(runtime, "runPromise"),
       2,
-      [callInvoker, func](
+      [callInvoker, function](
           jsi::Runtime &runtime,
           const jsi::Value &thisValue,
           const jsi::Value *arguments,
@@ -52,7 +53,7 @@ jsi::Value PromiseVendor::createPromise(
         };
 
         auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
-        func(promise);
+        function(promise);
 
         return jsi::Value::undefined();
       });
@@ -61,4 +62,4 @@ jsi::Value PromiseVendor::createPromise(
   return promiseCtor.callAsConstructor(runtime, runPromise);
 }
 
-} // namespace JsiPromise
+} // namespace audioapi

package/common/cpp/jsi/JsiPromise.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace audioapi {
+
+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)) {}
+
+  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,
+      const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : runtime_(runtime), callInvoker_(callInvoker) {}
+
+ public:
+  jsi::Value createPromise(
+      const std::function<void(std::shared_ptr<Promise>)> &function);
+
+ private:
+  jsi::Runtime *runtime_;
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+};
+
+} // 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