react-native-audio-api 0.0.1 → 0.1.0

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioParamHostObject.h"
+#include "AudioScheduledSourceNodeHostObject.h"
+#include "OscillatorNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit OscillatorNodeHostObject(
+      const std::shared_ptr<OscillatorNodeWrapper> &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<OscillatorNodeHostObject> createFromWrapper(
+      const std::shared_ptr<OscillatorNodeWrapper> &wrapper) {
+    return std::make_shared<OscillatorNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> frequencyParam_;
+  std::shared_ptr<AudioParamHostObject> detuneParam_;
+
+  std::shared_ptr<OscillatorNodeWrapper>
+  getOscillatorNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/StereoPannerNodeHostObject.cpp

@@ -0,0 +1,41 @@
+#include "StereoPannerNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+StereoPannerNodeHostObject::StereoPannerNodeHostObject(
+    const std::shared_ptr<StereoPannerNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {
+  auto panParam = wrapper->getPanParam();
+  panParam_ = AudioParamHostObject::createFromWrapper(panParam);
+}
+
+std::vector<jsi::PropNameID> StereoPannerNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "pan"));
+  return propertyNames;
+}
+
+jsi::Value StereoPannerNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "pan") {
+    return jsi::Object::createFromHostObject(runtime, panParam_);
+  }
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void StereoPannerNodeHostObject::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/StereoPannerNodeHostObject.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class StereoPannerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit StereoPannerNodeHostObject(
+      const std::shared_ptr<StereoPannerNodeWrapper> &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<StereoPannerNodeHostObject> createFromWrapper(
+      const std::shared_ptr<StereoPannerNodeWrapper> &wrapper) {
+    return std::make_shared<StereoPannerNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioParamHostObject> panParam_;
+};
+} // namespace audioapi

package/common/cpp/core/AudioBuffer.cpp

@@ -0,0 +1,115 @@
+#include "AudioBuffer.h"
+
+namespace audioapi {
+
+AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate)
+    : numberOfChannels_(numberOfChannels),
+      length_(length),
+      sampleRate_(sampleRate),
+      duration_(static_cast<double>(length) / sampleRate) {
+  if (numberOfChannels != 1 && numberOfChannels != 2) {
+    throw std::invalid_argument("Invalid number of channels");
+  }
+
+  channels_ = new float *[numberOfChannels];
+
+  for (int i = 0; i < numberOfChannels; i++) {
+    channels_[i] = new float[length];
+
+    for (int j = 0; j < length; j++) {
+      channels_[i][j] = 0.0f;
+    }
+  }
+}
+
+int AudioBuffer::getNumberOfChannels() const {
+  return numberOfChannels_;
+}
+
+int AudioBuffer::getLength() const {
+  return length_;
+}
+
+int AudioBuffer::getSampleRate() const {
+  return sampleRate_;
+}
+
+double AudioBuffer::getDuration() const {
+  return duration_;
+}
+
+float *AudioBuffer::getChannelData(int channel) const {
+  if (channel < 0 || channel >= numberOfChannels_) {
+    throw std::invalid_argument("Invalid channel number");
+  }
+
+  return channels_[channel];
+}
+
+std::shared_ptr<AudioBuffer> AudioBuffer::mix(int outputNumberOfChannels) {
+  if (outputNumberOfChannels != 1 && outputNumberOfChannels != 2) {
+    throw std::invalid_argument("Invalid number of channels");
+  }
+
+  if (outputNumberOfChannels == numberOfChannels_) {
+    return shared_from_this();
+  }
+
+  auto mixedBuffer = std::make_shared<AudioBuffer>(
+      outputNumberOfChannels, length_, sampleRate_);
+
+  switch (this->numberOfChannels_) {
+    case 1:
+      mixedBuffer->copyToChannel(this->channels_[0], length_, 0, 0);
+      mixedBuffer->copyToChannel(this->channels_[0], length_, 1, 0);
+      break;
+    case 2:
+      for (int i = 0; i < length_; i++) {
+        mixedBuffer->channels_[0][i] =
+            (this->channels_[0][i] + this->channels_[1][i]) / 2;
+      }
+      break;
+  }
+
+  return mixedBuffer;
+}
+
+void AudioBuffer::copyFromChannel(
+    float *destination,
+    int destinationLength,
+    int channelNumber,
+    int startInChannel) const {
+  if (channelNumber < 0 || channelNumber >= numberOfChannels_) {
+    throw std::invalid_argument("Invalid channel number");
+  }
+
+  if (startInChannel < 0 || startInChannel >= length_) {
+    throw std::invalid_argument("Invalid start in channel");
+  }
+
+  std::copy(
+      channels_[channelNumber] + startInChannel,
+      channels_[channelNumber] + startInChannel +
+          std::min(destinationLength, length_ - startInChannel),
+      destination);
+}
+
+void AudioBuffer::copyToChannel(
+    const float *source,
+    int sourceLength,
+    int channelNumber,
+    int startInChannel) {
+  if (channelNumber < 0 || channelNumber >= numberOfChannels_) {
+    throw std::invalid_argument("Invalid channel number");
+  }
+
+  if (startInChannel < 0 || startInChannel >= length_) {
+    throw std::invalid_argument("Invalid start in channel");
+  }
+
+  std::copy(
+      source,
+      source + std::min(sourceLength, length_ - startInChannel),
+      channels_[channelNumber] + startInChannel);
+}
+} // namespace audioapi

