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

package/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp

@@ -1,14 +1,14 @@
 #include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <memory>
 
 namespace audioapi {
 
 AudioScheduledSourceNodeHostObject::AudioScheduledSourceNodeHostObject(
     const std::shared_ptr<AudioScheduledSourceNode> &node)
     : AudioNodeHostObject(node) {
-  addSetters(
-      JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onEnded));
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onEnded));
 
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, start),
@@ -16,8 +16,7 @@ AudioScheduledSourceNodeHostObject::AudioScheduledSourceNodeHostObject(
 }
 
 AudioScheduledSourceNodeHostObject::~AudioScheduledSourceNodeHostObject() {
-  auto audioScheduledSourceNode =
-      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto audioScheduledSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
 
   // When JSI object is garbage collected (together with the eventual callback),
   // underlying source node might still be active and try to call the
@@ -26,8 +25,7 @@ AudioScheduledSourceNodeHostObject::~AudioScheduledSourceNodeHostObject() {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioScheduledSourceNodeHostObject, onEnded) {
-  auto audioScheduleSourceNode =
-      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto audioScheduleSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
 
   audioScheduleSourceNode->setOnEndedCallbackId(
       std::stoull(value.getString(runtime).utf8(runtime)));
@@ -35,16 +33,14 @@ JSI_PROPERTY_SETTER_IMPL(AudioScheduledSourceNodeHostObject, onEnded) {
 
 JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, start) {
   auto when = args[0].getNumber();
-  auto audioScheduleSourceNode =
-      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto audioScheduleSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
   audioScheduleSourceNode->start(when);
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, stop) {
   auto time = args[0].getNumber();
-  auto audioScheduleSourceNode =
-      std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto audioScheduleSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
   audioScheduleSourceNode->stop(time);
   return jsi::Value::undefined();
 }

package/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -12,8 +13,7 @@ ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
 
 JSI_PROPERTY_GETTER_IMPL(ConstantSourceNodeHostObject, offset) {
   auto constantSourceNode = std::static_pointer_cast<ConstantSourceNode>(node_);
-  auto offsetParam_ = std::make_shared<AudioParamHostObject>(
-      constantSourceNode->getOffsetParam());
+  auto offsetParam_ = std::make_shared<AudioParamHostObject>(constantSourceNode->getOffsetParam());
   return jsi::Object::createFromHostObject(runtime, offsetParam_);
 }
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h

@@ -13,8 +13,7 @@ class ConstantSourceNode;
 
 class ConstantSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit ConstantSourceNodeHostObject(
-        const std::shared_ptr<ConstantSourceNode> &node);
+  explicit ConstantSourceNodeHostObject(const std::shared_ptr<ConstantSourceNode> &node);
 
   JSI_PROPERTY_GETTER_DECL(offset);
 };

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp

@@ -3,11 +3,11 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/core/sources/OscillatorNode.h>
+#include <memory>
 
 namespace audioapi {
 
-OscillatorNodeHostObject::OscillatorNodeHostObject(
-    const std::shared_ptr<OscillatorNode> &node)
+OscillatorNodeHostObject::OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node)
     : AudioScheduledSourceNodeHostObject(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
@@ -21,15 +21,14 @@ OscillatorNodeHostObject::OscillatorNodeHostObject(
 
 JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, frequency) {
   auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
-  auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
-      oscillatorNode->getFrequencyParam());
+  auto frequencyParam_ =
+      std::make_shared<AudioParamHostObject>(oscillatorNode->getFrequencyParam());
   return jsi::Object::createFromHostObject(runtime, frequencyParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, detune) {
   auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
-  auto detuneParam_ =
-      std::make_shared<AudioParamHostObject>(oscillatorNode->getDetuneParam());
+  auto detuneParam_ = std::make_shared<AudioParamHostObject>(oscillatorNode->getDetuneParam());
   return jsi::Object::createFromHostObject(runtime, detuneParam_);
 }
 
@@ -41,8 +40,7 @@ JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, type) {
 
 JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
   auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
-  auto periodicWave =
-      args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(runtime);
+  auto periodicWave = args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(runtime);
   oscillatorNode->setPeriodicWave(periodicWave->periodicWave_);
   return jsi::Value::undefined();
 }

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.h

@@ -13,8 +13,7 @@ class OscillatorNode;
 
 class OscillatorNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit OscillatorNodeHostObject(
-          const std::shared_ptr<OscillatorNode> &node);
+  explicit OscillatorNodeHostObject(const std::shared_ptr<OscillatorNode> &node);
 
   JSI_PROPERTY_GETTER_DECL(frequency);
   JSI_PROPERTY_GETTER_DECL(detune);

package/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/sources/RecorderAdapterNode.h>
 
 #include <memory>
 #include <string>
@@ -14,12 +14,11 @@ class AudioRecorderHostObject;
 
 class RecorderAdapterNodeHostObject : public AudioNodeHostObject {
  public:
-    explicit RecorderAdapterNodeHostObject(
-        const std::shared_ptr<RecorderAdapterNode> &node)
-        : AudioNodeHostObject(node) {}
+  explicit RecorderAdapterNodeHostObject(const std::shared_ptr<RecorderAdapterNode> &node)
+      : AudioNodeHostObject(node) {}
 
  private:
-    friend class AudioRecorderHostObject;
+  friend class AudioRecorderHostObject;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.cpp

@@ -3,11 +3,11 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/core/sources/StreamerNode.h>
+#include <memory>
 
 namespace audioapi {
 
-StreamerNodeHostObject::StreamerNodeHostObject(
-    const std::shared_ptr<StreamerNode> &node)
+StreamerNodeHostObject::StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node)
     : AudioScheduledSourceNodeHostObject(node) {
   addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
 }

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h

@@ -13,16 +13,15 @@ class StreamerNode;
 
 class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit StreamerNodeHostObject(
-          const std::shared_ptr<StreamerNode> &node);
+  explicit StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node);
 
-    [[nodiscard]] static inline size_t getSizeInBytes() {
-        return SIZE;
-    }
+  [[nodiscard]] static inline size_t getSizeInBytes() {
+    return SIZE;
+  }
 
   JSI_HOST_FUNCTION_DECL(initialize);
 
  private:
-    static constexpr size_t SIZE = 4'000'000; // 4MB
+  static constexpr size_t SIZE = 4'000'000; // 4MB
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h

@@ -12,7 +12,6 @@ using namespace facebook;
 class WorkletSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
   explicit WorkletSourceNodeHostObject(const std::shared_ptr<WorkletSourceNode> &node)
-      : AudioScheduledSourceNodeHostObject(node) {
-  }
+      : AudioScheduledSourceNodeHostObject(node) {}
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/utils/AudioDecoderHostObject.cpp

@@ -21,40 +21,31 @@ AudioDecoderHostObject::AudioDecoderHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithMemoryBlock) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = arrayBuffer.data(runtime);
   auto size = static_cast<int>(arrayBuffer.size(runtime));
 
   auto sampleRate = args[1].getNumber();
 
