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

package/common/cpp/core/AudioBus.cpp

@@ -1,12 +1,13 @@
 #include <algorithm>
 
+#include "AudioArray.h"
 #include "AudioBus.h"
+#include "BaseAudioContext.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:
+// 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);
@@ -17,12 +18,14 @@ namespace audioapi {
  * Public interfaces - memory management
  */
 AudioBus::AudioBus(int sampleRate, int size)
-    : sampleRate_(sampleRate), size_(size), numberOfChannels_(CHANNEL_COUNT) {
+    : numberOfChannels_(CHANNEL_COUNT), sampleRate_(sampleRate), size_(size) {
   createChannels();
 }
 
 AudioBus::AudioBus(int sampleRate, int size, int numberOfChannels)
-    : sampleRate_(sampleRate), size_(size), numberOfChannels_(numberOfChannels) {
+    : numberOfChannels_(numberOfChannels),
+      sampleRate_(sampleRate),
+      size_(size) {
   createChannels();
 }
 
@@ -46,56 +49,77 @@ int AudioBus::getSize() const {
   return size_;
 }
 
-AudioArray* AudioBus::getChannel(int index) const {
+AudioArray *AudioBus::getChannel(int index) const {
   return channels_[index].get();
 }
 
-AudioArray* AudioBus::getChannelByType(int channelType) const {
+AudioArray *AudioBus::getChannelByType(int channelType) const {
   switch (getNumberOfChannels()) {
     case 1: // mono
       if (channelType == ChannelMono || channelType == ChannelLeft) {
         return getChannel(0);
       }
-      return 0;
+      return nullptr;
 
     case 2: // stereo
       switch (channelType) {
-        case ChannelLeft: return getChannel(0);
-        case ChannelRight: return getChannel(1);
-        default: return 0;
+        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 0;
+        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 0;
+        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 0;
+        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 0;
+      return nullptr;
   }
 }
 
@@ -125,16 +149,16 @@ void AudioBus::normalize() {
 }
 
 void AudioBus::scale(float value) {
-  for (auto it = channels_.begin(); it != channels_.end(); ++it) {
-    it->get()->scale(value);
+  for (auto &channel : channels_) {
+    channel->scale(value);
   }
 }
 
 float AudioBus::maxAbsValue() const {
   float maxAbsValue = 1.0f;
 
-  for (auto it = channels_.begin(); it != channels_.end(); ++it) {
-    float channelMaxAbsValue = it->get()->getMaxAbsValue();
+  for (const auto &channel : channels_) {
+    float channelMaxAbsValue = channel->getMaxAbsValue();
     maxAbsValue = std::max(maxAbsValue, channelMaxAbsValue);
   }
 
@@ -149,7 +173,11 @@ 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) {
+void AudioBus::sum(
+    const AudioBus *source,
+    int sourceStart,
+    int destinationStart,
+    int length) {
   if (source == this) {
     return;
   }
@@ -157,8 +185,9 @@ void AudioBus::sum(const AudioBus *source, int sourceStart, int destinationStart
   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.
+  // 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;
@@ -172,7 +201,8 @@ void AudioBus::sum(const AudioBus *source, int sourceStart, int destinationStart
 
   // 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);
+    getChannel(i)->sum(
+        source->getChannel(i), sourceStart, destinationStart, length);
   }
 }
 
@@ -184,14 +214,19 @@ 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) {
+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);
+      getChannel(i)->copy(
+          source->getChannel(i), sourceStart, destinationStart, length);
     }
 
     return;
@@ -218,108 +253,212 @@ void AudioBus::createChannels() {
  * Internal tooling - channel summing
  */
 
-void AudioBus::discreteSum(const AudioBus *source, int sourceStart, int destinationStart, int length) {
-  int numberOfChannels = std::min(getNumberOfChannels(), source->getNumberOfChannels());
+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.
+  // 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);
+    getChannel(i)->sum(
+        source->getChannel(i), sourceStart, destinationStart, length);
   }
 }
 
-void AudioBus::sumByUpMixing(const AudioBus *source, int sourceStart, int destinationStart, int 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);
+  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);
+    AudioArray *sourceChannel = source->getChannel(0);
 
-    getChannelByType(ChannelCenter)->sum(sourceChannel, sourceStart, destinationStart, length);
+    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);
+  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);
+    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) {
+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);
+    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)
+  // 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);
+    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)
+  // 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);
+    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;
   }
 
@@ -329,25 +468,47 @@ void AudioBus::sumByDownMixing(const AudioBus *source, int sourceStart, int dest
   // 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);
+    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;
   }
 

package/common/cpp/core/AudioBus.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <vector>
-#include <algorithm>
 
 namespace audioapi {
 
@@ -29,23 +29,31 @@ class AudioBus {
   [[nodiscard]] int getNumberOfChannels() const;
   [[nodiscard]] int getSampleRate() const;
   [[nodiscard]] int getSize() const;
-  AudioArray* getChannel(int index) const;
-  AudioArray* getChannelByType(int channelType) const;
+  [[nodiscard]] AudioArray *getChannel(int index) const;
+  [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
   void normalize();
   void scale(float value);
-  float maxAbsValue() const;
+  [[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 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);
+  void copy(
+      const AudioBus *source,
+      int sourceStart,
+      int destinationStart,
+      int length);
 
  private:
   std::vector<std::shared_ptr<AudioArray>> channels_;
@@ -55,9 +63,21 @@ class AudioBus {
   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);
+  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

@@ -6,19 +6,15 @@
 
 #include "AudioContext.h"
 
-
 namespace audioapi {
 
-AudioContext::AudioContext() : BaseAudioContext() {}
+AudioContext::AudioContext() : BaseAudioContext() {
+  audioPlayer_->start();
+}
 
 void AudioContext::close() {
   state_ = ContextState::CLOSED;
-
-  if (audioPlayer_) {
-    audioPlayer_->stop();
-  }
-
-  audioPlayer_.reset();
-  destination_.reset();
+  audioPlayer_->stop();
 }
+
 } // namespace audioapi