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

package/common/cpp/core/AudioBus.cpp

@@ -0,0 +1,518 @@
+#include <algorithm>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+#include "BaseAudioContext.h"
+#include "Constants.h"
+#include "VectorMath.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)
+    : numberOfChannels_(CHANNEL_COUNT), sampleRate_(sampleRate), size_(size) {
+  createChannels();
+}
+
+AudioBus::AudioBus(int sampleRate, int size, int numberOfChannels)
+    : numberOfChannels_(numberOfChannels),
+      sampleRate_(sampleRate),
+      size_(size) {
+  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 nullptr;
+
+    case 2: // stereo
+      switch (channelType) {
+        case ChannelLeft:
+          return getChannel(0);
+        case ChannelRight:
+          return getChannel(1);
+        default:
+          return nullptr;
+      }
+
+    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 nullptr;
+      }
+
+    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 nullptr;
+      }
+
+    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 nullptr;
+      }
+    default:
+      return nullptr;
+  }
+}
+
+/**
+ * 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 &channel : channels_) {
+    channel->scale(value);
+  }
+}
+
+float AudioBus::maxAbsValue() const {
+  float maxAbsValue = 1.0f;
+
+  for (const auto &channel : channels_) {
+    float channelMaxAbsValue = channel->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) const {
+  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,83 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+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;
+  [[nodiscard]] AudioArray *getChannel(int index) const;
+  [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
+
+  void normalize();
+  void scale(float value);
+  [[nodiscard]] 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) const;
+  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,90 +1,20 @@
-#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();
+#include "AudioContext.h"
 
-  auto now = std::chrono::high_resolution_clock ::now();
-  contextStartTime_ =
-      static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                              now.time_since_epoch())
-                              .count());
+namespace audioapi {
 
+AudioContext::AudioContext() : BaseAudioContext() {
   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);
+  state_ = ContextState::CLOSED;
+  audioPlayer_->stop();
 }
 
-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