react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/HostObjects/AudioNodeHostObject.cpp

@@ -0,0 +1,102 @@
+#include "AudioNodeHostObject.h"
+#include "AudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioNodeHostObject::AudioNodeHostObject(
+    const std::shared_ptr<AudioNodeWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "connect"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "disconnect"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "numberOfInputs"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "numberOfOutputs"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "channelCount"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "channelCountMode"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "channelInterpretation"));
+  return propertyNames;
+}
+
+jsi::Value AudioNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "connect") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto node =
+              args[0].getObject(rt).getHostObject<AudioNodeHostObject>(rt);
+          wrapper_->connect(
+              std::shared_ptr<AudioNodeHostObject>(node)->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "disconnect") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto node =
+              args[0].getObject(rt).getHostObject<AudioNodeHostObject>(rt);
+          wrapper_->disconnect(
+              std::shared_ptr<AudioNodeHostObject>(node)->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "numberOfInputs") {
+    return {wrapper_->getNumberOfInputs()};
+  }
+
+  if (propName == "numberOfOutputs") {
+    return {wrapper_->getNumberOfOutputs()};
+  }
+
+  if (propName == "channelCount") {
+    return {wrapper_->getChannelCount()};
+  }
+
+  if (propName == "channelCountMode") {
+    return jsi::String::createFromUtf8(
+        runtime, wrapper_->getChannelCountMode());
+  }
+
+  if (propName == "channelInterpretation") {
+    return jsi::String::createFromUtf8(
+        runtime, wrapper_->getChannelInterpretation());
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/AudioNodeHostObject.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioNodeHostObject : public jsi::HostObject {
+ public:
+  explicit AudioNodeHostObject(
+      const std::shared_ptr<AudioNodeWrapper> &wrapper);
+
+  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;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ protected:
+  std::shared_ptr<AudioNodeWrapper> wrapper_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.cpp

@@ -0,0 +1,115 @@
+#include "AudioParamHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioParamHostObject::AudioParamHostObject(
+    const std::shared_ptr<AudioParamWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioParamHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "value"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "defaultValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "minValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "maxValue"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "setValueAtTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "linearRampToValueAtTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "exponentialRampToValueAtTime"));
+  return propertyNames;
+}
+
+jsi::Value AudioParamHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "value") {
+    return {wrapper_->getValue()};
+  }
+
+  if (propName == "defaultValue") {
+    return {wrapper_->getDefaultValue()};
+  }
+
+  if (propName == "minValue") {
+    return {wrapper_->getMinValue()};
+  }
+
+  if (propName == "maxValue") {
+    return {wrapper_->getMaxValue()};
+  }
+
+  if (propName == "setValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double startTime = args[1].getNumber();
+          wrapper_->setValueAtTime(value, startTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "linearRampToValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double endTime = args[1].getNumber();
+          wrapper_->linearRampToValueAtTime(value, endTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "exponentialRampToValueAtTime") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        2,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          double value = args[0].getNumber();
+          double endTime = args[1].getNumber();
+          wrapper_->exponentialRampToValueAtTime(value, endTime);
+          return jsi::Value::undefined();
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioParamHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "value") {
+    double paramValue = value.getNumber();
+    wrapper_->setValue(paramValue);
+    return;
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "AudioParamWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioParamHostObject : public jsi::HostObject {
+ public:
+  explicit AudioParamHostObject(
+      const std::shared_ptr<AudioParamWrapper> &wrapper);
+
+  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;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static std::shared_ptr<AudioParamHostObject> createFromWrapper(
+      const std::shared_ptr<AudioParamWrapper> &wrapper) {
+    return std::make_shared<AudioParamHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamWrapper> wrapper_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.cpp

@@ -0,0 +1,73 @@
+#include "AudioScheduledSourceNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+std::shared_ptr<AudioScheduledSourceNodeWrapper>
+AudioScheduledSourceNodeHostObject::
+    getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<AudioScheduledSourceNodeWrapper>(wrapper_);
+}
+
+std::vector<jsi::PropNameID>
+AudioScheduledSourceNodeHostObject::getPropertyNames(jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "start"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "stop"));
+  return propertyNames;
+}
+
+jsi::Value AudioScheduledSourceNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "start") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto time = args[0].getNumber();
+          auto wrapper =
+              getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+          wrapper->start(time);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "stop") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto time = args[0].getNumber();
+          auto wrapper =
+              getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+          wrapper->stop(time);
+          return jsi::Value::undefined();
+        });
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void AudioScheduledSourceNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AudioScheduledSourceNodeHostObject(
+      const std::shared_ptr<AudioScheduledSourceNodeWrapper> &wrapper)
+      : AudioNodeHostObject(wrapper) {}
+
+  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;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ private:
+  std::shared_ptr<AudioScheduledSourceNodeWrapper>
+  getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -0,0 +1,214 @@
+#include "BaseAudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+BaseAudioContextHostObject::BaseAudioContextHostObject(
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper)
+    : wrapper_(wrapper) {
+  auto destinationNodeWrapper = wrapper_->getDestination();
+  destination_ =
+      AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
+}
+
+std::vector<jsi::PropNameID> BaseAudioContextHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "destination"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "state"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "sampleRate"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "currentTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createOscillator"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createGain"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createStereoPanner"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBiquadFilter"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBufferSource"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createPeriodicWave"));
+  return propertyNames;
+}
+
+jsi::Value BaseAudioContextHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "destination") {
+    return jsi::Object::createFromHostObject(runtime, destination_);
+  }
+
+  if (propName == "state") {
+    return jsi::String::createFromUtf8(runtime, wrapper_->getState());
+  }
+
+  if (propName == "sampleRate") {
+    return {wrapper_->getSampleRate()};
+  }
+
+  if (propName == "currentTime") {
+    return {wrapper_->getCurrentTime()};
+  }
+
+  if (propName == "createOscillator") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto oscillator = wrapper_->createOscillator();
+          auto oscillatorHostObject =
+              OscillatorNodeHostObject::createFromWrapper(oscillator);
+          return jsi::Object::createFromHostObject(
+              runtime, oscillatorHostObject);
+        });
+  }
+
+  if (propName == "createGain") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto gain = wrapper_->createGain();
+          auto gainHostObject = GainNodeHostObject::createFromWrapper(gain);
+          return jsi::Object::createFromHostObject(runtime, gainHostObject);
+        });
+  }
+
+  if (propName == "createStereoPanner") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto stereoPanner = wrapper_->createStereoPanner();
+          auto stereoPannerHostObject =
+              StereoPannerNodeHostObject::createFromWrapper(stereoPanner);
+          return jsi::Object::createFromHostObject(
+              runtime, stereoPannerHostObject);
+        });
+  }
+
+  if (propName == "createBiquadFilter") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto biquadFilter = wrapper_->createBiquadFilter();
+          auto biquadFilterHostObject =
+              BiquadFilterNodeHostObject::createFromWrapper(biquadFilter);
+          return jsi::Object::createFromHostObject(
+              runtime, biquadFilterHostObject);
+        });
+  }
+
+  if (propName == "createBufferSource") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto bufferSource = wrapper_->createBufferSource();
+          auto bufferSourceHostObject =
+              AudioBufferSourceNodeHostObject::createFromWrapper(bufferSource);
+          return jsi::Object::createFromHostObject(
+              runtime, bufferSourceHostObject);
+        });
+  }
+
+  if (propName == "createBuffer") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto numberOfChannels = static_cast<int>(arguments[0].getNumber());
+          auto length = static_cast<int>(arguments[1].getNumber());
+          auto sampleRate = static_cast<int>(arguments[2].getNumber());
+          auto buffer =
+              wrapper_->createBuffer(numberOfChannels, length, sampleRate);
+          auto bufferHostObject =
+              AudioBufferHostObject::createFromWrapper(buffer);
+          return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+        });
+  }
+
+  if (propName == "createPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto real = arguments[0].getObject(runtime).getArray(runtime);
+          auto imag = arguments[1].getObject(runtime).getArray(runtime);
+          auto disableNormalization = arguments[2].getBool();
+          auto length =
+              static_cast<int>(real.getProperty(runtime, "length").asNumber());
+
+          auto *realData = new float[length];
+          auto *imagData = new float[length];
+
+          for (size_t i = 0; i < real.length(runtime); i++) {
+            realData[i] = static_cast<float>(
+                real.getValueAtIndex(runtime, i).getNumber());
+          }
+          for (size_t i = 0; i < imag.length(runtime); i++) {
+            realData[i] = static_cast<float>(
+                imag.getValueAtIndex(runtime, i).getNumber());
+          }
+
+          auto periodicWave = wrapper_->createPeriodicWave(
+              realData, imagData, disableNormalization, length);
+          auto periodicWaveHostObject =
+              PeriodicWaveHostObject::createFromWrapper(periodicWave);
+          return jsi::Object::createFromHostObject(
+              runtime, periodicWaveHostObject);
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void BaseAudioContextHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+} // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "AudioBufferHostObject.h"
+#include "AudioBufferSourceNodeHostObject.h"
+#include "AudioDestinationNodeHostObject.h"
+#include "BaseAudioContextWrapper.h"
+#include "BiquadFilterNodeHostObject.h"
+#include "GainNodeHostObject.h"
+#include "OscillatorNodeHostObject.h"
+#include "PeriodicWaveHostObject.h"
+#include "StereoPannerNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class BaseAudioContextHostObject : public jsi::HostObject {
+ public:
+  explicit BaseAudioContextHostObject(
+      const std::shared_ptr<BaseAudioContextWrapper> &wrapper);
+
+  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;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ protected:
+  std::shared_ptr<BaseAudioContextWrapper> wrapper_;
+  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+};
+} // namespace audioapi