react-native-audio-api 0.0.1 → 0.1.0

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioBufferSourceNode.h"
+#include "AudioBufferWrapper.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+
+class AudioBufferSourceNodeWrapper : public AudioScheduledSourceNodeWrapper {
+ public:
+  explicit AudioBufferSourceNodeWrapper(
+      const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode);
+
+  void setLoop(bool loop);
+  bool getLoop();
+  std::shared_ptr<AudioBufferWrapper> getBuffer();
+  void setBuffer(const std::shared_ptr<AudioBufferWrapper> &buffer);
+
+ private:
+  std::shared_ptr<AudioBufferSourceNode>
+  getAudioBufferSourceNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.cpp

@@ -0,0 +1,46 @@
+#include "AudioBufferWrapper.h"
+
+namespace audioapi {
+
+AudioBufferWrapper::AudioBufferWrapper(
+    const std::shared_ptr<AudioBuffer> &audioBuffer)
+    : audioBuffer_(audioBuffer) {}
+
+int AudioBufferWrapper::getSampleRate() const {
+  return audioBuffer_->getSampleRate();
+}
+
+int AudioBufferWrapper::getLength() const {
+  return audioBuffer_->getLength();
+}
+
+double AudioBufferWrapper::getDuration() const {
+  return audioBuffer_->getDuration();
+}
+
+int AudioBufferWrapper::getNumberOfChannels() const {
+  return audioBuffer_->getNumberOfChannels();
+}
+
+float *AudioBufferWrapper::getChannelData(int channel) const {
+  return audioBuffer_->getChannelData(channel);
+}
+
+void AudioBufferWrapper::copyFromChannel(
+    float *destination,
+    int destinationLength,
+    int channelNumber,
+    int startInChannel) const {
+  audioBuffer_->copyFromChannel(
+      destination, destinationLength, channelNumber, startInChannel);
+}
+
+void AudioBufferWrapper::copyToChannel(
+    float *source,
+    int sourceLength,
+    int channelNumber,
+    int startInChannel) const {
+  audioBuffer_->copyToChannel(
+      source, sourceLength, channelNumber, startInChannel);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioBuffer.h"
+
+namespace audioapi {
+
+class AudioBufferWrapper {
+ public:
+  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;
+  void copyFromChannel(
+      float *destination,
+      int destinationLength,
+      int channelNumber,
+      int startInChannel = 0) const;
+  void copyToChannel(
+      float *source,
+      int sourceLength,
+      int channelNumber,
+      int startInChannel = 0) const;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.cpp

@@ -0,0 +1,70 @@
+#include "AudioContextWrapper.h"
+
+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();
+}
+
+double AudioContextWrapper::getCurrentTime() const {
+  return audioContext_->getCurrentTime();
+}
+
+void AudioContextWrapper::close() const {
+  audioContext_->close();
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.h

@@ -0,0 +1,40 @@
+#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"
+
+namespace audioapi {
+
+class AudioContextWrapper {
+ public:
+  explicit AudioContextWrapper(
+      const std::shared_ptr<AudioContext> &audiocontext);
+
+  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;
+
+ private:
+  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
+  std::shared_ptr<AudioContext> audioContext_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioDestinationNodeWrapper.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioDestinationNode.h"
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+
+class AudioDestinationNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit AudioDestinationNodeWrapper(
+      const std::shared_ptr<AudioDestinationNode> &destinationNode)
+      : AudioNodeWrapper(destinationNode) {}
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.cpp

@@ -0,0 +1,37 @@
+#include "AudioNodeWrapper.h"
+
+namespace audioapi {
+
+AudioNodeWrapper::AudioNodeWrapper(const std::shared_ptr<AudioNode> &node)
+    : node_(node) {}
+
+int AudioNodeWrapper::getNumberOfInputs() const {
+  return node_->getNumberOfInputs();
+}
+
+int AudioNodeWrapper::getNumberOfOutputs() const {
+  return node_->getNumberOfOutputs();
+}
+
+int AudioNodeWrapper::getChannelCount() const {
+  return node_->getChannelCount();
+}
+
+std::string AudioNodeWrapper::getChannelCountMode() const {
+  return node_->getChannelCountMode();
+}
+
+std::string AudioNodeWrapper::getChannelInterpretation() const {
+  return node_->getChannelInterpretation();
+}
+
+void AudioNodeWrapper::connect(
+    const std::shared_ptr<AudioNodeWrapper> &node) const {
+  node_->connect(node->node_);
+}
+
+void AudioNodeWrapper::disconnect(
+    const std::shared_ptr<AudioNodeWrapper> &node) const {
+  node_->disconnect(node->node_);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "AudioNode.h"
+
+namespace audioapi {
+
+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;
+  void connect(const std::shared_ptr<AudioNodeWrapper> &node) const;
+  void disconnect(const std::shared_ptr<AudioNodeWrapper> &node) const;
+
+ protected:
+  std::shared_ptr<AudioNode> node_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.cpp

@@ -0,0 +1,42 @@
+#include "AudioParamWrapper.h"
+
+namespace audioapi {
+
+AudioParamWrapper::AudioParamWrapper(const std::shared_ptr<AudioParam> &param)
+    : param_(param) {}
+
+float AudioParamWrapper::getValue() const {
+  return param_->getValue();
+}
+
+void AudioParamWrapper::setValue(float value) const {
+  param_->setValue(value);
+}
+
+float AudioParamWrapper::getDefaultValue() const {
+  return param_->getDefaultValue();
+}
+
+float AudioParamWrapper::getMinValue() const {
+  return param_->getMinValue();
+}
+
+float AudioParamWrapper::getMaxValue() const {
+  return param_->getMaxValue();
+}
+
+void AudioParamWrapper::setValueAtTime(float value, double startTime) const {
+  param_->setValueAtTime(value, startTime);
+}
+
+void AudioParamWrapper::linearRampToValueAtTime(float value, double endTime)
+    const {
+  param_->linearRampToValueAtTime(value, endTime);
+}
+
+void AudioParamWrapper::exponentialRampToValueAtTime(
+    float value,
+    double endTime) const {
+  param_->exponentialRampToValueAtTime(value, endTime);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioParam.h"
+
+namespace audioapi {
+
+class AudioParamWrapper {
+ public:
+  explicit AudioParamWrapper(const std::shared_ptr<AudioParam> &param);
+
+  float getValue() const;
+  void setValue(float value) const;
+  float getDefaultValue() const;
+  float getMinValue() const;
+  float getMaxValue() const;
+  void setValueAtTime(float value, double startTime) const;
+  void linearRampToValueAtTime(float value, double endTime) const;
+  void exponentialRampToValueAtTime(float value, double endTime) const;
+
+ private:
+  std::shared_ptr<AudioParam> param_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.cpp

@@ -0,0 +1,23 @@
+#include "AudioScheduledSourceNodeWrapper.h"
+
+namespace audioapi {
+
+AudioScheduledSourceNodeWrapper::AudioScheduledSourceNodeWrapper(
+    const std::shared_ptr<AudioScheduledSourceNode> &audioScheduledSourceNode)
+    : AudioNodeWrapper(audioScheduledSourceNode) {}
+
+std::shared_ptr<AudioScheduledSourceNode>
+AudioScheduledSourceNodeWrapper::getAudioScheduledSourceNodeFromAudioNode() {
+  return std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+}
+
+void AudioScheduledSourceNodeWrapper::start(double time) {
+  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
+  audioScheduledSourceNode->start(time);
+}
+
+void AudioScheduledSourceNodeWrapper::stop(double time) {
+  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
+  audioScheduledSourceNode->stop(time);
+}
+} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioScheduledSourceNode.h"
+
+namespace audioapi {
+
+class AudioScheduledSourceNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit AudioScheduledSourceNodeWrapper(
+      const std::shared_ptr<AudioScheduledSourceNode>
+          &audioScheduledSourceNode);
+
+  void start(double time);
+  void stop(double time);
+
+ private:
+  std::shared_ptr<AudioScheduledSourceNode>
+  getAudioScheduledSourceNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.cpp

@@ -0,0 +1,51 @@
+#include "BiquadFilterNodeWrapper.h"
+
+namespace audioapi {
+
+std::shared_ptr<BiquadFilterNode>
+BiquadFilterNodeWrapper::getBiquadFilterNodeFromAudioNode() {
+  return std::static_pointer_cast<BiquadFilterNode>(node_);
+}
+
+BiquadFilterNodeWrapper::BiquadFilterNodeWrapper(
+    const std::shared_ptr<BiquadFilterNode> &biquadFilterNode)
+    : AudioNodeWrapper(biquadFilterNode) {
+  auto frequencyParam = biquadFilterNode->getFrequencyParam();
+  frequencyParam_ = std::make_shared<AudioParamWrapper>(frequencyParam);
+  auto detuneParam = biquadFilterNode->getDetuneParam();
+  detuneParam_ = std::make_shared<AudioParamWrapper>(detuneParam);
+  auto QParam = biquadFilterNode->getQParam();
+  QParam_ = std::make_shared<AudioParamWrapper>(QParam);
+  auto gainParam = biquadFilterNode->getGainParam();
+  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getFrequencyParam()
+    const {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getDetuneParam()
+    const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getQParam() const {
+  return QParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getGainParam()
+    const {
+  return gainParam_;
+}
+
+std::string BiquadFilterNodeWrapper::getType() {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  return biquadFilterNode_->getType();
+}
+
+void BiquadFilterNodeWrapper::setType(const std::string &filterType) {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  biquadFilterNode_->setType(filterType);
+}
+} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "BiquadFilterNode.h"
+
+namespace audioapi {
+
+class BiquadFilterNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit BiquadFilterNodeWrapper(
+      const std::shared_ptr<BiquadFilterNode> &biquadFilterNode);
+
+  std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  std::shared_ptr<AudioParamWrapper> getQParam() const;
+  std::shared_ptr<AudioParamWrapper> getGainParam() const;
+  std::string getType();
+  void setType(const std::string &filterType);
+
+ private:
+  std::shared_ptr<AudioParamWrapper> frequencyParam_;
+  std::shared_ptr<AudioParamWrapper> detuneParam_;
+  std::shared_ptr<AudioParamWrapper> QParam_;
+  std::shared_ptr<AudioParamWrapper> gainParam_;
+
+  std::shared_ptr<BiquadFilterNode> getBiquadFilterNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.cpp

@@ -0,0 +1,14 @@
+#include "GainNodeWrapper.h"
+
+namespace audioapi {
+
+GainNodeWrapper::GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode)
+    : AudioNodeWrapper(gainNode) {
+  auto gainParam = gainNode->getGainParam();
+  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
+}
+
+std::shared_ptr<AudioParamWrapper> GainNodeWrapper::getGainParam() const {
+  return gainParam_;
+}
+} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "GainNode.h"
+
+namespace audioapi {
+
+class GainNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode);
+
+  std::shared_ptr<AudioParamWrapper> getGainParam() const;
+
+ private:
+  std::shared_ptr<AudioParamWrapper> gainParam_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/OscillatorNodeWrapper.cpp

@@ -0,0 +1,38 @@
+#include "OscillatorNodeWrapper.h"
+
+namespace audioapi {
+
+std::shared_ptr<OscillatorNode>
+OscillatorNodeWrapper::getOscillatorNodeFromAudioNode() {
+  return std::static_pointer_cast<OscillatorNode>(node_);
+}
+
+OscillatorNodeWrapper::OscillatorNodeWrapper(
+    const std::shared_ptr<OscillatorNode> &oscillator)
+    : AudioScheduledSourceNodeWrapper(oscillator) {
+  auto frequencyParam = oscillator->getFrequencyParam();
+  frequencyParam_ = std::make_shared<AudioParamWrapper>(frequencyParam);
+  auto detuneParam = oscillator->getDetuneParam();
+  detuneParam_ = std::make_shared<AudioParamWrapper>(detuneParam);
+}
+
+std::shared_ptr<AudioParamWrapper> OscillatorNodeWrapper::getFrequencyParam()
+    const {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> OscillatorNodeWrapper::getDetuneParam()
+    const {
+  return detuneParam_;
+}
+
+std::string OscillatorNodeWrapper::getType() {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  return oscillatorNode_->getType();
+}
+
+void OscillatorNodeWrapper::setType(const std::string &type) {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  oscillatorNode_->setType(type);
+}
+} // namespace audioapi

package/common/cpp/wrappers/OscillatorNodeWrapper.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "AudioParamWrapper.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+#include "OscillatorNode.h"
+
+namespace audioapi {
+
+class OscillatorNodeWrapper : public AudioScheduledSourceNodeWrapper {
+ public:
+  explicit OscillatorNodeWrapper(
+      const std::shared_ptr<OscillatorNode> &oscillatorNode);
+
+  std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  std::string getType();
+  void setType(const std::string &type);
+
+ private:
+  std::shared_ptr<AudioParamWrapper> frequencyParam_;
+  std::shared_ptr<AudioParamWrapper> detuneParam_;
+
+  std::shared_ptr<OscillatorNode> getOscillatorNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/StereoPannerNodeWrapper.cpp

@@ -0,0 +1,16 @@
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+
+StereoPannerNodeWrapper::StereoPannerNodeWrapper(
+    const std::shared_ptr<StereoPannerNode> &stereoPannerNode)
+    : AudioNodeWrapper(stereoPannerNode) {
+  auto panParam = stereoPannerNode->getPanParam();
+  panParam_ = std::make_shared<AudioParamWrapper>(panParam);
+}
+
+std::shared_ptr<AudioParamWrapper> StereoPannerNodeWrapper::getPanParam()
+    const {
+  return panParam_;
+}
+} // namespace audioapi

package/common/cpp/wrappers/StereoPannerNodeWrapper.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "StereoPannerNode.h"
+
+namespace audioapi {
+
+class StereoPannerNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit StereoPannerNodeWrapper(
+      const std::shared_ptr<StereoPannerNode> &stereoPannerNode);
+
+  std::shared_ptr<AudioParamWrapper> getPanParam() const;
+
+ private:
+  std::shared_ptr<AudioParamWrapper> panParam_;
+};
+} // namespace audioapi

package/ios/AudioAPIModule.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface AudioAPIModule : NSObject <RCTBridgeModule>
+
+@end