react-native-audio-api 0.1.0 → 0.2.0

package/common/cpp/core/AudioBus.cpp

@@ -0,0 +1,357 @@
+#include <algorithm>
+
+#include "AudioBus.h"
+#include "Constants.h"
+#include "AudioArray.h"
+#include "VectorMath.h"
+#include "BaseAudioContext.h"
+
+// Implementation of channel summing/mixing is based on the WebKit approach, source:
+// https://github.com/WebKit/WebKit/blob/main/Source/WebCore/platform/audio/AudioBus.cpp
+
+const float SQRT_HALF = sqrtf(0.5f);
+
+namespace audioapi {
+
+/**
+ * Public interfaces - memory management
+ */
+AudioBus::AudioBus(int sampleRate, int size)
+    : sampleRate_(sampleRate), size_(size), numberOfChannels_(CHANNEL_COUNT) {
+  createChannels();
+}
+
+AudioBus::AudioBus(int sampleRate, int size, int numberOfChannels)
+    : sampleRate_(sampleRate), size_(size), numberOfChannels_(numberOfChannels) {
+  createChannels();
+}
+
+AudioBus::~AudioBus() {
+  channels_.clear();
+}
+
+/**
+ * Public interfaces - getters
+ */
+
+int AudioBus::getNumberOfChannels() const {
+  return numberOfChannels_;
+}
+
+int AudioBus::getSampleRate() const {
+  return sampleRate_;
+}
+
+int AudioBus::getSize() const {
+  return size_;
+}
+
+AudioArray* AudioBus::getChannel(int index) const {
+  return channels_[index].get();
+}
+
+AudioArray* AudioBus::getChannelByType(int channelType) const {
+  switch (getNumberOfChannels()) {
+    case 1: // mono
+      if (channelType == ChannelMono || channelType == ChannelLeft) {
+        return getChannel(0);
+      }
+      return 0;
+
+    case 2: // stereo
+      switch (channelType) {
+        case ChannelLeft: return getChannel(0);
+        case ChannelRight: return getChannel(1);
+        default: return 0;
+      }
+
+    case 4: // quad
+      switch (channelType) {
+        case ChannelLeft: return getChannel(0);
+        case ChannelRight: return getChannel(1);
+        case ChannelSurroundLeft: return getChannel(2);
+        case ChannelSurroundRight: return getChannel(3);
+        default: return 0;
+      }
+
+    case 5: // 5.0
+      switch (channelType) {
+        case ChannelLeft: return getChannel(0);
+        case ChannelRight: return getChannel(1);
+        case ChannelCenter: return getChannel(2);
+        case ChannelSurroundLeft: return getChannel(3);
+        case ChannelSurroundRight: return getChannel(4);
+        default: return 0;
+      }
+
+    case 6: // 5.1
+      switch (channelType) {
+        case ChannelLeft: return getChannel(0);
+        case ChannelRight: return getChannel(1);
+        case ChannelCenter: return getChannel(2);
+        case ChannelLFE: return getChannel(3);
+        case ChannelSurroundLeft: return getChannel(4);
+        case ChannelSurroundRight: return getChannel(5);
+        default: return 0;
+      }
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Public interfaces - audio processing and setters
+ */
+
+void AudioBus::zero() {
+  zero(0, getSize());
+}
+
+void AudioBus::zero(int start, int length) {
+  for (auto it = channels_.begin(); it != channels_.end(); it += 1) {
+    it->get()->zero(start, length);
+  }
+}
+
+void AudioBus::normalize() {
+  float maxAbsValue = this->maxAbsValue();
+
+  if (maxAbsValue == 0.0f || maxAbsValue == 1.0f) {
+    return;
+  }
+
+  float scale = 1.0f / maxAbsValue;
+  this->scale(scale);
+}
+
+void AudioBus::scale(float value) {
+  for (auto it = channels_.begin(); it != channels_.end(); ++it) {
+    it->get()->scale(value);
+  }
+}
+
+float AudioBus::maxAbsValue() const {
+  float maxAbsValue = 1.0f;
+
+  for (auto it = channels_.begin(); it != channels_.end(); ++it) {
+    float channelMaxAbsValue = it->get()->getMaxAbsValue();
+    maxAbsValue = std::max(maxAbsValue, channelMaxAbsValue);
+  }
+
+  return maxAbsValue;
+}
+
+void AudioBus::sum(const AudioBus *source) {
+  sum(source, 0, 0, getSize());
+}
+
+void AudioBus::sum(const AudioBus *source, int start, int length) {
+  sum(source, start, start, length);
+}
+
+void AudioBus::sum(const AudioBus *source, int sourceStart, int destinationStart, int length) {
+  if (source == this) {
+    return;
+  }
+
+  int numberOfSourceChannels = source->getNumberOfChannels();
+  int numberOfChannels = getNumberOfChannels();
+
+  // TODO: consider adding ability to enforce discrete summing (if/when it will be useful).
+  // Source channel count is smaller than current bus, we need to up-mix.
+  if (numberOfSourceChannels < numberOfChannels) {
+    sumByUpMixing(source, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Source channel count is larger than current bus, we need to down-mix.
+  if (numberOfSourceChannels > numberOfChannels) {
+    sumByDownMixing(source, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Source and destination channel counts are the same. Just sum the channels.
+  for (int i = 0; i < numberOfChannels_; i += 1) {
+    getChannel(i)->sum(source->getChannel(i), sourceStart, destinationStart, length);
+  }
+}
+
+void AudioBus::copy(const AudioBus *source) {
+  copy(source, 0, 0, getSize());
+}
+
+void AudioBus::copy(const AudioBus *source, int start, int length) {
+  copy(source, start, start, length);
+}
+
+void AudioBus::copy(const AudioBus *source, int sourceStart, int destinationStart, int length) {
+  if (source == this) {
+    return;
+  }
+
+  if (source->getNumberOfChannels() == getNumberOfChannels()) {
+    for (int i = 0; i < getNumberOfChannels(); i += 1) {
+      getChannel(i)->copy(source->getChannel(i), sourceStart, destinationStart, length);
+    }
+
+    return;
+  }
+
+  // zero + sum is equivalent to copy, but takes care of up/down-mixing.
+  zero(destinationStart, length);
+  sum(source, sourceStart, destinationStart, length);
+}
+
+/**
+ * Internal tooling - channel initialization
+ */
+
+void AudioBus::createChannels() {
+  channels_ = std::vector<std::shared_ptr<AudioArray>>(numberOfChannels_);
+
+  for (int i = 0; i < numberOfChannels_; i += 1) {
+    channels_[i] = std::make_shared<AudioArray>(size_);
+  }
+}
+
+/**
+ * Internal tooling - channel summing
+ */
+
+void AudioBus::discreteSum(const AudioBus *source, int sourceStart, int destinationStart, int length) {
+  int numberOfChannels = std::min(getNumberOfChannels(), source->getNumberOfChannels());
+
+  // In case of source > destination, we "down-mix" and drop the extra channels.
+  // In case of source < destination, we "up-mix" as many channels as we have, leaving the remaining channels untouched.
+  for (int i = 0; i < numberOfChannels; i++) {
+    getChannel(i)->sum(source->getChannel(i), sourceStart, destinationStart, length);
+  }
+}
+
+void AudioBus::sumByUpMixing(const AudioBus *source, int sourceStart, int destinationStart, int length) {
+  int numberOfSourceChannels = source->getNumberOfChannels();
+  int numberOfChannels = getNumberOfChannels();
+
+  // Mono to stereo (1 -> 2, 4)
+  if (numberOfSourceChannels == 1 && (numberOfChannels == 2 || numberOfChannels == 4)) {
+    AudioArray* sourceChannel = source->getChannelByType(ChannelMono);
+
+    getChannelByType(ChannelLeft)->sum(sourceChannel, sourceStart, destinationStart, length);
+    getChannelByType(ChannelRight)->sum(sourceChannel, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Mono to 5.1 (1 -> 6)
+  if (numberOfSourceChannels == 1 && numberOfChannels == 6) {
+    AudioArray* sourceChannel = source->getChannel(0);
+
+    getChannelByType(ChannelCenter)->sum(sourceChannel, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Stereo 2 to stereo 4 or 5.1 (2 -> 4, 6)
+  if (numberOfSourceChannels == 2 && (numberOfChannels == 4 || numberOfChannels == 6)) {
+    getChannelByType(ChannelLeft)->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
+    getChannelByType(ChannelRight)->sum(source->getChannelByType(ChannelRight), sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Stereo 4 to 5.1 (4 -> 6)
+  if (numberOfSourceChannels == 4 && numberOfChannels == 6) {
+    getChannelByType(ChannelLeft)->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
+    getChannelByType(ChannelRight)->sum(source->getChannelByType(ChannelRight), sourceStart, destinationStart, length);
+    getChannelByType(ChannelSurroundLeft)->sum(source->getChannelByType(ChannelSurroundLeft), sourceStart, destinationStart, length);
+    getChannelByType(ChannelSurroundRight)->sum(source->getChannelByType(ChannelSurroundRight), sourceStart, destinationStart, length);
+    return;
+  }
+
+  discreteSum(source, sourceStart, destinationStart, length);
+}
+
+void AudioBus::sumByDownMixing(const AudioBus *source, int sourceStart, int destinationStart, int length) {
+  int numberOfSourceChannels = source->getNumberOfChannels();
+  int numberOfChannels = getNumberOfChannels();
+
+  // Stereo to mono (2 -> 1): output += 0.5 * (input.left + input.right).
+  if (numberOfSourceChannels == 2 && numberOfChannels == 1) {
+    float* sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float* sourceRight = source->getChannelByType(ChannelRight)->getData();
+
+    float* destinationData = getChannelByType(ChannelMono)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(sourceLeft + sourceStart, 0.5f, destinationData + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceRight + sourceStart, 0.5f, destinationData + destinationStart, length);
+    return;
+  }
+
+  // Stereo 4 to mono: output += 0.25 * (input.left + input.right + input.surroundLeft + input.surroundRight)
+  if (numberOfSourceChannels == 4 && numberOfChannels == 1) {
+    float* sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float* sourceRight = source->getChannelByType(ChannelRight)->getData();
+    float* sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float* sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
+
+    float* destinationData = getChannelByType(ChannelMono)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(sourceLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceRight + sourceStart, 0.25f, destinationData + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceSurroundLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceSurroundRight + sourceStart, 0.25f, destinationData + destinationStart, length);
+    return;
+  }
+
+  // 5.1 to stereo:
+  // output.left += input.left + sqrt(1/2) * (input.center + input.surroundLeft)
+  // output.right += input.right + sqrt(1/2) * (input.center + input.surroundRight)
+  if (numberOfSourceChannels == 6 && numberOfChannels == 2) {
+    float* sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float* sourceRight = source->getChannelByType(ChannelRight)->getData();
+    float* sourceCenter = source->getChannelByType(ChannelCenter)->getData();
+    float* sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float* sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
+
+    float* destinationLeft = getChannelByType(ChannelLeft)->getData();
+    float* destinationRight = getChannelByType(ChannelRight)->getData();
+
+    VectorMath::add(sourceLeft + sourceStart, destinationLeft + destinationStart, destinationLeft + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceCenter + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceSurroundLeft + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
+
+    VectorMath::add(sourceRight + sourceStart, destinationRight + destinationStart, destinationRight + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceCenter + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceSurroundRight + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
+    return;
+  }
+
+  // 5.1 to stereo 4:
+  // output.left += input.left + sqrt(1/2) * input.center
+  // output.right += input.right + sqrt(1/2) * input.center
+  // output.surroundLeft += input.surroundLeft
+  // output.surroundRight += input.surroundRight
+  if (numberOfSourceChannels == 6 && numberOfChannels == 4) {
+    float* sourceLeft = source->getChannelByType(ChannelLeft)->getData();
+    float* sourceRight = source->getChannelByType(ChannelRight)->getData();
+    float* sourceCenter = source->getChannelByType(ChannelCenter)->getData();
+    float* sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float* sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
+
+    float* destinationLeft = getChannelByType(ChannelLeft)->getData();
+    float* destinationRight = getChannelByType(ChannelRight)->getData();
+    float* destinationSurroundLeft = getChannelByType(ChannelSurroundLeft)->getData();
+    float* destinationSurroundRight = getChannelByType(ChannelSurroundRight)->getData();
+
+    VectorMath::add(sourceLeft + sourceStart, destinationLeft + destinationStart, destinationLeft + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceCenter, SQRT_HALF, destinationLeft + destinationStart, length);
+
+    VectorMath::add(sourceRight + sourceStart, destinationRight + destinationStart, destinationRight + destinationStart, length);
+    VectorMath::multiplyByScalarThenAddToOutput(sourceCenter, SQRT_HALF, destinationRight + destinationStart, length);
+
+    VectorMath::add(sourceSurroundLeft + sourceStart, destinationSurroundLeft + destinationStart, destinationSurroundLeft + destinationStart, length);
+    VectorMath::add(sourceSurroundRight + sourceStart, destinationSurroundRight + destinationStart, destinationSurroundRight + destinationStart, length);
+    return;
+  }
+
+  discreteSum(source, sourceStart, destinationStart, length);
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioBus.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <algorithm>
+
+namespace audioapi {
+
+class BaseAudioContext;
+class AudioArray;
+
+class AudioBus {
+ public:
+  enum {
+    ChannelMono = 0,
+    ChannelLeft = 0,
+    ChannelRight = 1,
+    ChannelCenter = 2,
+    ChannelLFE = 3,
+    ChannelSurroundLeft = 4,
+    ChannelSurroundRight = 5,
+  };
+
+  explicit AudioBus(int sampleRate, int size);
+  explicit AudioBus(int sampleRate, int size, int numberOfChannels);
+
+  ~AudioBus();
+
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] int getSize() const;
+  AudioArray* getChannel(int index) const;
+  AudioArray* getChannelByType(int channelType) const;
+
+  void normalize();
+  void scale(float value);
+  float maxAbsValue() const;
+
+  void zero();
+  void zero(int start, int length);
+
+  void sum(const AudioBus *source);
+  void sum(const AudioBus *source, int start, int length);
+  void sum(const AudioBus *source, int sourceStart, int destinationStart, int length);
+
+  void copy(const AudioBus *source);
+  void copy(const AudioBus *source, int start, int length);
+  void copy(const AudioBus *source, int sourceStart, int destinationStart, int length);
+
+ private:
+  std::vector<std::shared_ptr<AudioArray>> channels_;
+
+  int numberOfChannels_;
+  int sampleRate_;
+  int size_;
+
+  void createChannels();
+  void discreteSum(const AudioBus *source, int sourceStart, int destinationStart, int length);
+  void sumByUpMixing(const AudioBus *source, int sourceStart, int destinationStart, int length);
+  void sumByDownMixing(const AudioBus *source, int sourceStart, int destinationStart, int length);
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioContext.cpp

@@ -1,45 +1,18 @@
-#include "AudioContext.h"
-
-namespace audioapi {
-
-AudioContext::AudioContext() {
 #ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+#include "AudioPlayer.h"
 #else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
+#include "IOSAudioPlayer.h"
 #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());
+#include "AudioContext.h"
 
-  audioPlayer_->start();
-}
 
-std::string AudioContext::getState() {
-  return AudioContext::toString(state_);
-}
-
-int AudioContext::getSampleRate() const {
-  return sampleRate_;
-}
+namespace audioapi {
 
-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;
-}
+AudioContext::AudioContext() : BaseAudioContext() {}
 
 void AudioContext::close() {
-  state_ = State::CLOSED;
+  state_ = ContextState::CLOSED;
 
   if (audioPlayer_) {
     audioPlayer_->stop();
@@ -48,43 +21,4 @@ void AudioContext::close() {
   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

@@ -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,45 @@
+#include "AudioBus.h"
+#include "AudioNode.h"
+#include "VectorMath.h"
+#include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
 #include "AudioDestinationNode.h"
-#include "AudioContext.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();
+}
+
+void AudioDestinationNode::renderAudio(AudioBus *destinationBus, int32_t numFrames) {
+  context_->getNodeManager()->preProcessGraph();
+  destinationBus->zero();
 
-  if (mixingBuffer == nullptr) {
-    mixingBuffer = std::make_unique<float[]>(numSamples);
+  if (!numFrames) {
+    return;
   }
 
-  memset(audioData, 0.0f, sizeof(float) * numSamples);
+  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

@@ -1,24 +1,32 @@
 #pragma once
 
-#include <algorithm>
-#include <memory>
 #include <vector>
+#include <memory>
+#include <algorithm>
 
 #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