react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -2,6 +2,10 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
 
 // Implementation of channel summing/mixing is based on the WebKit approach,
 // source:
@@ -16,9 +20,7 @@ namespace audioapi {
  */
 
 AudioBus::AudioBus(size_t size, int numberOfChannels, float sampleRate)
-    : numberOfChannels_(numberOfChannels),
-      sampleRate_(sampleRate),
-      size_(size) {
+    : numberOfChannels_(numberOfChannels), sampleRate_(sampleRate), size_(size) {
   createChannels();
 }
 
@@ -210,9 +212,7 @@ float AudioBus::maxAbsValue() const {
   return maxAbsValue;
 }
 
-void AudioBus::sum(
-    const AudioBus *source,
-    ChannelInterpretation interpretation) {
+void AudioBus::sum(const AudioBus *source, ChannelInterpretation interpretation) {
   sum(source, 0, 0, getSize(), interpretation);
 }
 
@@ -256,8 +256,7 @@ void AudioBus::sum(
 
   // 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);
   }
 }
 
@@ -280,8 +279,7 @@ void AudioBus::copy(
 
   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;
@@ -313,15 +311,13 @@ void AudioBus::discreteSum(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) const {
-  int numberOfChannels =
-      std::min(getNumberOfChannels(), source->getNumberOfChannels());
+  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);
+    getChannel(i)->sum(source->getChannel(i), sourceStart, destinationStart, length);
   }
 }
 
@@ -334,14 +330,11 @@ void AudioBus::sumByUpMixing(
   int numberOfChannels = getNumberOfChannels();
 
   // Mono to stereo (1 -> 2, 4)
-  if (numberOfSourceChannels == 1 &&
-      (numberOfChannels == 2 || numberOfChannels == 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);
+    getChannelByType(ChannelLeft)->sum(sourceChannel, sourceStart, destinationStart, length);
+    getChannelByType(ChannelRight)->sum(sourceChannel, sourceStart, destinationStart, length);
     return;
   }
 
@@ -349,55 +342,30 @@ void AudioBus::sumByUpMixing(
   if (numberOfSourceChannels == 1 && numberOfChannels == 6) {
     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)) {
+  if (numberOfSourceChannels == 2 && (numberOfChannels == 4 || numberOfChannels == 6)) {
     getChannelByType(ChannelLeft)
-        ->sum(
-            source->getChannelByType(ChannelLeft),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelRight)
-        ->sum(
-            source->getChannelByType(ChannelRight),
-            sourceStart,
-            destinationStart,
-            length);
+        ->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);
+        ->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelRight)
-        ->sum(
-            source->getChannelByType(ChannelRight),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelRight), sourceStart, destinationStart, length);
     getChannelByType(ChannelSurroundLeft)
-        ->sum(
-            source->getChannelByType(ChannelSurroundLeft),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelSurroundLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelSurroundRight)
         ->sum(
-            source->getChannelByType(ChannelSurroundRight),
-            sourceStart,
-            destinationStart,
-            length);
+            source->getChannelByType(ChannelSurroundRight), sourceStart, destinationStart, length);
     return;
   }
 
@@ -420,15 +388,9 @@ void AudioBus::sumByDownMixing(
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.5f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.5f, destinationData + destinationStart, length);
     return;
   }
 
@@ -438,33 +400,19 @@ void AudioBus::sumByDownMixing(
   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 *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.25f, destinationData + destinationStart, length);
     return;
   }
 
@@ -475,38 +423,24 @@ void AudioBus::sumByDownMixing(
     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 *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        SQRT_HALF,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, SQRT_HALF, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        SQRT_HALF,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, SQRT_HALF, destinationData + destinationStart, length);
     dsp::add(
         sourceCenter + sourceStart,
         destinationData + destinationStart,
         destinationData + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.5f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.5f, destinationData + destinationStart, length);
 
     return;
   }