package/common/cpp/core/AudioBuffer.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
+ public:
+  explicit AudioBuffer(int numberOfChannels, int length, int sampleRate);
+
+  int getNumberOfChannels() const;
+  int getLength() const;
+  int getSampleRate() const;
+  double getDuration() const;
+  float *getChannelData(int channel) const;
+  void copyFromChannel(
+      float *destination,
+      int destinationLength,
+      int channelNumber,
+      int startInChannel) const;
+  void copyToChannel(
+      const float *source,
+      int sourceLength,
+      int channelNumber,
+      int startInChannel);
+
+ private:
+  friend class AudioBufferSourceNode;
+
+  int numberOfChannels_;
+  int length_;
+  int sampleRate_;
+  double duration_;
+  float **channels_;
+
+  std::shared_ptr<AudioBuffer> mix(int outputNumberOfChannels);
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -0,0 +1,58 @@
+#include "AudioBufferSourceNode.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioBufferSourceNode::AudioBufferSourceNode(AudioContext *context)
+    : AudioScheduledSourceNode(context), loop_(false), bufferIndex_(0) {
+  numberOfInputs_ = 0;
+  buffer_ = std::nullopt;
+}
+
+bool AudioBufferSourceNode::getLoop() const {
+  return loop_;
+}
+
+std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
+  if (!buffer_.has_value()) {
+    throw std::runtime_error("Buffer is not set");
+  }
+
+  return buffer_.value();
+}
+
+void AudioBufferSourceNode::setLoop(bool loop) {
+  loop_ = loop;
+}
+
+void AudioBufferSourceNode::setBuffer(
+    const std::shared_ptr<AudioBuffer> &buffer) {
+  buffer_ = buffer->mix(channelCount_);
+}
+
+bool AudioBufferSourceNode::processAudio(float *audioData, int32_t numFrames) {
+  if (!isPlaying_ || !buffer_.has_value()) {
+    return false;
+  } else {
+    for (int i = 0; i < numFrames; ++i) {
+      for (int j = 0; j < channelCount_; j++) {
+        audioData[i * channelCount_ + j] =
+            buffer_.value()->getChannelData(j)[bufferIndex_];
+      }
+
+      bufferIndex_++;
+
+      if (bufferIndex_ >= buffer_.value()->getLength()) {
+        if (loop_) {
+          bufferIndex_ = 0;
+        } else {
+          isPlaying_ = false;
+          break;
+        }
+      }
+    }
+
+    return true;
+  }
+}
+} // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "AudioBuffer.h"
+#include "AudioScheduledSourceNode.h"
+
+namespace audioapi {
+
+class AudioBufferSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit AudioBufferSourceNode(AudioContext *context);
+
+  bool getLoop() const;
+  std::shared_ptr<AudioBuffer> getBuffer() const;
+  void setLoop(bool loop);
+  void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ private:
+  bool loop_;
+  std::optional<std::shared_ptr<AudioBuffer>> buffer_;
+  int bufferIndex_;
+};
+} // namespace audioapi