-  auto promise = promiseVendor_->createAsyncPromise(
-      [data, size, sampleRate]() -> PromiseResolver {
-        auto result =
-            AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
+  auto promise = promiseVendor_->createAsyncPromise([data, size, sampleRate]() -> PromiseResolver {
+    auto result = AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
 
-        if (!result) {
-          return [](jsi::Runtime &runtime)
-                     -> std::variant<jsi::Value, std::string> {
-            return std::string("Failed to decode audio data.");
-          };
-        }
+    if (!result) {
+      return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+        return std::string("Failed to decode audio data.");
+      };
+    }
 
-        auto audioBufferHostObject =
-            std::make_shared<AudioBufferHostObject>(result);
+    auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(result);
 
-        return [audioBufferHostObject =
-                    std::move(audioBufferHostObject)](jsi::Runtime &runtime)
-                   -> std::variant<jsi::Value, std::string> {
-          auto jsiObject =
-              jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
-          jsiObject.setExternalMemoryPressure(
-              runtime, audioBufferHostObject->getSizeInBytes());
-          return jsiObject;
-        };
-      });
+    return [audioBufferHostObject = std::move(audioBufferHostObject)](
+               jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+      auto jsiObject = jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+      jsiObject.setExternalMemoryPressure(runtime, audioBufferHostObject->getSizeInBytes());
+      return jsiObject;
+    };
+  });
   return promise;
 }
 
