react-native-audio-api 0.1.0 → 0.3.0-rc1

package/common/cpp/core/AudioContext.h

@@ -1,73 +1,16 @@
 #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
+#include "BaseAudioContext.h"
 
 namespace audioapi {
 
-class AudioContext {
+class AudioContext : public BaseAudioContext {
  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_;
+  void close();
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -1,35 +1,47 @@
 #include "AudioDestinationNode.h"
-#include "AudioContext.h"
+#include "AudioBus.h"
+#include "AudioNode.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
+#include "VectorMath.h"
 
 namespace audioapi {
 
-AudioDestinationNode::AudioDestinationNode(AudioContext *context)
-    : AudioNode(context) {
+AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
+    : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
   numberOfInputs_ = INT_MAX;
   channelCountMode_ = ChannelCountMode::EXPLICIT;
+  isInitialized_ = true;
 }
 
-void AudioDestinationNode::renderAudio(float *audioData, int32_t numFrames) {
-  processAudio(audioData, numFrames);
+std::size_t AudioDestinationNode::getCurrentSampleFrame() const {
+  return currentSampleFrame_;
 }
 
-bool AudioDestinationNode::processAudio(float *audioData, int32_t numFrames) {
-  int numSamples = numFrames * CHANNEL_COUNT;
+double AudioDestinationNode::getCurrentTime() const {
+  return static_cast<double>(currentSampleFrame_) / context_->getSampleRate();
+}
 
-  if (mixingBuffer == nullptr) {
-    mixingBuffer = std::make_unique<float[]>(numSamples);
+void AudioDestinationNode::renderAudio(
+    AudioBus *destinationBus,
+    int32_t numFrames) {
+  if (!numFrames || !destinationBus || !isInitialized_) {
+    return;
   }
 
-  memset(audioData, 0.0f, sizeof(float) * numSamples);
+  context_->getNodeManager()->preProcessGraph();
+  destinationBus->zero();
+
+  AudioBus *processedBus = processAudio(destinationBus, numFrames);
 
-  for (auto &node : inputNodes_) {
-    if (node && node->processAudio(mixingBuffer.get(), numFrames)) {
-      VectorMath::add(audioData, mixingBuffer.get(), audioData, numSamples);
-    }
+  if (processedBus && processedBus != destinationBus) {
+    destinationBus->copy(processedBus);
   }
 
-  return true;
+  destinationBus->normalize();
+
+  currentSampleFrame_ += numFrames;
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.h

@@ -5,20 +5,28 @@
 #include <vector>
 
 #include "AudioNode.h"
-#include "VectorMath.h"
 
 namespace audioapi {
 
+class AudioBus;
+class BaseAudioContext;
+
 class AudioDestinationNode : public AudioNode {
  public:
-  explicit AudioDestinationNode(AudioContext *context);
+  explicit AudioDestinationNode(BaseAudioContext *context);
+
+  void renderAudio(AudioBus *audioData, int32_t numFrames);
 
-  void renderAudio(float *audioData, int32_t numFrames);
+  std::size_t getCurrentSampleFrame() const;
+  double getCurrentTime() const;
 
  protected:
-  bool processAudio(float *audioData, int32_t numFrames) override;
+  // DestinationNode is triggered by AudioContext using renderAudio
+  // processNode function is not necessary and is never called.
+  void processNode(AudioBus *, int) final{};
 
  private:
-  std::unique_ptr<float[]> mixingBuffer;
+  std::size_t currentSampleFrame_;
 };
+
 } // namespace audioapi

package/common/cpp/core/AudioNode.cpp

@@ -1,11 +1,21 @@
+#include <memory>
+
+#include "AudioBus.h"
 #include "AudioNode.h"
-#include "AudioContext.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.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,23 +40,142 @@ 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() {
@@ -54,15 +183,48 @@ void AudioNode::cleanup() {
   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();
   }
+}
 
-  return isPlaying;
+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

@@ -3,17 +3,19 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "Constants.h"
 
-// channelCount always equal to 2
+#include "ChannelCountMode.h"
+#include "ChannelInterpretation.h"
+#include "Constants.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,75 @@
+
+#include "AudioNodeManager.h"
+#include "AudioNode.h"
+#include "Locker.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,42 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <tuple>
+#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() {