react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/core/AudioContext.cpp

@@ -0,0 +1,24 @@
+#ifdef ANDROID
+#include "AudioPlayer.h"
+#else
+#include "IOSAudioPlayer.h"
+#endif
+
+#include "AudioContext.h"
+
+
+namespace audioapi {
+
+AudioContext::AudioContext() : BaseAudioContext() {}
+
+void AudioContext::close() {
+  state_ = ContextState::CLOSED;
+
+  if (audioPlayer_) {
+    audioPlayer_->stop();
+  }
+
+  audioPlayer_.reset();
+  destination_.reset();
+}
+} // namespace audioapi

package/common/cpp/core/AudioContext.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+
+#include "BaseAudioContext.h"
+
+namespace audioapi {
+
+class AudioContext : public BaseAudioContext {
+ public:
+  AudioContext();
+
+  void close();
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -0,0 +1,45 @@
+#include "AudioBus.h"
+#include "AudioNode.h"
+#include "VectorMath.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
+#include "AudioDestinationNode.h"
+
+namespace audioapi {
+
+AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
+    : AudioNode(context), currentSampleFrame_(0) {
+  numberOfOutputs_ = 0;
+  numberOfInputs_ = INT_MAX;
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  isInitialized_ = true;
+}
+
+std::size_t AudioDestinationNode::getCurrentSampleFrame() const {
+  return currentSampleFrame_;
+}
+
+double AudioDestinationNode::getCurrentTime() const {
+  return static_cast<double>(currentSampleFrame_) / context_->getSampleRate();
+}
+
+void AudioDestinationNode::renderAudio(AudioBus *destinationBus, int32_t numFrames) {
+  context_->getNodeManager()->preProcessGraph();
+  destinationBus->zero();
+
+  if (!numFrames) {
+    return;
+  }
+
+  AudioBus* processedBus = processAudio(destinationBus, numFrames);
+
+  if (processedBus && processedBus != destinationBus) {
+    destinationBus->copy(processedBus);
+  }
+
+  destinationBus->normalize();
+
+  currentSampleFrame_ += numFrames;
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioDestinationNode.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+#include "AudioNode.h"
+
+namespace audioapi {
+
+class AudioBus;
+class BaseAudioContext;
+
+class AudioDestinationNode : public AudioNode {
+ public:
+  explicit AudioDestinationNode(BaseAudioContext *context);
+
+  void renderAudio(AudioBus* audioData, int32_t numFrames);
+
+  std::size_t getCurrentSampleFrame() const;
+  double getCurrentTime() const;
+
+ protected:
+  // DestinationNode is triggered by AudioContext using renderAudio
+  // processNode function is not necessary and is never called.
+  void processNode(AudioBus*, int) final { };
+
+ private:
+  std::size_t currentSampleFrame_;
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioNode.cpp

@@ -0,0 +1,222 @@
+#include <memory>
+
+#include "AudioBus.h"
+#include "AudioNode.h"
+#include "BaseAudioContext.h"
+#include "AudioNodeManager.h"
+
+namespace audioapi {
+
+AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
+  audioBus_ = std::make_shared<AudioBus>(context->getSampleRate(), context->getBufferSizeInFrames(), channelCount_);
+}
+
+AudioNode::~AudioNode() {
+  isInitialized_ = false;
+  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) {
+  context_->getNodeManager()->addPendingConnection(shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
+}
+
+void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
+  outputNodes_.push_back(node);
+  node->onInputConnected(this);
+}
+
+void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
+  context_->getNodeManager()->addPendingConnection(shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
+}
+
+void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
+  node->onInputDisconnected(this);
+
+  auto position = std::find(outputNodes_.begin(), outputNodes_.end(), node);
+
+  if (position != outputNodes_.end()) {
+    outputNodes_.erase(position);
+  }
+}
+
+bool AudioNode::isEnabled() const {
+  return isEnabled_;
+}
+
+void AudioNode::enable() {
+  isEnabled_ = true;
+
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    it->get()->onInputEnabled();
+  }
+}
+
+void AudioNode::disable() {
+  isEnabled_ = false;
+
+  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
+    it->get()->onInputDisabled();
+  }
+}
+
+std::string AudioNode::toString(ChannelCountMode mode) {
+  switch (mode) {
+    case ChannelCountMode::MAX:
+      return "max";
+    case ChannelCountMode::CLAMPED_MAX:
+      return "clamped-max";
+    case ChannelCountMode::EXPLICIT:
+      return "explicit";
+    default:
+      throw std::invalid_argument("Unknown channel count mode");
+  }
+}
+
+std::string AudioNode::toString(ChannelInterpretation interpretation) {
+  switch (interpretation) {
+    case ChannelInterpretation::SPEAKERS:
+      return "speakers";
+    case ChannelInterpretation::DISCRETE:
+      return "discrete";
+    default:
+      throw std::invalid_argument("Unknown channel interpretation");
+  }
+}
+
+AudioBus* AudioNode::processAudio(AudioBus* outputBus, int framesToProcess) {
+  if (!isInitialized_) {
+    return outputBus;
+  }
+
+  std::size_t currentSampleFrame = context_->getCurrentSampleFrame();
+
+  // check if the node has already been processed for this rendering quantum
+  bool isAlreadyProcessed = currentSampleFrame == lastRenderedFrame_;
+
+  // Node can't use output bus if:
+  // - outputBus is not provided, which means that next node is doing a multi-node summing.
+  // - it has more than one input, which means that it has to sum all inputs using internal bus.
+  // - it has more than one output, so each output node can get the processed data without re-calculating the node.
+  bool canUseOutputBus = outputBus != 0 && inputNodes_.size() < 2 && outputNodes_.size() < 2;
+
+  if (isAlreadyProcessed) {
+    // If it was already processed in the rendering quantum, return it.
+    return audioBus_.get();
+  }
+
+  // Update the last rendered frame before processing node and its inputs.
+  lastRenderedFrame_ = currentSampleFrame;
+
+  AudioBus* processingBus = canUseOutputBus ? outputBus : audioBus_.get();
+
+  if (!canUseOutputBus) {
+    // Clear the bus before summing all connected nodes.
+    processingBus->zero();
+  }
+
+  if (inputNodes_.empty()) {
+    // If there are no connected inputs, process the node just to advance the audio params.
+    // The node will output silence anyway.
+    processNode(processingBus, framesToProcess);
+    return processingBus;
+  }
+
+  for (auto it = inputNodes_.begin(); it != inputNodes_.end(); ++it) {
+    if (!(*it)->isEnabled()) {
+      continue;
+    }
+
+    // Process first connected node, it can be directly connected to the processingBus,
+    // resulting in one less summing operation.
+    if (it == inputNodes_.begin()) {
+      AudioBus* inputBus = (*it)->processAudio(processingBus, framesToProcess);
+
+      if (inputBus != processingBus) {
+        processingBus->sum(inputBus);
+      }
+    } else {
+      // Enforce the summing to be done using the internal bus.
+      AudioBus* inputBus = (*it)->processAudio(0, framesToProcess);
+      if (inputBus) {
+        processingBus->sum(inputBus);
+      }
+    }
+  }
+
+  // Finally, process the node itself.
+  processNode(processingBus, framesToProcess);
+
+  return processingBus;
+}
+
+void AudioNode::cleanup() {
+  outputNodes_.clear();
+  inputNodes_.clear();
+}
+
+void AudioNode::onInputEnabled() {
+  numberOfEnabledInputNodes_ += 1;
+
+  if (!isEnabled()) {
+    enable();
+  }
+}
+
+void AudioNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
+
+  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+    disable();
+  }
+}
+
+void AudioNode::onInputConnected(AudioNode *node) {
+  inputNodes_.push_back(node);
+
+  if (node->isEnabled()) {
+    onInputEnabled();
+  }
+}
+
+void AudioNode::onInputDisconnected(AudioNode *node) {
+  auto position = std::find(inputNodes_.begin(), inputNodes_.end(), node);
+
+  if (position != inputNodes_.end()) {
+    inputNodes_.erase(position);
+  }
+
+
+  if (inputNodes_.size() > 0) {
+    return;
+  }
+
+  if (isEnabled()) {
+    node->onInputDisabled();
+  }
+
+  for (auto outputNode : outputNodes_) {
+    disconnectNode(outputNode);
+  }
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioNode.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "Constants.h"
+#include "ChannelCountMode.h"
+#include "ChannelInterpretation.h"
+
+namespace audioapi {
+
+class AudioBus;
+class BaseAudioContext;
+
+class AudioNode : public std::enable_shared_from_this<AudioNode> {
+ public:
+  explicit AudioNode(BaseAudioContext *context);
+  virtual ~AudioNode();
+  int getNumberOfInputs() const;
+  int getNumberOfOutputs() const;
+  int getChannelCount() const;
+  std::string getChannelCountMode() const;
+  std::string getChannelInterpretation() const;
+  void connect(const std::shared_ptr<AudioNode> &node);
+  void disconnect(const std::shared_ptr<AudioNode> &node);
+
+  bool isEnabled() const;
+  void enable();
+  void disable();
+
+ protected:
+  friend class AudioNodeManager;
+  friend class AudioDestinationNode;
+
+  BaseAudioContext *context_;
+  std::shared_ptr<AudioBus> audioBus_;
+
+  int channelCount_ = CHANNEL_COUNT;
+
+  int numberOfInputs_ = 1;
+  int numberOfOutputs_ = 1;
+  int numberOfEnabledInputNodes_ = 0;
+
+  bool isInitialized_ = false;
+  bool isEnabled_ = true;
+
+  std::size_t lastRenderedFrame_ { SIZE_MAX };
+
+  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
+  ChannelInterpretation channelInterpretation_ =
+      ChannelInterpretation::SPEAKERS;
+
+  std::vector<AudioNode*> inputNodes_ = {};
+  std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
+
+ private:
+  static std::string toString(ChannelCountMode mode);
+  static std::string toString(ChannelInterpretation interpretation);
+
+  void cleanup();
+  AudioBus* processAudio(AudioBus* outputBus, int framesToProcess);
+  virtual void processNode(AudioBus* processingBus, int framesToProcess) = 0;
+
+  void connectNode(const std::shared_ptr<AudioNode> &node);
+  void disconnectNode(const std::shared_ptr<AudioNode> &node);
+
+  void onInputEnabled();
+  void onInputDisabled();
+  void onInputConnected(AudioNode *node);
+  void onInputDisconnected(AudioNode *node);
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioNodeManager.cpp

@@ -0,0 +1,72 @@
+
+#include "Locker.h"
+#include "AudioNode.h"
+#include "AudioNodeManager.h"
+
+namespace audioapi {
+
+AudioNodeManager::AudioNodeManager() {}
+
+AudioNodeManager::~AudioNodeManager() {
+  audioNodesToConnect_.clear();
+  sourceNodes_.clear();
+}
+
+void AudioNodeManager::addPendingConnection(const std::shared_ptr<AudioNode> &from, const std::shared_ptr<AudioNode> &to, ConnectionType type) {
+  Locker lock(getGraphLock());
+
+  audioNodesToConnect_.push_back(std::make_tuple(from, to, type));
+}
+
+void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioNode> &node) {
+  Locker lock(getGraphLock());
+
+  sourceNodes_.push_back(node);
+}
+
+void AudioNodeManager::preProcessGraph() {
+    if (!Locker::tryLock(getGraphLock())) {
+    return;
+  }
+
+  settlePendingConnections();
+  removeFinishedSourceNodes();
+}
+
+std::mutex& AudioNodeManager::getGraphLock() {
+  return graphLock_;
+}
+
+void AudioNodeManager::settlePendingConnections() {
+  for (auto& connection : audioNodesToConnect_) {
+    std::shared_ptr<AudioNode> from = std::get<0>(connection);
+    std::shared_ptr<AudioNode> to = std::get<1>(connection);
+    ConnectionType type = std::get<2>(connection);
+
+    if (type == ConnectionType::CONNECT) {
+      from->connectNode(to);
+    } else {
+      from->disconnectNode(to);
+    }
+  }
+
+  audioNodesToConnect_.clear();
+}
+
+void AudioNodeManager::removeFinishedSourceNodes() {
+  for (auto it = sourceNodes_.begin(); it != sourceNodes_.end();) {
+    auto currentNode = it->get();
+    // Release the source node if use count is equal to 1 (this vector)
+    if (!currentNode->isEnabled() && it->use_count() == 1) {
+      for (auto& outputNode : currentNode->outputNodes_) {
+        currentNode->disconnectNode(outputNode);
+      }
+
+      it = sourceNodes_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioNodeManager.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <mutex>
+#include <tuple>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioNode;
+
+class AudioNodeManager {
+ public:
+  enum class ConnectionType { CONNECT, DISCONNECT };
+  AudioNodeManager();
+  ~AudioNodeManager();
+
+  void preProcessGraph();
+  void addPendingConnection(const std::shared_ptr<AudioNode> &from, const std::shared_ptr<AudioNode> &to, ConnectionType type);
+
+  void addSourceNode(const std::shared_ptr<AudioNode> &node);
+
+  std::mutex& getGraphLock();
+
+ private:
+  std::mutex graphLock_;
+
+  std::vector<std::shared_ptr<AudioNode>> sourceNodes_;
+  std::vector<std::tuple<std::shared_ptr<AudioNode>, std::shared_ptr<AudioNode>, ConnectionType>> audioNodesToConnect_;
+
+  void settlePendingConnections();
+  void removeFinishedSourceNodes();
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioParam.cpp

@@ -0,0 +1,133 @@
+#include "AudioParam.h"
+#include "BaseAudioContext.h"
+
+namespace audioapi {
+
+AudioParam::AudioParam(
+    BaseAudioContext *context,
+    float defaultValue,
+    float minValue,
+    float maxValue)
+    : value_(defaultValue),
+      defaultValue_(defaultValue),
+      minValue_(minValue),
+      maxValue_(maxValue),
+      context_(context),
+      changesQueue_() {
+  startTime_ = 0;
+  endTime_ = 0;
+  startValue_ = 0;
+  endValue_ = 0;
+  calculateValue_ = [this](double, double, float, float, double) {
+    return value_;
+  };
+}
+
+float AudioParam::getValue() const {
+  return value_;
+}
+
+float AudioParam::getDefaultValue() const {
+  return defaultValue_;
+}
+
+float AudioParam::getMinValue() const {
+  return minValue_;
+}
+
+float AudioParam::getMaxValue() const {
+  return maxValue_;
+}
+
+void AudioParam::setValue(float value) {
+  value_ = checkValue(value);
+}
+
+float AudioParam::getValueAtTime(double time) {
+  if (!changesQueue_.empty()) {
+    if (endTime_ < time) {
+      auto change = *changesQueue_.begin();
+      startTime_ = change.getStartTime();
+      endTime_ = change.getEndTime();
+      startValue_ = change.getStartValue();
+      endValue_ = change.getEndValue();
+      calculateValue_ = change.getCalculateValue();
+      changesQueue_.erase(changesQueue_.begin());
+    }
+  }
+
+  if (startTime_ <= time) {
+    value_ =
+        calculateValue_(startTime_, endTime_, startValue_, endValue_, time);
+  }
+
+  return value_;
+}
+
+void AudioParam::setValueAtTime(float value, double time) {
+  value = checkValue(value);
+  auto calculateValue = [](double, double, float, float endValue, double) {
+    return endValue;
+  };
+
+  auto paramChange = ParamChange(time, time, value, value, calculateValue);
+  changesQueue_.insert(paramChange);
+}
+
+void AudioParam::linearRampToValueAtTime(float value, double time) {
+  value = checkValue(value);
+  auto calculateValue = [](double startTime,
+                           double endTime,
+                           float startValue,
+                           float endValue,
+                           double time) {
+    return time >= endTime ? endValue
+                           : startValue +
+            (endValue - startValue) * (time - startTime) /
+                (endTime - startTime);
+  };
+
+  auto paramChange =
+      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
+  changesQueue_.emplace(paramChange);
+}
+
+void AudioParam::exponentialRampToValueAtTime(float value, double time) {
+  value = checkValue(value);
+  auto calculateValue = [](double startTime,
+                           double endTime,
+                           float startValue,
+                           float endValue,
+                           double time) {
+    return time >= endTime ? endValue
+                           : startValue *
+            pow(endValue / startValue,
+                (time - startTime) / (endTime - startTime));
+  };
+
+  auto paramChange =
+      ParamChange(getStartTime(), time, getStartValue(), value, calculateValue);
+  changesQueue_.emplace(paramChange);
+}
+
+float AudioParam::checkValue(float value) const {
+  return std::clamp(value, minValue_, maxValue_);
+}
+
+double AudioParam::getStartTime() {
+  if (changesQueue_.empty()) {
+    return context_->getCurrentTime();
+  }
+
+  return changesQueue_.rbegin()->getEndTime();
+}
+
+float AudioParam::getStartValue() {
+  if (changesQueue_.empty()) {
+    return this->value_;
+  }
+
+  return changesQueue_.rbegin()->getEndValue();
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioParam.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+#include <set>
+#include <vector>
+
+#include "ParamChange.h"
+
+namespace audioapi {
+
+class BaseAudioContext;
+
+class AudioParam {
+ public:
+  explicit AudioParam(
+      BaseAudioContext *context,
+      float defaultValue,
+      float minValue,
+      float maxValue);
+
+  [[nodiscard]] float getValue() const;
+  float getValueAtTime(double time);
+  void setValue(float value);
+  [[nodiscard]] float getDefaultValue() const;
+  [[nodiscard]] float getMinValue() const;
+  [[nodiscard]] float getMaxValue() const;
+  void setValueAtTime(float value, double startTime);
+  void linearRampToValueAtTime(float value, double endTime);
+  void exponentialRampToValueAtTime(float value, double endTime);
+
+ private:
+  float value_;
+  float defaultValue_;
+  float minValue_;
+  float maxValue_;
+  BaseAudioContext *context_;
+  std::set<ParamChange> changesQueue_;
+
+  double startTime_;
+  double endTime_;
+  float startValue_;
+  float endValue_;
+  std::function<float(double, double, float, float, double)> calculateValue_;
+
+  float checkValue(float value) const;
+  double getStartTime();
+  float getStartValue();
+};
+
+} // namespace audioapi