package/common/cpp/core/AudioContext.cpp

@@ -0,0 +1,90 @@
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioContext::AudioContext() {
+#ifdef ANDROID
+  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+#else
+  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+#endif
+  destination_ = std::make_shared<AudioDestinationNode>(this);
+
+  sampleRate_ = audioPlayer_->getSampleRate();
+
+  auto now = std::chrono::high_resolution_clock ::now();
+  contextStartTime_ =
+      static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                              now.time_since_epoch())
+                              .count());
+
+  audioPlayer_->start();
+}
+
+std::string AudioContext::getState() {
+  return AudioContext::toString(state_);
+}
+
+int AudioContext::getSampleRate() const {
+  return sampleRate_;
+}
+
+double AudioContext::getCurrentTime() const {
+  auto now = std::chrono::high_resolution_clock ::now();
+  auto currentTime =
+      static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                              now.time_since_epoch())
+                              .count());
+  return (currentTime - contextStartTime_) / 1e9;
+}
+
+void AudioContext::close() {
+  state_ = State::CLOSED;
+
+  if (audioPlayer_) {
+    audioPlayer_->stop();
+  }
+
+  audioPlayer_.reset();
+  destination_.reset();
+}
+
+std::shared_ptr<AudioDestinationNode> AudioContext::getDestination() {
+  return destination_;
+}
+
+std::shared_ptr<OscillatorNode> AudioContext::createOscillator() {
+  return std::make_shared<OscillatorNode>(this);
+}
+
+std::shared_ptr<GainNode> AudioContext::createGain() {
+  return std::make_shared<GainNode>(this);
+}
+
+std::shared_ptr<StereoPannerNode> AudioContext::createStereoPanner() {
+  return std::make_shared<StereoPannerNode>(this);
+}
+
+std::shared_ptr<BiquadFilterNode> AudioContext::createBiquadFilter() {
+  return std::make_shared<BiquadFilterNode>(this);
+}
+
+std::shared_ptr<AudioBufferSourceNode> AudioContext::createBufferSource() {
+  return std::make_shared<AudioBufferSourceNode>(this);
+}
+
+std::shared_ptr<AudioBuffer>
+AudioContext::createBuffer(int numberOfChannels, int length, int sampleRate) {
+  return std::make_shared<AudioBuffer>(numberOfChannels, length, sampleRate);
+}
+
+std::function<void(float *, int)> AudioContext::renderAudio() {
+  if (state_ == State::CLOSED) {
+    return [](float *, int) {};
+  }
+
+  return [this](float *data, int frames) {
+    destination_->renderAudio(data, frames);
+  };
+}
+} // namespace audioapi

