react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.3

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

@@ -11,24 +11,52 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/utils/AudioBus.h>
 
-#ifndef AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 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
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 
+#include <atomic>
 #include <cmath>
 #include <memory>
 #include <string>
-#include <atomic>
-
-static bool constexpr VERBOSE = false;
+#include <utility>
+#ifndef AUDIO_API_TEST_SUITE
+#include <audioapi/utils/SpscChannel.hpp>
+
+static constexpr audioapi::channels::spsc::OverflowStrategy STREAMER_NODE_SPSC_OVERFLOW_STRATEGY =
+    audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
+static constexpr audioapi::channels::spsc::WaitStrategy STREAMER_NODE_SPSC_WAIT_STRATEGY =
+    audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
+#endif // AUDIO_API_TEST_SUITE
+
+static constexpr bool VERBOSE = false;
+static constexpr int CHANNEL_CAPACITY = 32;
+
+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) {
+    if (this == &data) {
+      return *this;
+    }
+    bus = data.bus;
+    size = data.size;
+    return *this;
+  }
+};
 
 namespace audioapi {
 
@@ -42,33 +70,41 @@ class StreamerNode : public AudioScheduledSourceNode {
   /**
    * @brief Initialize all necessary ffmpeg components for streaming audio
   */
-  bool initialize(const std::string& inputUrl);
-  void stop(double when) override;
+  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
-  AVFrame* pendingFrame_; // Frame that is saved if bufferedBus is full
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+  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 bufferedBusIndex_; // index in the buffered bus where we write the next frame
-  size_t maxBufferSize_; // maximum size of the buffered bus
-  int audio_stream_index_; // index of the audio stream channel in the input
-  SwrContext* swrCtx_;
-  uint8_t** resampledData_; // weird ffmpeg way of using raw byte pointers for resampled data
+  size_t bufferedBusSize_;                // size of currently buffered bus
+  int audio_stream_index_;                // index of the audio stream channel in the input
   int maxResampledSamples_;
-  std::mutex mutex_;
+  size_t processedSamples_;
+
   std::thread streamingThread_;
-  std::atomic<bool> streamFlag; // Flag to control the streaming thread
-  static constexpr float BUFFER_LENGTH_SECONDS = 5.0f; // Length of the buffer in seconds
+  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_;
 
   /**
    * @brief Setting up the resampler
@@ -81,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
@@ -100,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
@@ -113,6 +149,6 @@ class StreamerNode : public AudioScheduledSourceNode {
    * @return true if successful, false otherwise
    */
   bool setupDecoder();
-  #endif // AUDIO_API_TEST_SUITE
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 };
 } // 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/AudioFileWriter.cpp

@@ -0,0 +1,41 @@
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+AudioFileWriter::AudioFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry), fileProperties_(fileProperties) {}
+
+void AudioFileWriter::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioFileWriter::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+void AudioFileWriter::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
+  // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
+  // TL;DR: atomic szpont
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+bool AudioFileWriter::isFileOpen() {
+  return isFileOpen_.load(std::memory_order_acquire);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+typedef Result<std::string, std::string> OpenFileResult;
+typedef Result<std::tuple<double, double>, std::string> CloseFileResult;
+
+class AudioFileWriter {
+ public:
+  AudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  virtual ~AudioFileWriter() = default;
+
+  virtual CloseFileResult closeFile() = 0;
+
+  virtual std::string getFilePath() const = 0;
+  virtual double getCurrentDuration() const = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  bool isFileOpen();
+
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<size_t> framesWritten_{0};
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+};
+
+} // namespace audioapi

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

@@ -1,8 +1,13 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/effects/DelayNode.h>
 #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 {
 
@@ -116,8 +121,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;
@@ -126,8 +130,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;
@@ -147,8 +150,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));
@@ -196,8 +198,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);
@@ -214,20 +215,20 @@ 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());
+    return node.use_count() == 1 && (node->isUnscheduled() || node->isFinished());
+  } else if (node->requiresTailProcessing()) {
+    // if the node requires tail processing, its own implementation handles disabling it at the right time
+    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;
   }
@@ -279,14 +280,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();
   }