@@ -62,30 +53,24 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithFilePath) {
   auto sourcePath = args[0].getString(runtime).utf8(runtime);
   auto sampleRate = args[1].getNumber();
 
-  auto promise = promiseVendor_->createAsyncPromise(
-      [sourcePath, sampleRate]() -> PromiseResolver {
-        auto result = AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
+  auto promise = promiseVendor_->createAsyncPromise([sourcePath, sampleRate]() -> PromiseResolver {
+    auto result = AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
 
-        if (!result) {
-          return [](jsi::Runtime &runtime)
-                     -> std::variant<jsi::Value, std::string> {
-            return std::string("Failed to decode audio data source.");
-          };
-        }
+    if (!result) {
+      return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+        return std::string("Failed to decode audio data source.");
+      };
+    }
 
-        auto audioBufferHostObject =
-            std::make_shared<AudioBufferHostObject>(result);
+    auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(result);
 
-        return [audioBufferHostObject =
-                    std::move(audioBufferHostObject)](jsi::Runtime &runtime)
-                   -> std::variant<jsi::Value, std::string> {
-          auto jsiObject =
-              jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
-          jsiObject.setExternalMemoryPressure(
-              runtime, audioBufferHostObject->getSizeInBytes());
-          return jsiObject;
-        };
-      });
+    return [audioBufferHostObject = std::move(audioBufferHostObject)](
+               jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+      auto jsiObject = jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+      jsiObject.setExternalMemoryPressure(runtime, audioBufferHostObject->getSizeInBytes());
+      return jsiObject;
+    };
+  });
 
   return promise;
 }
