react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/core/AudioBuffer.cpp

@@ -0,0 +1,55 @@
+#include "AudioBus.h"
+#include "AudioArray.h"
+#include "AudioBuffer.h"
+
+namespace audioapi {
+
+AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate) {
+  bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
+}
+
+int AudioBuffer::getLength() const {
+  return bus_->getSize();
+}
+
+int AudioBuffer::getNumberOfChannels() const {
+  return bus_->getNumberOfChannels();
+}
+
+int AudioBuffer::getSampleRate() const {
+  return bus_->getSampleRate();
+}
+
+double AudioBuffer::getDuration() const {
+  return static_cast<double>(getLength()) / getSampleRate();
+}
+
+float* AudioBuffer::getChannelData(int channel) const {
+  return bus_->getChannel(channel)->getData();
+}
+
+void AudioBuffer::copyFromChannel(
+    float *destination,
+    int destinationLength,
+    int channelNumber,
+    int startInChannel) const {
+  memcpy(
+    destination,
+    bus_->getChannel(channelNumber)->getData() + startInChannel,
+    std::min(destinationLength, getLength() - startInChannel) * sizeof(float)
+  );
+}
+
+void AudioBuffer::copyToChannel(
+    const float *source,
+    int sourceLength,
+    int channelNumber,
+    int startInChannel) {
+  memcpy(
+    bus_->getChannel(channelNumber)->getData() + startInChannel,
+    source,
+    std::min(sourceLength, getLength() - startInChannel) * sizeof(float)
+  );
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioBuffer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+
+class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
+ public:
+  explicit AudioBuffer(int numberOfChannels, int length, int sampleRate);
+
+  [[nodiscard]] int getLength() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] double getDuration() const;
+
+  [[nodiscard]] int getNumberOfChannels() const;
+  [[nodiscard]] float *getChannelData(int channel) const;
+
+  void copyFromChannel(
+      float *destination,
+      int destinationLength,
+      int channelNumber,
+      int startInChannel) const;
+  void copyToChannel(
+      const float *source,
+      int sourceLength,
+      int channelNumber,
+      int startInChannel);
+
+ private:
+  std::shared_ptr<AudioBus> bus_;
+
+  friend class AudioBufferSourceNode;
+};
+
+} // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -0,0 +1,135 @@
+#include <algorithm>
+
+#include "AudioBus.h"
+#include "AudioArray.h"
+#include "BaseAudioContext.h"
+#include "AudioBufferSourceNode.h"
+
+namespace audioapi {
+
+AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
+    : AudioScheduledSourceNode(context), loop_(false), bufferIndex_(0) {
+  numberOfInputs_ = 0;
+  buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+  isInitialized_ = true;
+}
+
+bool AudioBufferSourceNode::getLoop() const {
+  return loop_;
+}
+
+std::shared_ptr<AudioBuffer> AudioBufferSourceNode::getBuffer() const {
+  return buffer_;
+}
+
+void AudioBufferSourceNode::setLoop(bool loop) {
+  loop_ = loop;
+}
+
+void AudioBufferSourceNode::setBuffer(
+    const std::shared_ptr<AudioBuffer> &buffer) {
+
+  if (!buffer) {
+    buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
+    return;
+  }
+
+  buffer_ = buffer;
+}
+
+// Note: AudioBus copy method will use memcpy if the source buffer and system processing bus have same channel count,
+// otherwise it will use the summing function taking care of up/down mixing.
+void AudioBufferSourceNode::processNode(AudioBus* processingBus, int framesToProcess) {
+  // No audio data to fill, zero the output and return.
+  if (!isPlaying() || !buffer_ || buffer_->getLength() == 0) {
+    processingBus->zero();
+    return;
+  }
+
+  // Easiest case, the buffer is the same length as the number of frames to process, just copy the data.
+  if (framesToProcess == buffer_->getLength()) {
+    processingBus->copy(buffer_->bus_.get());
+
+    if (!loop_) {
+      playbackState_ = PlaybackState::FINISHED;
+      disable();
+    }
+
+    return;
+  }
+
+  // The buffer is longer than the number of frames to process.
+  // We have to keep track of where we are in the buffer.
+  if (framesToProcess < buffer_->getLength()) {
+    int outputBusIndex = 0;
+    int framesToCopy = 0;
+
+    while (framesToProcess - outputBusIndex > 0) {
+      framesToCopy = std::min(framesToProcess - outputBusIndex, buffer_->getLength() - bufferIndex_);
+
+      processingBus->copy(buffer_->bus_.get(), bufferIndex_, outputBusIndex, framesToCopy);
+
+      bufferIndex_ += framesToCopy;
+      outputBusIndex += framesToCopy;
+
+      if (bufferIndex_ < buffer_->getLength()) {
+        continue;
+      }
+
+
+      bufferIndex_ %= buffer_->getLength();
+
+      if (!loop_) {
+      playbackState_ = PlaybackState::FINISHED;
+      disable();
+
+        if (framesToProcess - outputBusIndex > 0) {
+          processingBus->zero(outputBusIndex, framesToProcess - outputBusIndex);
+        }
+      }
+    }
+
+    return;
+  }
+
+  // processing bus is longer than the source buffer
+  if (!loop_) {
+    // If we don't loop the buffer, copy it once and zero the remaining processing bus frames.
+    processingBus->copy(buffer_->bus_.get());
+    processingBus->zero(buffer_->getLength(), framesToProcess - buffer_->getLength());
+
+    playbackState_ = PlaybackState::FINISHED;
+    disable();
+
+    return;
+  }
+
+  // If we loop the buffer, we need to loop the buffer framesToProcess / bufferSize times
+  // There might also be a remainder of frames to copy after the loop,
+  // which will also carry over some buffer frames to the next render quantum.
+  int processingBusPosition = 0;
+  int bufferSize = buffer_->getLength();
+  int remainingFrames = framesToProcess - framesToProcess / bufferSize;
+
+  // Do we have some frames left in the buffer from the previous render quantum,
+  // if yes copy them over and reset the buffer position.
+  if (bufferIndex_ > 0) {
+    processingBus->copy(buffer_->bus_.get(), 0, bufferIndex_);
+    processingBusPosition += bufferIndex_;
+    bufferIndex_ = 0;
+  }
+
+  // Copy the entire buffer n times to the processing bus.
+  while (processingBusPosition + bufferSize <= framesToProcess) {
+    processingBus->copy(buffer_->bus_.get());
+    processingBusPosition += bufferSize;
+  }
+
+  // Fill in the remaining frames from the processing buffer and update buffer index for next render quantum.
+  if (remainingFrames > 0) {
+    processingBus->copy(buffer_->bus_.get(), 0, processingBusPosition, remainingFrames);
+    bufferIndex_ = remainingFrames;
+  }
+}
+
+} // namespace audioapi

package/common/cpp/core/AudioBufferSourceNode.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioBuffer.h"
+#include "AudioScheduledSourceNode.h"
+
+namespace audioapi {
+
+class AudioBus;
+
+class AudioBufferSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit AudioBufferSourceNode(BaseAudioContext *context);
+
+  [[nodiscard]] bool getLoop() const;
+  [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const;
+  void setLoop(bool loop);
+  void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
+
+ protected:
+  void processNode(AudioBus* processingBus, int framesToProcess) override;
+
+ private:
+  bool loop_;
+  std::shared_ptr<AudioBuffer> buffer_;
+  int bufferIndex_;
+};
+
+} // namespace audioapi

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