react-native-audio-api 0.1.0 → 0.2.0

package/common/cpp/core/AudioNode.cpp

@@ -1,11 +1,18 @@
+#include <memory>
+
+#include "AudioBus.h"
 #include "AudioNode.h"
-#include "AudioContext.h"
+#include "BaseAudioContext.h"
+#include "AudioNodeManager.h"
 
 namespace audioapi {
 
-AudioNode::AudioNode(AudioContext *context) : context_(context) {}
+AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
+  audioBus_ = std::make_shared<AudioBus>(context->getSampleRate(), context->getBufferSizeInFrames(), channelCount_);
+}
 
 AudioNode::~AudioNode() {
+  isInitialized_ = false;
   cleanup();
 }
 
@@ -30,39 +37,186 @@ std::string AudioNode::getChannelInterpretation() const {
 }
 
 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());
-  }
+  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) {
-  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());
+  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();
 }
 
-bool AudioNode::processAudio(float *audioData, int32_t numFrames) {
-  bool isPlaying = false;
-  for (auto &node : inputNodes_) {
-    if (node->processAudio(audioData, numFrames)) {
-      isPlaying = true;
-    }
+void AudioNode::onInputEnabled() {
+  numberOfEnabledInputNodes_ += 1;
+
+  if (!isEnabled()) {
+    enable();
   }
+}
+
+void AudioNode::onInputDisabled() {
+  numberOfEnabledInputNodes_ -= 1;
 
-  return isPlaying;
+  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

@@ -3,17 +3,19 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "Constants.h"
 
-// channelCount always equal to 2
+#include "Constants.h"
+#include "ChannelCountMode.h"
+#include "ChannelInterpretation.h"
 
 namespace audioapi {
 
-class AudioContext;
+class AudioBus;
+class BaseAudioContext;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(AudioContext *context);
+  explicit AudioNode(BaseAudioContext *context);
   virtual ~AudioNode();
   int getNumberOfInputs() const;
   int getNumberOfOutputs() const;
@@ -23,52 +25,50 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void connect(const std::shared_ptr<AudioNode> &node);
   void disconnect(const std::shared_ptr<AudioNode> &node);
 
-  // Change public to protected
-  virtual bool processAudio(float *audioData, int32_t numFrames);
+  bool isEnabled() const;
+  void enable();
+  void disable();
 
  protected:
-  enum class ChannelCountMode { MAX, CLAMPED_MAX, EXPLICIT };
-
-  static std::string 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");
-    }
-  }
-
-  enum class ChannelInterpretation { SPEAKERS, DISCRETE };
-
-  static std::string toString(ChannelInterpretation interpretation) {
-    switch (interpretation) {
-      case ChannelInterpretation::SPEAKERS:
-        return "speakers";
-      case ChannelInterpretation::DISCRETE:
-        return "discrete";
-      default:
-        throw std::invalid_argument("Unknown channel interpretation");
-    }
-  }
+  friend class AudioNodeManager;
+  friend class AudioDestinationNode;
+
+  BaseAudioContext *context_;
+  std::shared_ptr<AudioBus> audioBus_;
+
+  int channelCount_ = CHANNEL_COUNT;
 
- protected:
-  AudioContext *context_;
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
-  int channelCount_ = CHANNEL_COUNT;
+  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<std::shared_ptr<AudioNode>> inputNodes_ = {};
+  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

@@ -1,10 +1,10 @@
 #include "AudioParam.h"
-#include "AudioContext.h"
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
 AudioParam::AudioParam(
-    AudioContext *context,
+    BaseAudioContext *context,
     float defaultValue,
     float minValue,
     float maxValue)
@@ -40,8 +40,7 @@ float AudioParam::getMaxValue() const {
 }
 
 void AudioParam::setValue(float value) {
-  checkValue(value);
-  value_ = value;
+  value_ = checkValue(value);
 }
 
 float AudioParam::getValueAtTime(double time) {
@@ -66,7 +65,7 @@ float AudioParam::getValueAtTime(double time) {
 }
 
 void AudioParam::setValueAtTime(float value, double time) {
-  checkValue(value);
+  value = checkValue(value);
   auto calculateValue = [](double, double, float, float endValue, double) {
     return endValue;
   };
@@ -76,7 +75,7 @@ void AudioParam::setValueAtTime(float value, double time) {
 }
 
 void AudioParam::linearRampToValueAtTime(float value, double time) {
-  checkValue(value);
+  value = checkValue(value);
   auto calculateValue = [](double startTime,
                            double endTime,
                            float startValue,
@@ -94,7 +93,7 @@ void AudioParam::linearRampToValueAtTime(float value, double time) {
 }
 
 void AudioParam::exponentialRampToValueAtTime(float value, double time) {
-  checkValue(value);
+  value = checkValue(value);
   auto calculateValue = [](double startTime,
                            double endTime,
                            float startValue,
@@ -111,10 +110,8 @@ void AudioParam::exponentialRampToValueAtTime(float value, double time) {
   changesQueue_.emplace(paramChange);
 }
 
-void AudioParam::checkValue(float value) const {
-  if (value < minValue_ || value > maxValue_) {
-    throw std::invalid_argument("Value out of range");
-  }
+float AudioParam::checkValue(float value) const {
+  return std::clamp(value, minValue_, maxValue_);
 }
 
 double AudioParam::getStartTime() {

package/common/cpp/core/AudioParam.h

@@ -8,22 +8,22 @@
 
 namespace audioapi {
 
-class AudioContext;
+class BaseAudioContext;
 
 class AudioParam {
  public:
   explicit AudioParam(
-      AudioContext *context,
+      BaseAudioContext *context,
       float defaultValue,
       float minValue,
       float maxValue);
 
-  float getValue() const;
+  [[nodiscard]] float getValue() const;
   float getValueAtTime(double time);
   void setValue(float value);
-  float getDefaultValue() const;
-  float getMinValue() const;
-  float getMaxValue() const;
+  [[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);
@@ -33,7 +33,7 @@ class AudioParam {
   float defaultValue_;
   float minValue_;
   float maxValue_;
-  AudioContext *context_;
+  BaseAudioContext *context_;
   std::set<ParamChange> changesQueue_;
 
   double startTime_;
@@ -42,7 +42,7 @@ class AudioParam {
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
 
-  void checkValue(float value) const;
+  float checkValue(float value) const;
   double getStartTime();
   float getStartValue();
 };

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -1,14 +1,19 @@
+#include "BaseAudioContext.h"
+#include "AudioNodeManager.h"
 #include "AudioScheduledSourceNode.h"
-#include "AudioContext.h"
 
 namespace audioapi {
 
-AudioScheduledSourceNode::AudioScheduledSourceNode(AudioContext *context)
-    : AudioNode(context), isPlaying_(false) {
+AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
+    : AudioNode(context), playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  isInitialized_ = true;
 }
 
 void AudioScheduledSourceNode::start(double time) {
+  context_->getNodeManager()->addSourceNode(shared_from_this());
+
+  playbackState_ = PlaybackState::SCHEDULED;
   waitAndExecute(time, [this](double time) { startPlayback(); });
 }
 
@@ -16,12 +21,21 @@ void AudioScheduledSourceNode::stop(double time) {
   waitAndExecute(time, [this](double time) { stopPlayback(); });
 }
 
+bool AudioScheduledSourceNode::isPlaying() {
+  return playbackState_ == PlaybackState::PLAYING;
+}
+
+bool AudioScheduledSourceNode::isFinished() {
+  return playbackState_ == PlaybackState::FINISHED;
+}
+
 void AudioScheduledSourceNode::startPlayback() {
-  isPlaying_ = true;
+  playbackState_ = PlaybackState::PLAYING;
 }
 
 void AudioScheduledSourceNode::stopPlayback() {
-  isPlaying_ = false;
+  playbackState_ = PlaybackState::FINISHED;
+  disable();
 }
 
 void AudioScheduledSourceNode::waitAndExecute(

package/common/cpp/core/AudioScheduledSourceNode.h

@@ -13,13 +13,17 @@ namespace audioapi {
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
-  explicit AudioScheduledSourceNode(AudioContext *context);
+  enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, FINISHED };
+  explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
   void start(double time);
   void stop(double time);
 
+  bool isFinished();
+  bool isPlaying();
+
  protected:
-  std::atomic<bool> isPlaying_;
+  std::atomic<PlaybackState> playbackState_;
 
  private:
   void startPlayback();