react-native-audio-api 0.11.0-nightly-6ba0571-20251209 → 0.11.0-nightly-c0ffb48-20251211

package/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp

@@ -10,9 +10,7 @@
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
-#ifndef AUDIO_API_TEST_SUITE
 #include <android/log.h>
-#endif // AUDIO_API_TEST_SUITE
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
@@ -31,7 +29,6 @@ std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outpu
   std::vector<float> temp(CHUNK_SIZE * outputChannels);
   ma_uint64 outFramesRead = 0;
 
-#ifndef AUDIO_API_TEST_SUITE
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
     ma_decoder_read_pcm_frames(&decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
@@ -46,8 +43,6 @@ std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outpu
   if (outFramesRead == 0) {
     __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
   }
-#endif
-  return buffer;
 }
 
 std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
@@ -73,7 +68,6 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
 std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
     const std::string &path,
     float sampleRate) {
-#ifndef AUDIO_API_TEST_SUITE
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
     auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
@@ -116,14 +110,10 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
   return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
-#else
-  return nullptr;
-#endif
 }
 
 std::shared_ptr<AudioBuffer>
 AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleRate) {
-#ifndef AUDIO_API_TEST_SUITE
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
   if (format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
@@ -161,9 +151,6 @@ AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleR
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
   return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
-#else
-  return nullptr;
-#endif
 }
 
 std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(

package/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp

@@ -103,7 +103,7 @@ void BiquadFilterNode::getFrequencyResponse(
     float *magResponseOutput,
     float *phaseResponseOutput,
     const size_t length) {
-#ifndef AUDIO_API_TEST_SUITE
+#if !RN_AUDIO_API_TEST
   applyFilter();
 #endif
 

package/common/cpp/audioapi/core/effects/BiquadFilterNode.h

@@ -31,9 +31,9 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/types/BiquadFilterType.h>
-#ifdef AUDIO_API_TEST_SUITE
+#if RN_AUDIO_API_TEST
 #include <gtest/gtest_prod.h>
-#endif
+#endif // RN_AUDIO_API_TEST
 
 #include <algorithm>
 #include <cmath>
@@ -48,10 +48,10 @@ namespace audioapi {
 class AudioBus;
 
 class BiquadFilterNode : public AudioNode {
-#ifdef AUDIO_API_TEST_SUITE
+#if RN_AUDIO_API_TEST
   friend class BiquadFilterTest;
   FRIEND_TEST(BiquadFilterTest, GetFrequencyResponse);
-#endif
+#endif // RN_AUDIO_API_TEST
 
  public:
   explicit BiquadFilterNode(BaseAudioContext *context);

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

@@ -8,7 +8,7 @@
 
 #if !RN_AUDIO_API_TEST
 #include <audioapi/core/AudioContext.h>
-#endif
+#endif // RN_AUDIO_API_TEST
 
 #include <algorithm>
 #include <limits>
@@ -30,7 +30,7 @@ void AudioScheduledSourceNode::start(double when) {
   if (auto context = dynamic_cast<AudioContext *>(context_)) {
     context->start();
   }
-#endif
+#endif // RN_AUDIO_API_TEST
 
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;

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

@@ -294,6 +294,7 @@ bool StreamerNode::setupDecoder() {
 
 void StreamerNode::cleanup() {
   this->playbackState_ = PlaybackState::FINISHED;
+  isNodeFinished_.store(true, std::memory_order_release);
   if (streamingThread_.joinable()) {
     StreamingData dummy;
     while (receiver_.try_receive(dummy) == channels::spsc::ResponseStatus::SUCCESS)

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

@@ -24,19 +24,17 @@ extern "C" {
 }
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
+#include <audioapi/utils/SpscChannel.hpp>
 #include <atomic>
 #include <cmath>
 #include <memory>
 #include <string>
 #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;

package/common/cpp/audioapi/utils/AlignedAllocator.hpp

@@ -2,49 +2,52 @@
 #include <cstddef>
 #include <new>
 
-template<typename T, std::size_t Align = 16>
+template <typename T, std::size_t Align = 16>
 class AlignedAllocator {
-public:
+ public:
   using value_type = T;
   using size_type = std::size_t;
   using difference_type = std::ptrdiff_t;
 
   AlignedAllocator() noexcept = default;
-  template<class U> AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept {}
+  template <class U>
+  AlignedAllocator(const AlignedAllocator<U, Align> &) noexcept {}
 
-  T* allocate(std::size_t n) {
+  T *allocate(std::size_t n) {
     // We want to maximize performance on hot paths, so we hint unlikely branches
-    if (n == 0) [[ unlikely ]] {
+    if (n == 0) [[unlikely]] {
       return nullptr;
     }
     std::size_t bytes = n * sizeof(T);
     // C++17 aligned new
-    void* p = ::operator new(bytes, std::align_val_t(Align));
+    void *p = ::operator new(bytes, std::align_val_t(Align));
 
     // We have more serious problems if this happens than speed concerns
     // so we can opt the branch prediction
-    if (!p) [[ unlikely ]] {
+    if (!p) [[unlikely]] {
       throw std::bad_alloc();
     }
-    return static_cast<T*>(p);
+    return static_cast<T *>(p);
   }
 
-  void deallocate(T* p, std::size_t) noexcept {
-      ::operator delete(p, std::align_val_t(Align));
+  void deallocate(T *p, std::size_t) noexcept {
+    ::operator delete(p, std::align_val_t(Align));
   }
 
   // Rebind allocator to type U (required by std::vector)
-  template<class U>
-  struct rebind { using other = AlignedAllocator<U, Align>; };
+  template <class U>
+  struct rebind {
+    using other = AlignedAllocator<U, Align>;
+  };
 
   // Comparison operators (required by std::vector)
-  template<typename U, std::size_t UAlign>
-  bool operator==(const AlignedAllocator<U, UAlign>&) const noexcept {
+  template <typename U, std::size_t UAlign>
+  bool operator==(const AlignedAllocator<U, UAlign> &) const noexcept {
     return Align == UAlign;
   }
 
-  template<typename U, std::size_t UAlign>
-  bool operator!=(const AlignedAllocator<U, UAlign>&) const noexcept {
+  template <typename U, std::size_t UAlign>
+  bool operator!=(const AlignedAllocator<U, UAlign> &) const noexcept {
     return Align != UAlign;
   }
 };

package/common/cpp/audioapi/utils/Benchmark.hpp

@@ -1,8 +1,11 @@
 #pragma once
 
-/// Benchmarking utilities
+// Benchmarking utilities
 #include <chrono>
+#include <cstdio>
+#include <string>
 #include <unordered_map>
+#include <utility>
 
 #ifdef ANDROID
 #include <android/log.h>
@@ -10,49 +13,49 @@
 
 namespace audioapi::benchmarks {
 
-    /// @brief Gets the execution time of a function
-    /// @tparam Func The type of the function to benchmark
-    /// @param func The function to benchmark
-    /// @return The duration of the function execution in nanoseconds
-    /// @note This function is safe to use across threads
-    template <typename Func>
-    double getExecutionTime(Func&& func) {
-        auto start = std::chrono::high_resolution_clock::now();
-        std::forward<Func>(func)();
-        auto end = std::chrono::high_resolution_clock::now();
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
-    }
-
-    /// @brief Logs the average execution time of a function
-    /// @tparam Func The type of the function to benchmark
-    /// @param msg The message to log
-    /// @param func The function to benchmark
-    /// @return The duration of the function execution in nanoseconds
-    /// @note This function should not be used in production
-    /// @note This function is not thread-safe and should be used preferably once in a codebase when you need to measure performance
-    template <typename Func>
-    double logAvgExecutionTime(const std::string& msg, Func&& func) {
-        double duration = getExecutionTime(std::forward<Func>(func));
-
-        static std::unordered_map<std::string, double> durationsSum;
-        static std::unordered_map<std::string, int> durationsCount;
-
-        // Ensure initialization for first time
-        if (durationsSum.find(msg) == durationsSum.end()) {
-            durationsSum[msg] = 0.0;
-            durationsCount[msg] = 0;
-        }
-
-        durationsSum[msg] += duration;
-        durationsCount[msg]++;
-
-        long long avgDuration = static_cast<long long>(durationsSum[msg] / durationsCount[msg]);
-
-        #ifdef ANDROID
-            __android_log_print(ANDROID_LOG_INFO, "AudioAPI", "%s: %lld ns", msg.c_str(), avgDuration);
-        #else
-            printf("%s: %lld ns\n", msg.c_str(), avgDuration);
-        #endif
-        return duration;
-    }
-}
+/// @brief Gets the execution time of a function
+/// @tparam Func The type of the function to benchmark
+/// @param func The function to benchmark
+/// @return The duration of the function execution in nanoseconds
+/// @note This function is safe to use across threads
+template <typename Func>
+double getExecutionTime(Func &&func) {
+  auto start = std::chrono::high_resolution_clock::now();
+  std::forward<Func>(func)();
+  auto end = std::chrono::high_resolution_clock::now();
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
+}
+
+/// @brief Logs the average execution time of a function
+/// @tparam Func The type of the function to benchmark
+/// @param msg The message to log
+/// @param func The function to benchmark
+/// @return The duration of the function execution in nanoseconds
+/// @note This function should not be used in production
+/// @note This function is not thread-safe and should be used preferably once in a codebase when you need to measure performance
+template <typename Func>
+double logAvgExecutionTime(const std::string &msg, Func &&func) {
+  double duration = getExecutionTime(std::forward<Func>(func));
+
+  static std::unordered_map<std::string, double> durationsSum;
+  static std::unordered_map<std::string, int> durationsCount;
+
+  // Ensure initialization for first time
+  if (durationsSum.find(msg) == durationsSum.end()) {
+    durationsSum[msg] = 0.0;
+    durationsCount[msg] = 0;
+  }
+
+  durationsSum[msg] += duration;
+  durationsCount[msg]++;
+
+  int64_t avgDuration = static_cast<int64_t>(durationsSum[msg] / durationsCount[msg]);
+
+#ifdef ANDROID
+  __android_log_print(ANDROID_LOG_INFO, "AudioAPI", "%s: %lld ns", msg.c_str(), avgDuration);
+#else
+  printf("%s: %lld ns\n", msg.c_str(), avgDuration);
+#endif
+  return duration;
+}
+} // namespace audioapi::benchmarks

package/common/cpp/audioapi/utils/CrossThreadEventScheduler.hpp

@@ -2,8 +2,9 @@
 
 #include <audioapi/utils/SpscChannel.hpp>
 
-#include <type_traits>
 #include <functional>
+#include <type_traits>
+#include <utility>
 
 namespace audioapi {
 using namespace channels::spsc;
@@ -27,32 +28,34 @@ template <typename T>
 class CrossThreadEventScheduler {
  public:
   explicit CrossThreadEventScheduler(size_t capacity) {
-    auto [sender, receiver] = channel<std::function<void(T&)>>(capacity);
+    auto [sender, receiver] = channel<std::function<void(T &)>>(capacity);
     eventSender_ = std::move(sender);
     eventReceiver_ = std::move(receiver);
   }
-  CrossThreadEventScheduler(const CrossThreadEventScheduler&) = delete;
-  CrossThreadEventScheduler& operator=(const CrossThreadEventScheduler&) = delete;
+  CrossThreadEventScheduler(const CrossThreadEventScheduler &) = delete;
+  CrossThreadEventScheduler &operator=(const CrossThreadEventScheduler &) = delete;
 
   /// @brief Schedules an event to be processed on the audio thread.
   /// @param event The event to schedule.
   /// @return True if the event was successfully scheduled, false if the queue is full.
-  bool scheduleEvent(std::function<void(T&)> &&event) noexcept(noexcept(eventSender_.try_send(std::move(event)))) {
+  bool scheduleEvent(std::function<void(T &)> &&event) noexcept(
+      noexcept(eventSender_.try_send(std::move(event)))) {
     return eventSender_.try_send(std::move(event)) == ResponseStatus::SUCCESS;
   }
 
   /// @brief Processes all scheduled events.
   /// @param data The data to pass to each event.
-  void processAllEvents(T& data) noexcept(noexcept(eventReceiver_.try_receive(std::declval<std::function<void(T&)>&>()))) {
-    std::function<void(T&)> event;
+  void processAllEvents(T &data) noexcept(
+      noexcept(eventReceiver_.try_receive(std::declval<std::function<void(T &)> &>()))) {
+    std::function<void(T &)> event;
     while (eventReceiver_.try_receive(event) == ResponseStatus::SUCCESS) {
       event(data);
     }
   }
 
  private:
-  Sender<std::function<void(T&)>> eventSender_;
-  Receiver<std::function<void(T&)>> eventReceiver_;
+  Sender<std::function<void(T &)>> eventSender_;
+  Receiver<std::function<void(T &)>> eventReceiver_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/MoveOnlyFunction.hpp

@@ -1,12 +1,14 @@
 #pragma once
 #include <functional>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
 /// @brief A forward declaration of a move-only function wrapper.
 /// @note it is somehow required to have <R(Args...)> specialization below
 /// @tparam Signature
-template<typename Signature>
+template <typename Signature>
 class move_only_function; // Forward declaration
 
 /// @brief A move-only function wrapper similar to std::function but non-copyable.
@@ -18,7 +20,7 @@ class move_only_function; // Forward declaration
 /// @note IMPORTANT: This thing is implemented in C++23 standard and can be replaced with std::move_only_function once we switch to C++23.
 /// @tparam R
 /// @tparam ...Args
-template<typename R, typename... Args>
+template <typename R, typename... Args>
 class move_only_function<R(Args...)> {
   /// @brief The base class for type erasure.
   /// @note It gets optimized by Empty Base Optimization (EBO) when possible.
@@ -29,7 +31,7 @@ class move_only_function<R(Args...)> {
 
   /// @brief The implementation of the callable object.
   /// @tparam F
-  template<typename F>
+  template <typename F>
   struct callable_impl : callable_base {
     /// @brief The stored callable object.
     F f;
@@ -38,8 +40,8 @@ class move_only_function<R(Args...)> {
     /// @tparam G
     /// @param func
     /// @note The enable_if_t ensures that F can be constructed from G&&.
-    template<typename G, typename = std::enable_if_t<std::is_constructible_v<F, G&&>>>
-    callable_impl(G&& func) : f(std::forward<G>(func)) {}
+    template <typename G, typename = std::enable_if_t<std::is_constructible_v<F, G &&>>>
+    explicit callable_impl(G &&func) : f(std::forward<G>(func)) {}
 
     /// @brief Invoke the stored callable object with the given arguments.
     /// @param args
@@ -58,19 +60,19 @@ class move_only_function<R(Args...)> {
   /// @brief The unique pointer to the base callable type.
   std::unique_ptr<callable_base> impl_;
 
-public:
+ public:
   move_only_function() = default;
   move_only_function(std::nullptr_t) noexcept : impl_(nullptr) {}
 
-  template<typename F>
-  move_only_function(F&& f)
-    : impl_(std::make_unique<callable_impl<std::decay_t<F>>>(std::forward<F>(f))) {}
+  template <typename F>
+  move_only_function(F &&f)
+      : impl_(std::make_unique<callable_impl<std::decay_t<F>>>(std::forward<F>(f))) {}
 
-  move_only_function(const move_only_function&) = delete;
-  move_only_function& operator=(const move_only_function&) = delete;
+  move_only_function(const move_only_function &) = delete;
+  move_only_function &operator=(const move_only_function &) = delete;
 
-  move_only_function(move_only_function&&) = default;
-  move_only_function& operator=(move_only_function&&) = default;
+  move_only_function(move_only_function &&) = default;
+  move_only_function &operator=(move_only_function &&) = default;
 
   inline explicit operator bool() const noexcept {
     return impl_ != nullptr;
@@ -78,13 +80,13 @@ public:
 
   inline R operator()(Args... args) {
     /// We are unlikely to hit this case as we want to optimize for the common case.
-    if (impl_ == nullptr) [[ unlikely ]] {
+    if (impl_ == nullptr) [[unlikely]] {
       throw std::bad_function_call{};
     }
     return (*impl_)(std::forward<Args>(args)...);
   }
 
-  void swap(move_only_function& other) noexcept {
+  void swap(move_only_function &other) noexcept {
     impl_.swap(other.impl_);
   }
 };

package/common/cpp/audioapi/utils/RingBiDirectionalBuffer.hpp

@@ -3,6 +3,7 @@
 #include <bit>
 #include <memory>
 #include <type_traits>
+#include <utility>
 
 namespace audioapi {
 
@@ -16,15 +17,10 @@ template <typename T, size_t capacity_>
 class RingBiDirectionalBuffer {
  public:
   /// @brief Constructor for RingBuffer.
-  RingBiDirectionalBuffer()
-    : headIndex_(0), tailIndex_(0) {
+  RingBiDirectionalBuffer() : headIndex_(0), tailIndex_(0) {
     static_assert(isPowerOfTwo(capacity_), "RingBiDirectionalBuffer's capacity must be power of 2");
-    buffer_ = static_cast<T*>(
-      ::operator new[](
-        capacity_ * sizeof(T),
-        static_cast<std::align_val_t>(alignof(T))
-      )
-    );
+    buffer_ = static_cast<T *>(
+        ::operator new[](capacity_ * sizeof(T), static_cast<std::align_val_t>(alignof(T))));
   }
 
   /// @brief Destructor for RingBuffer.
@@ -32,11 +28,7 @@ class RingBiDirectionalBuffer {
     for (int i = headIndex_; i != tailIndex_; i = nextIndex(i)) {
       buffer_[i].~T();
     }
-    ::operator delete[](
-      buffer_,
-      capacity_ * sizeof(T),
-      static_cast<std::align_val_t>(alignof(T))
-    );
+    ::operator delete[](buffer_, capacity_ * sizeof(T), static_cast<std::align_val_t>(alignof(T)));
   }
 
   /// @brief Push a value into the ring buffer.
@@ -44,8 +36,8 @@ class RingBiDirectionalBuffer {
   /// @param value The value to push.
   /// @return True if the value was pushed successfully, false if the buffer is full.
   template <typename U>
-  bool pushBack(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
-    if (isFull()) [[ unlikely ]] {
+  bool pushBack(U &&value) noexcept(std::is_nothrow_constructible_v<T, U &&>) {
+    if (isFull()) [[unlikely]] {
       return false;
     }
     new (&buffer_[tailIndex_]) T(std::forward<U>(value));
@@ -58,8 +50,8 @@ class RingBiDirectionalBuffer {
   /// @param value The value to push.
   /// @return True if the value was pushed successfully, false if the buffer is full.
   template <typename U>
-  bool pushFront(U&& value) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
-    if (isFull()) [[ unlikely ]] {
+  bool pushFront(U &&value) noexcept(std::is_nothrow_constructible_v<T, U &&>) {
+    if (isFull()) [[unlikely]] {
       return false;
     }
     headIndex_ = prevIndex(headIndex_);
@@ -70,8 +62,9 @@ class RingBiDirectionalBuffer {
   /// @brief Pop a value from the front of the buffer.
   /// @param out The value popped from the buffer.
   /// @return True if the value was popped successfully, false if the buffer is empty.
-  bool popFront(T& out) noexcept(std::is_nothrow_move_constructible_v<T> && std::is_nothrow_destructible_v<T>) {
-    if (isEmpty()) [[ unlikely ]] {
+  bool popFront(T &out) noexcept(
+      std::is_nothrow_move_constructible_v<T> && std::is_nothrow_destructible_v<T>) {
+    if (isEmpty()) [[unlikely]] {
       return false;
     }
     out = std::move(buffer_[headIndex_]);
@@ -83,7 +76,7 @@ class RingBiDirectionalBuffer {
   /// @brief Pop a value from the front of the buffer.
   /// @return True if the value was popped successfully, false if the buffer is empty.
   bool popFront() noexcept(std::is_nothrow_destructible_v<T>) {
-    if (isEmpty()) [[ unlikely ]] {
+    if (isEmpty()) [[unlikely]] {
       return false;
     }
     buffer_[headIndex_].~T();
@@ -94,8 +87,9 @@ class RingBiDirectionalBuffer {
   /// @brief Pop a value from the back of the buffer.
   /// @param out The value popped from the buffer.
   /// @return True if the value was popped successfully, false if the buffer is empty.
-  bool popBack(T& out) noexcept(std::is_nothrow_move_constructible_v<T> && std::is_nothrow_destructible_v<T>) {
-    if (isEmpty()) [[ unlikely ]] {
+  bool popBack(T &out) noexcept(
+      std::is_nothrow_move_constructible_v<T> && std::is_nothrow_destructible_v<T>) {
+    if (isEmpty()) [[unlikely]] {
       return false;
     }
     tailIndex_ = prevIndex(tailIndex_);
@@ -107,7 +101,7 @@ class RingBiDirectionalBuffer {
   /// @brief Pop a value from the back of the buffer.
   /// @return True if the value was popped successfully, false if the buffer is empty.
   bool popBack() noexcept(std::is_nothrow_destructible_v<T>) {
-    if (isEmpty()) [[ unlikely ]] {
+    if (isEmpty()) [[unlikely]] {
       return false;
     }
     tailIndex_ = prevIndex(tailIndex_);
@@ -117,25 +111,25 @@ class RingBiDirectionalBuffer {
 
   /// @brief Peek at the front of the buffer.
   /// @return A const reference to the front element of the buffer.
-  const inline T& peekFront() const noexcept {
+  const inline T &peekFront() const noexcept {
     return buffer_[headIndex_];
   }
 
   /// @brief Peek at the back of the buffer.
   /// @return A const reference to the back element of the buffer.
-  const inline T& peekBack() const noexcept {
+  const inline T &peekBack() const noexcept {
     return buffer_[prevIndex(tailIndex_)];
   }
 
   /// @brief Peek at the front of the buffer.
   /// @return A mutable reference to the front element of the buffer.
-  inline T& peekFrontMut() noexcept {
+  inline T &peekFrontMut() noexcept {
     return buffer_[headIndex_];
   }
 
   /// @brief Peek at the back of the buffer.
   /// @return A mutable reference to the back element of the buffer.
-  inline T& peekBackMut() noexcept {
+  inline T &peekBackMut() noexcept {
     return buffer_[prevIndex(tailIndex_)];
   }
 
@@ -196,4 +190,4 @@ class RingBiDirectionalBuffer {
   }
 };
 
-};
+}; // namespace audioapi