@@ -97,28 +82,22 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithPCMInBase64) {
   auto interleaved = args[3].getBool();
 
   auto promise = promiseVendor_->createAsyncPromise(
-      [b64, inputSampleRate, inputChannelCount, interleaved]()
-          -> PromiseResolver {
+      [b64, inputSampleRate, inputChannelCount, interleaved]() -> PromiseResolver {
         auto result = AudioDecoder::decodeWithPCMInBase64(
             b64, inputSampleRate, inputChannelCount, interleaved);
 
         if (!result) {
-          return [](jsi::Runtime &runtime)
-                     -> std::variant<jsi::Value, std::string> {
+          return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
             return std::string("Failed to decode audio data source.");
           };
         }
 
-        auto audioBufferHostObject =
-            std::make_shared<AudioBufferHostObject>(result);
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(result);
 
-        return [audioBufferHostObject =
-                    std::move(audioBufferHostObject)](jsi::Runtime &runtime)
-                   -> std::variant<jsi::Value, std::string> {
-          auto jsiObject =
-              jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
-          jsiObject.setExternalMemoryPressure(
-              runtime, audioBufferHostObject->getSizeInBytes());
+        return [audioBufferHostObject = std::move(audioBufferHostObject)](
+                   jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+          auto jsiObject = jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+          jsiObject.setExternalMemoryPressure(runtime, audioBufferHostObject->getSizeInBytes());
           return jsiObject;
         };
       });

package/common/cpp/audioapi/HostObjects/utils/AudioStretcherHostObject.cpp

@@ -15,18 +15,15 @@ AudioStretcherHostObject::AudioStretcherHostObject(
     jsi::Runtime *runtime,
     const std::shared_ptr<react::CallInvoker> &callInvoker) {
   promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
-  addFunctions(
-      JSI_EXPORT_FUNCTION(AudioStretcherHostObject, changePlaybackSpeed));
+  addFunctions(JSI_EXPORT_FUNCTION(AudioStretcherHostObject, changePlaybackSpeed));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioStretcherHostObject, changePlaybackSpeed) {
-  auto audioBuffer =
-      args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  auto audioBuffer = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
   auto playbackSpeed = static_cast<float>(args[1].asNumber());
 
   auto promise = promiseVendor_->createAsyncPromise([=]() -> PromiseResolver {
-    auto result = AudioStretcher::changePlaybackSpeed(
-        *audioBuffer->audioBuffer_, playbackSpeed);
+    auto result = AudioStretcher::changePlaybackSpeed(*audioBuffer->audioBuffer_, playbackSpeed);
 
     if (result == nullptr) {
       return [](jsi::Runtime &runtime) {
@@ -34,8 +31,7 @@ JSI_HOST_FUNCTION_IMPL(AudioStretcherHostObject, changePlaybackSpeed) {
       };
     }
     return [result](jsi::Runtime &runtime) {
-      auto audioBufferHostObject =
-          std::make_shared<AudioBufferHostObject>(result);
+      auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(result);
       return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
     };
   });

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -7,12 +7,13 @@
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <memory>
+#include <string>
 
 namespace audioapi {
 AudioContext::AudioContext(
     float sampleRate,
-    const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry,
+    const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
     const RuntimeRegistry &runtimeRegistry)
     : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry) {
 #ifdef ANDROID
@@ -89,8 +90,7 @@ bool AudioContext::start() {
   return false;
 }
 
-std::function<void(std::shared_ptr<AudioBus>, int)>
-AudioContext::renderAudio() {
+std::function<void(std::shared_ptr<AudioBus>, int)> AudioContext::renderAudio() {
   return [this](const std::shared_ptr<AudioBus> &data, int frames) {
     destination_->renderAudio(data, frames);
   };

package/common/cpp/audioapi/core/AudioContext.h

@@ -3,8 +3,8 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
-#include <memory>
 #include <functional>
+#include <memory>
 
 namespace audioapi {
 #ifdef ANDROID
@@ -15,7 +15,10 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
+  explicit AudioContext(
+      float sampleRate,
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry);
   ~AudioContext() override;
 
   void close();

package/common/cpp/audioapi/core/AudioNode.cpp

@@ -4,12 +4,15 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }
 
 AudioNode::~AudioNode() {
@@ -50,9 +53,7 @@ void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
 
 void AudioNode::disconnect() {
   context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(),
-      nullptr,
-      AudioNodeManager::ConnectionType::DISCONNECT_ALL);
+      shared_from_this(), nullptr, AudioNodeManager::ConnectionType::DISCONNECT_ALL);
 }
 
 void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
@@ -76,8 +77,7 @@ void AudioNode::enable() {
 
   isEnabled_ = true;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputEnabled();
   }
 }
@@ -89,8 +89,7 @@ void AudioNode::disable() {
 
   isEnabled_ = false;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputDisabled();
   }
 }
@@ -132,8 +131,7 @@ std::shared_ptr<AudioBus> AudioNode::processAudio(
   }
 
   // Process inputs and return the bus with the most channels.
-  auto processingBus =
-      processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
+  auto processingBus = processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
 
   // Apply channel count mode.
   processingBus = applyChannelCountMode(processingBus);
@@ -172,8 +170,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
   processingBus->zero();
 
   int maxNumberOfChannels = 0;
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end; ++it) {
     auto inputNode = *it;
     assert(inputNode != nullptr);
 
@@ -181,8 +178,7 @@ std::shared_ptr<AudioBus> AudioNode::processInputs(
       continue;
     }
 
-    auto inputBus = inputNode->processAudio(
-        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    auto inputBus = inputNode->processAudio(outputBus, framesToProcess, checkIsAlreadyProcessed);
     inputBuses_.push_back(inputBus);
 
     if (maxNumberOfChannels < inputBus->getNumberOfChannels()) {
@@ -215,8 +211,7 @@ std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
 void AudioNode::mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus) {
   assert(processingBus != nullptr);
 
-  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
-       ++it) {
+  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end; ++it) {
     processingBus->sum(it->get(), channelInterpretation_);
   }
 
@@ -306,8 +301,7 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
 void AudioNode::cleanup() {
   isInitialized_ = false;
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
+  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
     it->get()->onInputDisconnected(this);
   }
 

package/common/cpp/audioapi/core/AudioNode.h

@@ -4,12 +4,12 @@
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/Constants.h>
 
+#include <cassert>
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <unordered_set>
-#include <cstddef>
 #include <vector>
-#include <cassert>
 
 namespace audioapi {
 
@@ -32,7 +32,10 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void disconnect();
   void disconnect(const std::shared_ptr<AudioNode> &node);
   void disconnect(const std::shared_ptr<AudioParam> &param);
-  virtual std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  virtual std::shared_ptr<AudioBus> processAudio(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed);
 
   bool isEnabled() const;
   void enable();
@@ -51,7 +54,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   int channelCount_ = 2;
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
   ChannelInterpretation channelInterpretation_ =
-          ChannelInterpretation::SPEAKERS;
+
+      ChannelInterpretation::SPEAKERS;
 
   std::unordered_set<AudioNode *> inputNodes_ = {};
   std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
@@ -69,12 +73,15 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  virtual std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-  virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>&, int) = 0;
+  virtual std::shared_ptr<AudioBus> processInputs(
+      const std::shared_ptr<AudioBus> &outputBus,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed);
+  virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int) = 0;
 
   bool isAlreadyProcessed();
   std::shared_ptr<AudioBus> applyChannelCountMode(const std::shared_ptr<AudioBus> &processingBus);
-  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
+  void mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus);
 
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);