package/common/cpp/core/AudioContext.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "AudioBuffer.h"
+#include "AudioBufferSourceNode.h"
+#include "AudioDestinationNode.h"
+#include "AudioScheduledSourceNode.h"
+#include "BiquadFilterNode.h"
+#include "Constants.h"
+#include "GainNode.h"
+#include "OscillatorNode.h"
+#include "StereoPannerNode.h"
+
+#ifdef ANDROID
+#include "AudioPlayer.h"
+#else
+#include "IOSAudioPlayer.h"
+#endif
+
+namespace audioapi {
+
+class AudioContext {
+ public:
+  AudioContext();
+  std::string getState();
+  int getSampleRate() const;
+  double getCurrentTime() const;
+  void close();
+
+  std::shared_ptr<AudioDestinationNode> getDestination();
+  std::shared_ptr<OscillatorNode> createOscillator();
+  std::shared_ptr<GainNode> createGain();
+  std::shared_ptr<StereoPannerNode> createStereoPanner();
+  std::shared_ptr<BiquadFilterNode> createBiquadFilter();
+  std::shared_ptr<AudioBufferSourceNode> createBufferSource();
+  static std::shared_ptr<AudioBuffer>
+  createBuffer(int numberOfChannels, int length, int sampleRate);
+  std::function<void(float *, int)> renderAudio();
+
+ private:
+  enum class State { SUSPENDED, RUNNING, CLOSED };
+
+  static std::string toString(State state) {
+    switch (state) {
+      case State::SUSPENDED:
+        return "suspended";
+      case State::RUNNING:
+        return "running";
+      case State::CLOSED:
+        return "closed";
+      default:
+        throw std::invalid_argument("Unknown context state");
+    }
+  }
+
+ private:
+  std::shared_ptr<AudioDestinationNode> destination_;
+#ifdef ANDROID
+  std::shared_ptr<AudioPlayer> audioPlayer_;
+#else
+  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+#endif
+  State state_ = State::RUNNING;
+  int sampleRate_;
+  double contextStartTime_;
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -0,0 +1,35 @@
+#include "AudioDestinationNode.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioDestinationNode::AudioDestinationNode(AudioContext *context)
+    : AudioNode(context) {
+  numberOfOutputs_ = 0;
+  numberOfInputs_ = INT_MAX;
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+}
+
+void AudioDestinationNode::renderAudio(float *audioData, int32_t numFrames) {
+  processAudio(audioData, numFrames);
+}
+
+bool AudioDestinationNode::processAudio(float *audioData, int32_t numFrames) {
+  int numSamples = numFrames * CHANNEL_COUNT;
+
+  if (mixingBuffer == nullptr) {
+    mixingBuffer = std::make_unique<float[]>(numSamples);
+  }
+
+  memset(audioData, 0.0f, sizeof(float) * numSamples);
+
+  for (auto &node : inputNodes_) {
+    if (node && node->processAudio(mixingBuffer.get(), numFrames)) {
+      VectorMath::add(audioData, mixingBuffer.get(), audioData, numSamples);
+    }
+  }
+
+  return true;
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioDestinationNode.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#include "AudioNode.h"
+#include "VectorMath.h"
+
+namespace audioapi {
+
+class AudioDestinationNode : public AudioNode {
+ public:
+  explicit AudioDestinationNode(AudioContext *context);
+
+  void renderAudio(float *audioData, int32_t numFrames);
+
+ protected:
+  bool processAudio(float *audioData, int32_t numFrames) override;
+
+ private:
+  std::unique_ptr<float[]> mixingBuffer;
+};
+} // namespace audioapi

package/common/cpp/core/AudioNode.cpp

@@ -0,0 +1,68 @@
+#include "AudioNode.h"
+#include "AudioContext.h"
+
+namespace audioapi {
+
+AudioNode::AudioNode(AudioContext *context) : context_(context) {}
+
+AudioNode::~AudioNode() {
+  cleanup();
+}
+
+int AudioNode::getNumberOfInputs() const {
+  return numberOfInputs_;
+}
+
+int AudioNode::getNumberOfOutputs() const {
+  return numberOfOutputs_;
+}
+
+int AudioNode::getChannelCount() const {
+  return channelCount_;
+}
+
+std::string AudioNode::getChannelCountMode() const {
+  return AudioNode::toString(channelCountMode_);
+}
+
+std::string AudioNode::getChannelInterpretation() const {
+  return AudioNode::toString(channelInterpretation_);
+}
+
+void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
+  if (numberOfOutputs_ > outputNodes_.size() &&
+      node->getNumberOfInputs() > node->inputNodes_.size()) {
+    outputNodes_.push_back(node);
+    node->inputNodes_.push_back(shared_from_this());
+  }
+}
+
+void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
+  outputNodes_.erase(
+      std::remove(outputNodes_.begin(), outputNodes_.end(), node),
+      outputNodes_.end());
+  if (auto sharedThis = shared_from_this()) {
+    node->inputNodes_.erase(
+        std::remove(
+            node->inputNodes_.begin(), node->inputNodes_.end(), sharedThis),
+        node->inputNodes_.end());
+  }
+}
+
+void AudioNode::cleanup() {
+  outputNodes_.clear();
+  inputNodes_.clear();
+}
+
+bool AudioNode::processAudio(float *audioData, int32_t numFrames) {
+  bool isPlaying = false;
+  for (auto &node : inputNodes_) {
+    if (node->processAudio(audioData, numFrames)) {
+      isPlaying = true;
+    }
+  }
+
+  return isPlaying;
+}
+
+} // namespace audioapi