@@ -517,35 +451,21 @@ void AudioBus::sumByDownMixing(
   if (numberOfSourceChannels == 4 && numberOfChannels == 2) {
     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 *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.5f,
-        destinationLeft + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.5f, destinationLeft + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.5f,
-        destinationLeft + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.5f, destinationLeft + destinationStart, length);
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.5f,
-        destinationRight + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.5f, destinationRight + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.5f,
-        destinationRight + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.5f, destinationRight + destinationStart, length);
     return;
   }
 
@@ -557,10 +477,8 @@ void AudioBus::sumByDownMixing(
     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 *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
@@ -571,15 +489,9 @@ void AudioBus::sumByDownMixing(
         destinationLeft + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceCenter + sourceStart,
-        SQRT_HALF,
-        destinationLeft + destinationStart,
-        length);
+        sourceCenter + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        SQRT_HALF,
-        destinationLeft + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
 
     dsp::add(
         sourceRight + sourceStart,
@@ -587,15 +499,9 @@ void AudioBus::sumByDownMixing(
         destinationRight + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceCenter + sourceStart,
-        SQRT_HALF,
-        destinationRight + destinationStart,
-        length);
+        sourceCenter + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        SQRT_HALF,
-        destinationRight + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
     return;
   }
 
@@ -608,17 +514,13 @@ void AudioBus::sumByDownMixing(
     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 *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();
+    float *destinationSurroundLeft = getChannelByType(ChannelSurroundLeft)->getData();
+    float *destinationSurroundRight = getChannelByType(ChannelSurroundRight)->getData();
 
     dsp::add(
         sourceLeft + sourceStart,

package/common/cpp/audioapi/utils/AudioBus.h

@@ -3,9 +3,9 @@
 #include <audioapi/core/types/ChannelInterpretation.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 
@@ -28,7 +28,7 @@ class AudioBus {
   explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
   AudioBus(const AudioBus &other);
   AudioBus(AudioBus &&other) noexcept;
-  AudioBus& operator=(const AudioBus& other);
+  AudioBus &operator=(const AudioBus &other);
 
   ~AudioBus();
 
@@ -49,21 +49,24 @@ class AudioBus {
   void zero();
   void zero(size_t start, size_t length);
 
-  void sum(const AudioBus *source, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
-  void sum(const AudioBus *source, size_t start, size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+  void sum(
+      const AudioBus *source,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+  void sum(
+      const AudioBus *source,
+      size_t start,
+      size_t length,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
   void sum(
       const AudioBus *source,
       size_t sourceStart,
       size_t destinationStart,
-      size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+      size_t length,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
 
   void copy(const AudioBus *source);
   void copy(const AudioBus *source, size_t start, size_t length);
-  void copy(
-      const AudioBus *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void copy(const AudioBus *source, size_t sourceStart, size_t destinationStart, size_t length);
 
  private:
   std::vector<std::shared_ptr<AudioArray>> channels_;
@@ -78,11 +81,8 @@ class AudioBus {
       size_t sourceStart,
       size_t destinationStart,
       size_t length) const;
-  void sumByUpMixing(
-      const AudioBus *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void
+  sumByUpMixing(const AudioBus *source, size_t sourceStart, size_t destinationStart, size_t length);
   void sumByDownMixing(
       const AudioBus *source,
       size_t sourceStart,

package/common/cpp/audioapi/utils/CircularAudioArray.cpp

@@ -4,10 +4,7 @@ namespace audioapi {
 
 CircularAudioArray::CircularAudioArray(size_t size) : AudioArray(size) {}
 
-void CircularAudioArray::push_back(
-    const float *data,
-    size_t size,
-    bool skipAvailableSpaceCheck) {
+void CircularAudioArray::push_back(const float *data, size_t size, bool skipAvailableSpaceCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -24,14 +21,10 @@ void CircularAudioArray::push_back(
     memcpy(data_ + vWriteIndex_, data, size * sizeof(float));
   }
 
-  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_
-                                             : vWriteIndex_ + size;
+  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_ : vWriteIndex_ + size;
 }
 
-void CircularAudioArray::pop_front(
-    float *data,
-    size_t size,
-    bool skipAvailableDataCheck) {
+void CircularAudioArray::pop_front(float *data, size_t size, bool skipAvailableDataCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -48,8 +41,7 @@ void CircularAudioArray::pop_front(
     memcpy(data, data_ + vReadIndex_, size * sizeof(float));
   }
 
-  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_
-                                           : vReadIndex_ + size;
+  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_ : vReadIndex_ + size;
 }
 
 void CircularAudioArray::pop_back(
@@ -66,10 +58,7 @@ void CircularAudioArray::pop_back(
   }
 
   if (vWriteIndex_ <= offset) {
-    memcpy(
-        data,
-        data_ + size_ - (offset - vWriteIndex_) - size,
-        size * sizeof(float));
+    memcpy(data, data_ + size_ - (offset - vWriteIndex_) - size, size * sizeof(float));
   } else if (vWriteIndex_ <= size + offset) {
     auto partSize = size + offset - vWriteIndex_;
     memcpy(data, data_ + size_ - partSize, partSize * sizeof(float));
@@ -78,8 +67,7 @@ void CircularAudioArray::pop_back(
     memcpy(data, data_ + vWriteIndex_ - size - offset, size * sizeof(float));
   }
 
-  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset
-                                          : vWriteIndex_ - offset;
+  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset : vWriteIndex_ - offset;
 }
 
 size_t CircularAudioArray::getNumberOfAvailableFrames() const {

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.cpp

@@ -1,16 +1,14 @@
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <algorithm>
 #include <type_traits>
 
 namespace audioapi {
 
-CircularOverflowableAudioArray::CircularOverflowableAudioArray(
-    size_t
-        size) noexcept(std::is_nothrow_constructible<AudioArray, size_t>::value)
+CircularOverflowableAudioArray::CircularOverflowableAudioArray(size_t size) noexcept(
+    std::is_nothrow_constructible<AudioArray, size_t>::value)
     : AudioArray(size) {}
 
-void CircularOverflowableAudioArray::write(
-    const float *data,
-    const size_t size) {
+void CircularOverflowableAudioArray::write(const float *data, const size_t size) {
   size_t writeIndex = vWriteIndex_.load(std::memory_order_relaxed);
 
   if (size > size_) {
@@ -43,8 +41,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
   size_t partSize = size_ - vReadIndex_;
   if (readSize > partSize) {
     std::memcpy(output, data_ + vReadIndex_, partSize * sizeof(float));
-    std::memcpy(
-        output + partSize, data_, (readSize - partSize) * sizeof(float));
+    std::memcpy(output + partSize, data_, (readSize - partSize) * sizeof(float));
   } else {
     std::memcpy(output, data_ + vReadIndex_, readSize * sizeof(float));
   }
@@ -54,8 +51,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
 }
 
 size_t CircularOverflowableAudioArray::getAvailableSpace() const {
-  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) %
-      size_;
+  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) % size_;
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.h

@@ -2,9 +2,9 @@
 #pragma once
 
 #include <audioapi/utils/AudioArray.h>
-#include <stdexcept>
 #include <atomic>
 #include <mutex>
+#include <stdexcept>
 
 namespace audioapi {
 
@@ -32,7 +32,7 @@ class CircularOverflowableAudioArray : public AudioArray {
   size_t read(float *output, size_t size) const;
 
  private:
-  std::atomic<size_t> vWriteIndex_ = { 0 };
+  std::atomic<size_t> vWriteIndex_ = {0};
   mutable size_t vReadIndex_ = 0; // it is only used after acquiring readLock_
   mutable std::mutex readLock_;
 

package/common/cpp/test/src/AudioParamTest.cpp

@@ -3,6 +3,8 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+#include <vector>
 
 using namespace audioapi;
 
@@ -119,8 +121,7 @@ TEST_F(AudioParamTest, SetTargetAtTime) {
 TEST_F(AudioParamTest, SetValueCurveAtTime) {
   AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
   param.setValue(0.5);
-  auto curve = std::make_shared<std::vector<float>>(
-      std::vector<float>{0.1, 0.4, 0.2, 0.8, 0.5});
+  auto curve = std::make_shared<std::vector<float>>(std::vector<float>{0.1, 0.4, 0.2, 0.8, 0.5});
   param.setValueCurveAtTime(curve, curve->size(), 0.1, 0.2);
   // 5 elements over 0.2s => each element is 0.04s apart
 

package/common/cpp/test/src/AudioScheduledSourceTest.cpp

@@ -5,12 +5,12 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 static constexpr int SAMPLE_RATE = 44100;
 static constexpr int RENDER_QUANTUM = 128;
-static constexpr double RENDER_QUANTUM_TIME =
-    static_cast<double>(RENDER_QUANTUM) / SAMPLE_RATE;
+static constexpr double RENDER_QUANTUM_TIME = static_cast<double>(RENDER_QUANTUM) / SAMPLE_RATE;
 
 class AudioScheduledSourceTest : public ::testing::Test {
  protected:
@@ -40,8 +40,7 @@ class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
         processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
   }
 
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int)
-      override {
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int) override {
     return nullptr;
   }
 
@@ -52,42 +51,30 @@ class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
   void playFrames(int frames) {
     size_t startOffset = 0;
     size_t nonSilentFramesToProcess = 0;
-    auto processingBus =
-        std::make_shared<AudioBus>(128, 2, static_cast<float>(SAMPLE_RATE));
-    updatePlaybackInfo(
-        processingBus, frames, startOffset, nonSilentFramesToProcess);
+    auto processingBus = std::make_shared<AudioBus>(128, 2, static_cast<float>(SAMPLE_RATE));
+    updatePlaybackInfo(processingBus, frames, startOffset, nonSilentFramesToProcess);
     context_->getDestination()->renderAudio(processingBus, frames);
   }
 };
 
 TEST_F(AudioScheduledSourceTest, IsUnscheduledStateSetCorrectly) {
   auto sourceNode = TestableAudioScheduledSourceNode(context.get());
-  EXPECT_EQ(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
 
   sourceNode.start(RENDER_QUANTUM_TIME);
-  EXPECT_NE(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
 }
 
 TEST_F(AudioScheduledSourceTest, IsScheduledStateSetCorrectly) {
   auto sourceNode = TestableAudioScheduledSourceNode(context.get());
   sourceNode.start(RENDER_QUANTUM_TIME);
-  EXPECT_EQ(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
 
   sourceNode.playFrames(RENDER_QUANTUM);
-  EXPECT_EQ(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
 
   sourceNode.playFrames(1);
-  EXPECT_NE(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
 }
 
 TEST_F(AudioScheduledSourceTest, IsPlayingStateSetCorrectly) {
@@ -96,14 +83,10 @@ TEST_F(AudioScheduledSourceTest, IsPlayingStateSetCorrectly) {
   sourceNode.stop(RENDER_QUANTUM_TIME);
 
   sourceNode.playFrames(RENDER_QUANTUM);
-  EXPECT_EQ(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::PLAYING);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::PLAYING);
 
   sourceNode.playFrames(1);
-  EXPECT_NE(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::PLAYING);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::PLAYING);
 }
 
 TEST_F(AudioScheduledSourceTest, IsStopScheduledStateSetCorrectly) {
@@ -112,14 +95,10 @@ TEST_F(AudioScheduledSourceTest, IsStopScheduledStateSetCorrectly) {
   sourceNode.stop(RENDER_QUANTUM_TIME);
   sourceNode.playFrames(1); // start playing
   sourceNode.playFrames(RENDER_QUANTUM);
-  EXPECT_EQ(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
 
   sourceNode.playFrames(1);
-  EXPECT_NE(
-      sourceNode.getPlaybackState(),
-      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
 }
 
 TEST_F(AudioScheduledSourceTest, IsFinishedStateSetCorrectly) {