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

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 #include <memory>
 
@@ -18,26 +18,28 @@ class AudioBus;
 /// @note it will push silence if it is not connected to any Recorder
 class RecorderAdapterNode : public AudioNode {
  public:
-    explicit RecorderAdapterNode(BaseAudioContext *context);
+  explicit RecorderAdapterNode(BaseAudioContext *context);
 
-    /// @brief Initialize the RecorderAdapterNode with a buffer size.
-    /// @note This method should be called ONLY ONCE when the buffer size is known.
-    /// @throws std::runtime_error if the node is already initialized.
-    /// @param bufferSize The size of the buffer to be used.
-    void init(size_t bufferSize);
+  /// @brief Initialize the RecorderAdapterNode with a buffer size.
+  /// @note This method should be called ONLY ONCE when the buffer size is known.
+  /// @throws std::runtime_error if the node is already initialized.
+  /// @param bufferSize The size of the buffer to be used.
+  void init(size_t bufferSize);
 
  protected:
-    std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-    std::shared_ptr<CircularOverflowableAudioArray> buff_;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+  std::shared_ptr<CircularOverflowableAudioArray> buff_;
 
  private:
-    /// @brief Read audio frames from the recorder's internal adapterBuffer.
-    /// @note If `framesToRead` is greater than the number of available frames, it will fill empty space with silence.
-    /// @param output Pointer to the output buffer.
-    /// @param framesToRead Number of frames to read.
-    void readFrames(float *output, size_t framesToRead);
+  /// @brief Read audio frames from the recorder's internal adapterBuffer.
+  /// @note If `framesToRead` is greater than the number of available frames, it will fill empty space with silence.
+  /// @param output Pointer to the output buffer.
+  /// @param framesToRead Number of frames to read.
+  void readFrames(float *output, size_t framesToRead);
 
-    friend class AudioRecorder;
+  friend class AudioRecorder;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/StreamerNode.cpp

@@ -15,6 +15,10 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <chrono>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace audioapi {
 StreamerNode::StreamerNode(BaseAudioContext *context)
@@ -65,8 +69,8 @@ bool StreamerNode::initialize(const std::string &input_url) {
   }
 
   channelCount_ = codecpar_->ch_layout.nb_channels;
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  audioBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
 
   auto [sender, receiver] = channels::spsc::channel<
       StreamingData,
@@ -134,8 +138,7 @@ void StreamerNode::streamAudio() {
     av_packet_unref(pkt_);
   }
   StreamingData dummy;
-  while (receiver_.try_receive(dummy) ==
-         channels::spsc::ResponseStatus::SUCCESS)
+  while (receiver_.try_receive(dummy) == channels::spsc::ResponseStatus::SUCCESS)
     ; // clear the receiver
 }
 

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -15,19 +15,19 @@
 
 #ifndef AUDIO_API_TEST_SUITE
 extern "C" {
-  #include <libavformat/avformat.h>
-  #include <libavcodec/avcodec.h>
-  #include <libavutil/samplefmt.h>
-  #include <libavutil/channel_layout.h>
-  #include <libavutil/opt.h>
-  #include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/opt.h>
+#include <libavutil/samplefmt.h>
+#include <libswresample/swresample.h>
 }
 #endif
 
+#include <atomic>
 #include <cmath>
 #include <memory>
 #include <string>
-#include <atomic>
 #include <utility>
 #ifndef AUDIO_API_TEST_SUITE
 #include <audioapi/utils/SpscChannel.hpp>
@@ -41,14 +41,14 @@ static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_
 static constexpr bool VERBOSE = false;
 static constexpr int CHANNEL_CAPACITY = 32;
 
-struct StreamingData{
+struct StreamingData {
   audioapi::AudioBus bus;
   size_t size;
   StreamingData() = default;
   StreamingData(audioapi::AudioBus b, size_t s) : bus(b), size(s) {}
-  StreamingData(const StreamingData& data) : bus(data.bus), size(data.size) {}
-  StreamingData(StreamingData&& data) noexcept : bus(std::move(data.bus)), size(data.size) {}
-  StreamingData& operator=(const StreamingData& data) {
+  StreamingData(const StreamingData &data) : bus(data.bus), size(data.size) {}
+  StreamingData(StreamingData &&data) noexcept : bus(std::move(data.bus)), size(data.size) {}
+  StreamingData &operator=(const StreamingData &data) {
     if (this == &data) {
       return *this;
     }
@@ -70,33 +70,41 @@ class StreamerNode : public AudioScheduledSourceNode {
   /**
    * @brief Initialize all necessary ffmpeg components for streaming audio
   */
-  bool initialize(const std::string& inputUrl);
+  bool initialize(const std::string &inputUrl);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
 
  private:
-  #ifndef AUDIO_API_TEST_SUITE
-  AVFormatContext* fmtCtx_;
-  AVCodecContext* codecCtx_;
-  const AVCodec* decoder_;
-  AVCodecParameters* codecpar_;
-  AVPacket* pkt_;
-  AVFrame* frame_; // Frame that is currently being processed
-  SwrContext* swrCtx_;
-  uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
+#ifndef AUDIO_API_TEST_SUITE
+  AVFormatContext *fmtCtx_;
+  AVCodecContext *codecCtx_;
+  const AVCodec *decoder_;
+  AVCodecParameters *codecpar_;
+  AVPacket *pkt_;
+  AVFrame *frame_; // Frame that is currently being processed
+  SwrContext *swrCtx_;
+  uint8_t **resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
 
   std::shared_ptr<AudioBus> bufferedBus_; // audio bus for buffering hls frames
-  size_t bufferedBusSize_; // size of currently buffered bus
-  int audio_stream_index_; // index of the audio stream channel in the input
+  size_t bufferedBusSize_;                // size of currently buffered bus
+  int audio_stream_index_;                // index of the audio stream channel in the input
   int maxResampledSamples_;
   size_t processedSamples_;
 
   std::thread streamingThread_;
-  std::atomic<bool> isNodeFinished_; // Flag to control the streaming thread
+  std::atomic<bool> isNodeFinished_;                         // Flag to control the streaming thread
   static constexpr int INITIAL_MAX_RESAMPLED_SAMPLES = 8192; // Initial size for resampled data
-  channels::spsc::Sender<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> sender_;
-  channels::spsc::Receiver<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY> receiver_;
+  channels::spsc::
+      Sender<StreamingData, STREAMER_NODE_SPSC_OVERFLOW_STRATEGY, STREAMER_NODE_SPSC_WAIT_STRATEGY>
+          sender_;
+  channels::spsc::Receiver<
+      StreamingData,
+      STREAMER_NODE_SPSC_OVERFLOW_STRATEGY,
+      STREAMER_NODE_SPSC_WAIT_STRATEGY>
+      receiver_;
 
   /**
    * @brief Setting up the resampler
@@ -109,7 +117,7 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @param frame The AVFrame to resample
    * @return true if successful, false otherwise
    */
-  bool processFrameWithResampler(AVFrame* frame);
+  bool processFrameWithResampler(AVFrame *frame);
 
   /**
    * @brief Thread function to continuously read and process audio frames
@@ -128,7 +136,7 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    * @note This function initializes the FFmpeg libraries and opens the input stream
    */
-  bool openInput(const std::string& inputUrl);
+  bool openInput(const std::string &inputUrl);
 
   /**
    * @brief Find the audio stream channel in the input
@@ -141,6 +149,6 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    */
   bool setupDecoder();
-  #endif // AUDIO_API_TEST_SUITE
+#endif // AUDIO_API_TEST_SUITE
 };
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp

@@ -1,13 +1,12 @@
 #include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
-WorkletSourceNode::WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner)
-    : AudioScheduledSourceNode(context),
-      workletRunner_(std::move(workletRunner)) {
+WorkletSourceNode::WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+    : AudioScheduledSourceNode(context), workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Prepare buffers for audio processing
@@ -30,8 +29,7 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
   size_t startOffset = 0;
   size_t nonSilentFramesToProcess = framesToProcess;
 
-  updatePlaybackInfo(
-      processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
 
   if (nonSilentFramesToProcess == 0) {
     processingBus->zero();

package/common/cpp/audioapi/core/sources/WorkletSourceNode.h

@@ -1,40 +1,42 @@
 #pragma once
-#include <jsi/jsi.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/utils/AudioBus.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
 #include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <jsi/jsi.h>
 
-#include <vector>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
 #if RN_AUDIO_API_TEST
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner
-  ) : AudioScheduledSourceNode(context) {}
+  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+      : AudioScheduledSourceNode(context) {}
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return processingBus;
+  }
 };
 #else
 
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(
-    BaseAudioContext *context,
-    WorkletsRunner &&workletRunner
-  );
+  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
 
  protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
  private:
   WorkletsRunner workletRunner_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;

package/common/cpp/audioapi/core/types/AudioFormat.h

@@ -2,15 +2,5 @@
 
 namespace audioapi {
 
-enum class AudioFormat {
-  UNKNOWN,
-  WAV,
-  OGG,
-  FLAC,
-  AAC,
-  MP3,
-  M4A,
-  MP4,
-  MOV
-};
+enum class AudioFormat { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV };
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioDecoder.h

@@ -18,16 +18,23 @@ class AudioDecoder {
  public:
   AudioDecoder() = delete;
 
-  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(
+      const std::string &path,
+      float sampleRate);
   [[nodiscard]] static std::shared_ptr<AudioBuffer>
   decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
+  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(
+      const std::string &data,
+      float inputSampleRate,
+      int inputChannelCount,
+      bool interleaved);
 
  private:
   static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
-  static std::shared_ptr<AudioBuffer>
-  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
+  static std::shared_ptr<AudioBuffer> makeAudioBufferFromFloatBuffer(
+      const std::vector<float> &buffer,
+      float outputSampleRate,
+      int outputChannels);
 
   static AudioFormat detectAudioFormat(const void *data, size_t size) {
     if (size < 12)
@@ -66,7 +73,9 @@ class AudioDecoder {
     return AudioFormat::UNKNOWN;
   }
 
-  static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
+  static inline bool pathHasExtension(
+      const std::string &path,
+      const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
     for (const auto &ext : extensions) {

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.cpp

@@ -1,6 +1,8 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/utils/AudioNodeDestructor.h>
 #include <audioapi/core/utils/Locker.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -11,8 +13,7 @@ AudioNodeDestructor::AudioNodeDestructor() {
       channels::spsc::OverflowStrategy::WAIT_ON_FULL,
       channels::spsc::WaitStrategy::ATOMIC_WAIT>(kChannelCapacity);
   sender_ = std::move(sender);
-  workerHandle_ =
-      std::thread(&AudioNodeDestructor::process, this, std::move(receiver));
+  workerHandle_ = std::thread(&AudioNodeDestructor::process, this, std::move(receiver));
 }
 
 AudioNodeDestructor::~AudioNodeDestructor() {
@@ -25,10 +26,8 @@ AudioNodeDestructor::~AudioNodeDestructor() {
   }
 }
 
-bool AudioNodeDestructor::tryAddNodeForDeconstruction(
-    std::shared_ptr<AudioNode> &&node) {
-  return sender_.try_send(std::move(node)) ==
-      channels::spsc::ResponseStatus::SUCCESS;
+bool AudioNodeDestructor::tryAddNodeForDeconstruction(std::shared_ptr<AudioNode> &&node) {
+  return sender_.try_send(std::move(node)) == channels::spsc::ResponseStatus::SUCCESS;
 }
 
 void AudioNodeDestructor::process(

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.h

@@ -1,19 +1,18 @@
 #pragma once
 
-#include <thread>
+#include <audioapi/utils/SpscChannel.hpp>
 #include <atomic>
-#include <vector>
 #include <memory>
-#include <audioapi/utils/SpscChannel.hpp>
+#include <thread>
+#include <vector>
 
 namespace audioapi {
 
 class AudioNode;
 
 #define AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS \
-  std::shared_ptr<AudioNode>, \
-  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
-  channels::spsc::WaitStrategy::ATOMIC_WAIT
+  std::shared_ptr<AudioNode>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+      channels::spsc::WaitStrategy::ATOMIC_WAIT
 
 class AudioNodeDestructor {
  public:
@@ -32,13 +31,11 @@ class AudioNodeDestructor {
   std::thread workerHandle_;
   std::atomic<bool> isExiting_;
 
-  channels::spsc::Sender<
-    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> sender_;
+  channels::spsc::Sender<AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> sender_;
 
   /// @brief Processes audio nodes for deconstruction.
   /// @param receiver The receiver channel for incoming audio nodes.
-  void process(channels::spsc::Receiver<
-    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> &&receiver);
+  void process(channels::spsc::Receiver<AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> &&receiver);
 };
 
 #undef AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS

package/common/cpp/audioapi/core/utils/AudioNodeManager.cpp

@@ -4,6 +4,9 @@
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -117,8 +120,7 @@ void AudioNodeManager::preProcessGraph() {
   prepareNodesForDestruction(processingNodes_);
 }
 
-void AudioNodeManager::addProcessingNode(
-    const std::shared_ptr<AudioNode> &node) {
+void AudioNodeManager::addProcessingNode(const std::shared_ptr<AudioNode> &node) {
   auto event = std::make_unique<Event>();
   event->type = ConnectionType::ADD;
   event->payloadType = EventPayloadType::NODE;
@@ -127,8 +129,7 @@ void AudioNodeManager::addProcessingNode(
   sender_.send(std::move(event));
 }
 
-void AudioNodeManager::addSourceNode(
-    const std::shared_ptr<AudioScheduledSourceNode> &node) {
+void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node) {
   auto event = std::make_unique<Event>();
   event->type = ConnectionType::ADD;
   event->payloadType = EventPayloadType::SOURCE_NODE;
@@ -148,8 +149,7 @@ void AudioNodeManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
 
 void AudioNodeManager::settlePendingConnections() {
   std::unique_ptr<Event> value;
-  while (receiver_.try_receive(value) !=
-         channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
+  while (receiver_.try_receive(value) != channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
     switch (value->type) {
       case ConnectionType::CONNECT:
         handleConnectEvent(std::move(value));
@@ -197,8 +197,7 @@ void AudioNodeManager::handleDisconnectAllEvent(std::unique_ptr<Event> event) {
   }
 }
 
-void AudioNodeManager::handleAddToDeconstructionEvent(
-    std::unique_ptr<Event> event) {
+void AudioNodeManager::handleAddToDeconstructionEvent(std::unique_ptr<Event> event) {
   switch (event->payloadType) {
     case EventPayloadType::NODE:
       processingNodes_.push_back(event->payload.node);
@@ -215,24 +214,19 @@ void AudioNodeManager::handleAddToDeconstructionEvent(
 }
 
 template <typename U>
-inline bool AudioNodeManager::nodeCanBeDestructed(
-    std::shared_ptr<U> const &node) {
+inline bool AudioNodeManager::nodeCanBeDestructed(std::shared_ptr<U> const &node) {
   // If the node is an AudioScheduledSourceNode, we need to check if it is
   // playing
   if constexpr (std::is_base_of_v<AudioScheduledSourceNode, U>) {
-    return node.use_count() == 1 &&
-        (node->isUnscheduled() || node->isFinished());
-  } else if constexpr (std::is_base_of_v<
-                           ConvolverNode,
-                           U>) { // convolver overrides disabling behavior
+    return node.use_count() == 1 && (node->isUnscheduled() || node->isFinished());
+  } else if constexpr (std::is_base_of_v<ConvolverNode, U>) {
     return node.use_count() == 1 && !node->isEnabled();
   }
   return node.use_count() == 1;
 }
 
 template <typename U>
-void AudioNodeManager::prepareNodesForDestruction(
-    std::vector<std::shared_ptr<U>> &vec) {
+void AudioNodeManager::prepareNodesForDestruction(std::vector<std::shared_ptr<U>> &vec) {
   if (vec.empty()) {
     return;
   }
@@ -284,14 +278,11 @@ void AudioNodeManager::prepareNodesForDestruction(
 }
 
 void AudioNodeManager::cleanup() {
-  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end;
-       ++it) {
+  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end; ++it) {
     it->get()->cleanup();
   }
 
-  for (auto it = processingNodes_.begin(), end = processingNodes_.end();
-       it != end;
-       ++it) {
+  for (auto it = processingNodes_.begin(), end = processingNodes_.end(); it != end; ++it) {
     it->get()->cleanup();
   }
 

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -16,9 +16,8 @@ class AudioScheduledSourceNode;
 class AudioParam;
 
 #define AUDIO_NODE_MANAGER_SPSC_OPTIONS \
-  std::unique_ptr<Event>, \
-  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
-  channels::spsc::WaitStrategy::BUSY_LOOP
+  std::unique_ptr<Event>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+      channels::spsc::WaitStrategy::BUSY_LOOP
 
 class AudioNodeManager {
  public:
@@ -49,8 +48,8 @@ class AudioNodeManager {
     EventPayloadType payloadType;
     EventPayload payload;
 
-    Event(Event&& other);
-    Event& operator=(Event&& other);
+    Event(Event &&other);
+    Event &operator=(Event &&other);
     Event() : type(ConnectionType::CONNECT), payloadType(EventPayloadType::NODES), payload() {}
     ~Event();
   };
@@ -78,7 +77,7 @@ class AudioNodeManager {
   void addPendingParamConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioParam> &to,
-    ConnectionType type);
+      ConnectionType type);
 
   /// @brief Adds a processing node to the manager.
   /// @param node The processing node to add.
@@ -112,11 +111,9 @@ class AudioNodeManager {
   std::vector<std::shared_ptr<AudioNode>> processingNodes_;
   std::vector<std::shared_ptr<AudioParam>> audioParams_;
 
-  channels::spsc::Receiver<
-    AUDIO_NODE_MANAGER_SPSC_OPTIONS> receiver_;
+  channels::spsc::Receiver<AUDIO_NODE_MANAGER_SPSC_OPTIONS> receiver_;
 
-  channels::spsc::Sender<
-    AUDIO_NODE_MANAGER_SPSC_OPTIONS> sender_;
+  channels::spsc::Sender<AUDIO_NODE_MANAGER_SPSC_OPTIONS> sender_;
 
   void settlePendingConnections();
   void handleConnectEvent(std::unique_ptr<Event> event);
@@ -128,7 +125,7 @@ class AudioNodeManager {
   void prepareNodesForDestruction(std::vector<std::shared_ptr<U>> &vec);
 
   template <typename U>
-  inline static bool nodeCanBeDestructed(std::shared_ptr<U> const& node);
+  inline static bool nodeCanBeDestructed(std::shared_ptr<U> const &node);
 };
 
 #undef AUDIO_NODE_MANAGER_SPSC_OPTIONS

package/common/cpp/audioapi/core/utils/AudioParamEventQueue.cpp

@@ -1,4 +1,6 @@
 #include <audioapi/core/utils/AudioParamEventQueue.h>
+#include <algorithm>
+#include <utility>
 
 namespace audioapi {
 
@@ -42,9 +44,7 @@ void AudioParamEventQueue::cancelScheduledValues(double cancelTime) {
   }
 }
 
-void AudioParamEventQueue::cancelAndHoldAtTime(
-    double cancelTime,
-    double &endTimeCache) {
+void AudioParamEventQueue::cancelAndHoldAtTime(double cancelTime, double &endTimeCache) {
   while (!eventQueue_.isEmpty()) {
     auto &back = eventQueue_.peekBack();
     if (back.getEndTime() < cancelTime || back.getStartTime() <= cancelTime) {

package/common/cpp/audioapi/core/utils/AudioParamEventQueue.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/RingBiDirectionalBuffer.hpp>
 
 namespace audioapi {
@@ -16,7 +16,7 @@ class AudioParamEventQueue {
 
   /// @brief Push a new event to the back of the queue.
   /// @note Handles connecting the start value of the new event to the end value of the last event in the queue.
-  void pushBack(ParamChangeEvent&& event);
+  void pushBack(ParamChangeEvent &&event);
 
   /// @brief Pop the front event from the queue.
   /// @return The front event in the queue.
@@ -28,17 +28,17 @@ class AudioParamEventQueue {
 
   /// @brief Cancel scheduled parameter changes and hold the current value at the given time.
   /// @param cancelTime The time at which to cancel scheduled changes.
-  void cancelAndHoldAtTime(double cancelTime, double& endTimeCache);
+  void cancelAndHoldAtTime(double cancelTime, double &endTimeCache);
 
   /// @brief Get the first event in the queue.
   /// @return The first event in the queue.
-  inline const ParamChangeEvent& front() const noexcept {
+  inline const ParamChangeEvent &front() const noexcept {
     return eventQueue_.peekFront();
   }
 
   /// @brief Get the last event in the queue.
   /// @return The last event in the queue.
-  inline const ParamChangeEvent& back() const noexcept {
+  inline const ParamChangeEvent &back() const noexcept {
     return eventQueue_.peekBack();
   }