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

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -5,6 +5,7 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 
@@ -23,8 +24,7 @@ class ConstantSourceTest : public ::testing::Test {
 
 class TestableConstantSourceNode : public ConstantSourceNode {
  public:
-  explicit TestableConstantSourceNode(BaseAudioContext *context)
-      : ConstantSourceNode(context) {}
+  explicit TestableConstantSourceNode(BaseAudioContext *context) : ConstantSourceNode(context) {}
 
   void setOffsetParam(float value) {
     getOffsetParam()->setValue(value);
@@ -45,10 +45,8 @@ TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
 TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
   static constexpr int FRAMES_TO_PROCESS = 4;
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
-  auto constantSource =
-      std::make_shared<TestableConstantSourceNode>(context.get());
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto constantSource = std::make_shared<TestableConstantSourceNode>(context.get());
   constantSource->start(context->getCurrentTime());
   auto resultBus = constantSource->processNode(bus, FRAMES_TO_PROCESS);
 

package/common/cpp/test/src/GainTest.cpp

@@ -5,6 +5,7 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 
@@ -47,8 +48,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     bus->getChannel(0)->getData()[i] = i + 1;
   }
@@ -65,8 +65,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     bus->getChannel(0)->getData()[i] = i + 1;
     bus->getChannel(1)->getData()[i] = -i - 1;

package/common/cpp/test/src/MockAudioEventHandlerRegistry.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <gmock/gmock.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
-#include <unordered_map>
-#include <string>
+#include <gmock/gmock.h>
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 using namespace audioapi;
 
@@ -12,13 +12,21 @@ using EventMap = std::unordered_map<std::string, EventValue>;
 
 class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
-  MOCK_METHOD(uint64_t, registerHandler,
-              (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler), (override));
-  MOCK_METHOD(void, unregisterHandler,
-              (const std::string &eventName, uint64_t listenerId), (override));
+  MOCK_METHOD(
+      uint64_t,
+      registerHandler,
+      (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler),
+      (override));
+  MOCK_METHOD(
+      void,
+      unregisterHandler,
+      (const std::string &eventName, uint64_t listenerId),
+      (override));
 
-  MOCK_METHOD2(invokeHandlerWithEventBody, void
-              (const std::string &eventName, const EventMap &body));
-  MOCK_METHOD3(invokeHandlerWithEventBody, void
-              (const std::string &eventName, uint64_t listenerId, const EventMap &body));
+  MOCK_METHOD2(
+      invokeHandlerWithEventBody,
+      void(const std::string &eventName, const EventMap &body));
+  MOCK_METHOD3(
+      invokeHandlerWithEventBody,
+      void(const std::string &eventName, uint64_t listenerId, const EventMap &body));
 };

package/common/cpp/test/src/OscillatorTest.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 

package/common/cpp/test/src/StereoPannerTest.cpp

@@ -5,6 +5,7 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 
@@ -23,8 +24,7 @@ class StereoPannerTest : public ::testing::Test {
 
 class TestableStereoPannerNode : public StereoPannerNode {
  public:
-  explicit TestableStereoPannerNode(BaseAudioContext *context)
-      : StereoPannerNode(context) {}
+  explicit TestableStereoPannerNode(BaseAudioContext *context) : StereoPannerNode(context) {}
 
   void setPanParam(float value) {
     getPanParam()->setValue(value);
@@ -48,8 +48,7 @@ TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
   }
@@ -76,8 +75,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
     (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;
@@ -105,8 +103,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
     (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;

package/common/cpp/test/src/biquad/BiquadFilterChromium.cpp

@@ -86,32 +86,22 @@ void getFrequencyResponse(
       phase_response[k] = std::nanf("");
     } else {
       double omega = -PI * normalizedFreq[k];
-      std::complex<double> z =
-          std::complex<double>(std::cos(omega), std::sin(omega));
+      std::complex<double> z = std::complex<double>(std::cos(omega), std::sin(omega));
       std::complex<double> numerator = b0 + (b1 + b2 * z) * z;
-      std::complex<double> denominator =
-          std::complex<double>(1, 0) + (a1 + a2 * z) * z;
+      std::complex<double> denominator = std::complex<double>(1, 0) + (a1 + a2 * z) * z;
       std::complex<double> response = numerator / denominator;
       mag_response[k] = static_cast<float>(abs(response));
-      phase_response[k] =
-          static_cast<float>(std::atan2(imag(response), real(response)));
+      phase_response[k] = static_cast<float>(std::atan2(imag(response), real(response)));
     }
   }
 }
 
-BiquadCoefficients normalizeCoefficients(
-    double b0,
-    double b1,
-    double b2,
-    double a0,
-    double a1,
-    double a2) {
+BiquadCoefficients
+normalizeCoefficients(double b0, double b1, double b2, double a0, double a1, double a2) {
   return BiquadCoefficients{b0 / a0, b1 / a0, b2 / a0, a1 / a0, a2 / a0};
 }
 
-BiquadCoefficients calculateLowpassCoefficients(
-    double cutoff,
-    double resonance) {
+BiquadCoefficients calculateLowpassCoefficients(double cutoff, double resonance) {
   // Limit cutoff to 0 to 1.
   cutoff = std::clamp(cutoff, 0.0, 1.0);
 
@@ -144,9 +134,7 @@ BiquadCoefficients calculateLowpassCoefficients(
   }
 }
 
-BiquadCoefficients calculateHighpassCoefficients(
-    double cutoff,
-    double resonance) {
+BiquadCoefficients calculateHighpassCoefficients(double cutoff, double resonance) {
   // Limit cutoff to 0 to 1.
   cutoff = std::clamp(cutoff, 0.0, 1.0);
 
@@ -180,9 +168,7 @@ BiquadCoefficients calculateHighpassCoefficients(
   }
 }
 
-BiquadCoefficients calculateLowshelfCoefficients(
-    double frequency,
-    double db_gain) {
+BiquadCoefficients calculateLowshelfCoefficients(double frequency, double db_gain) {
   // Clip frequencies to between 0 and 1, inclusive.
   frequency = std::clamp(frequency, 0.0, 1.0);
 
@@ -214,9 +200,7 @@ BiquadCoefficients calculateLowshelfCoefficients(
   }
 }
 
-BiquadCoefficients calculateHighshelfCoefficients(
-    double frequency,
-    double db_gain) {
+BiquadCoefficients calculateHighshelfCoefficients(double frequency, double db_gain) {
   // Clip frequencies to between 0 and 1, inclusive.
   frequency = std::clamp(frequency, 0.0, 1.0);
 
@@ -248,8 +232,7 @@ BiquadCoefficients calculateHighshelfCoefficients(
   }
 }
 
-BiquadCoefficients
-calculatePeakingCoefficients(double frequency, double q, double db_gain) {
+BiquadCoefficients calculatePeakingCoefficients(double frequency, double q, double db_gain) {
   // Clip frequencies to between 0 and 1, inclusive.
   frequency = std::clamp(frequency, 0.0, 1.0);
 

package/common/cpp/test/src/biquad/BiquadFilterChromium.h

@@ -44,13 +44,14 @@ struct BiquadCoefficients {
 };
 
 void getFrequencyResponse(
-const BiquadCoefficients &coeffs,
-std::span<const float> frequency,
-std::span<float> mag_response,
-std::span<float> phase_response,
-float nyquistFrequency);
+    const BiquadCoefficients &coeffs,
+    std::span<const float> frequency,
+    std::span<float> mag_response,
+    std::span<float> phase_response,
+    float nyquistFrequency);
 
-BiquadCoefficients normalizeCoefficients(double b0, double b1, double b2, double a0, double a1, double a2);
+BiquadCoefficients
+normalizeCoefficients(double b0, double b1, double b2, double a0, double a1, double a2);
 
 BiquadCoefficients calculateLowpassCoefficients(double cutoff, double Q);
 BiquadCoefficients calculateHighpassCoefficients(double cutoff, double Q);

package/common/cpp/test/src/biquad/BiquadFilterTest.cpp

@@ -1,5 +1,7 @@
 #include <test/src/biquad/BiquadFilterChromium.h>
 #include <test/src/biquad/BiquadFilterTest.h>
+#include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -18,8 +20,7 @@ void BiquadFilterTest::testLowpass(float frequency, float Q) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setLowpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateLowpassCoefficients(normalizedFrequency, Q));
+  expectCoefficientsNear(node, calculateLowpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testHighpass(float frequency, float Q) {
@@ -27,8 +28,7 @@ void BiquadFilterTest::testHighpass(float frequency, float Q) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setHighpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateHighpassCoefficients(normalizedFrequency, Q));
+  expectCoefficientsNear(node, calculateHighpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testBandpass(float frequency, float Q) {
@@ -36,8 +36,7 @@ void BiquadFilterTest::testBandpass(float frequency, float Q) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setBandpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateBandpassCoefficients(normalizedFrequency, Q));
+  expectCoefficientsNear(node, calculateBandpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testNotch(float frequency, float Q) {
@@ -45,8 +44,7 @@ void BiquadFilterTest::testNotch(float frequency, float Q) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setNotchCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateNotchCoefficients(normalizedFrequency, Q));
+  expectCoefficientsNear(node, calculateNotchCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testAllpass(float frequency, float Q) {
@@ -54,8 +52,7 @@ void BiquadFilterTest::testAllpass(float frequency, float Q) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setAllpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateAllpassCoefficients(normalizedFrequency, Q));
+  expectCoefficientsNear(node, calculateAllpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
@@ -63,8 +60,7 @@ void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setPeakingCoefficients(normalizedFrequency, Q, gain);
-  expectCoefficientsNear(
-      node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
+  expectCoefficientsNear(node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
 }
 
 void BiquadFilterTest::testLowshelf(float frequency, float gain) {
@@ -72,8 +68,7 @@ void BiquadFilterTest::testLowshelf(float frequency, float gain) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setLowshelfCoefficients(normalizedFrequency, gain);
-  expectCoefficientsNear(
-      node, calculateLowshelfCoefficients(normalizedFrequency, gain));
+  expectCoefficientsNear(node, calculateLowshelfCoefficients(normalizedFrequency, gain));
 }
 
 void BiquadFilterTest::testHighshelf(float frequency, float gain) {
@@ -81,17 +76,16 @@ void BiquadFilterTest::testHighshelf(float frequency, float gain) {
   float normalizedFrequency = frequency / nyquistFrequency;
 
   node->setHighshelfCoefficients(normalizedFrequency, gain);
-  expectCoefficientsNear(
-      node, calculateHighshelfCoefficients(normalizedFrequency, gain));
+  expectCoefficientsNear(node, calculateHighshelfCoefficients(normalizedFrequency, gain));
 }
 
 INSTANTIATE_TEST_SUITE_P(
     Frequencies,
     BiquadFilterFrequencyTest,
     ::testing::Values(
-        0.0f,   // 0 Hz - the filter should block all input signal
-        10.0f,  // very low frequency
-        350.0f, // default
+        0.0f,                       // 0 Hz - the filter should block all input signal
+        10.0f,                      // very low frequency
+        350.0f,                     // default
         nyquistFrequency - 0.0001f, // frequency near Nyquist
         nyquistFrequency));         // maximal frequency
 
@@ -255,25 +249,19 @@ TEST_F(BiquadFilterTest, GetFrequencyResponse) {
       phaseResponseNode.data(),
       TestFrequencies.size());
   getFrequencyResponse(
-      coeffs,
-      TestFrequencies,
-      magResponseExpected,
-      phaseResponseExpected,
-      nyquistFrequency);
+      coeffs, TestFrequencies, magResponseExpected, phaseResponseExpected, nyquistFrequency);
 
   for (size_t i = 0; i < TestFrequencies.size(); ++i) {
     float f = TestFrequencies[i];
     if (std::isnan(magResponseExpected[i])) {
-      EXPECT_TRUE(std::isnan(magResponseNode[i]))
-          << "Expected NaN at frequency " << f;
+      EXPECT_TRUE(std::isnan(magResponseNode[i])) << "Expected NaN at frequency " << f;
     } else {
       EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
           << "Magnitude mismatch at " << f << " Hz";
     }
 
     if (std::isnan(phaseResponseExpected[i])) {
-      EXPECT_TRUE(std::isnan(phaseResponseNode[i]))
-          << "Expected NaN at frequency " << f;
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i])) << "Expected NaN at frequency " << f;
     } else {
       EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
           << "Phase mismatch at " << f << " Hz";

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -19,10 +19,13 @@ class BiquadFilterTest : public ::testing::Test {
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 
-  void expectCoefficientsNear(const std::shared_ptr<BiquadFilterNode> &node, const BiquadCoefficients &expected);
+  void expectCoefficientsNear(
+      const std::shared_ptr<BiquadFilterNode> &node,
+      const BiquadCoefficients &expected);
   void testLowpass(float frequency, float Q);
   void testHighpass(float frequency, float Q);
   void testBandpass(float frequency, float Q);
@@ -33,8 +36,12 @@ class BiquadFilterTest : public ::testing::Test {
   void testHighshelf(float frequency, float gain);
 };
 
-class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterQTestRestTypes : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterFrequencyTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterGainTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest,
+                                         public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestRestTypes : public BiquadFilterTest,
+                                   public ::testing::WithParamInterface<float> {};
+class BiquadFilterFrequencyTest : public BiquadFilterTest,
+                                  public ::testing::WithParamInterface<float> {};
+class BiquadFilterGainTest : public BiquadFilterTest,
+                             public ::testing::WithParamInterface<float> {};
 } // namespace audioapi

package/ios/audioapi/ios/AudioAPIModule.h

@@ -13,12 +13,11 @@
 @class AudioSessionManager;
 @class LockScreenManager;
 
-@interface AudioAPIModule
-    : RCTEventEmitter
+@interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
-      <NativeAudioAPIModuleSpec, RCTCallInvokerModule, RCTInvalidating>
+                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule, RCTInvalidating>
 #else
-      <RCTBridgeModule>
+                            <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED
 
 @property (nonatomic, strong) AudioEngine *audioEngine;
@@ -26,7 +25,6 @@
 @property (nonatomic, strong) AudioSessionManager *audioSessionManager;
 @property (nonatomic, strong) LockScreenManager *lockScreenManager;
 
-- (void)invokeHandlerWithEventName:(NSString *)eventName
-                         eventBody:(NSDictionary *)eventBody;
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
 
 @end

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -62,15 +62,11 @@ RCT_EXPORT_MODULE(AudioAPIModule);
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
-  self.audioEngine = [[AudioEngine alloc]
-      initWithAudioSessionManager:self.audioSessionManager];
-  self.lockScreenManager =
-      [[LockScreenManager alloc] initWithAudioAPIModule:self];
-  self.notificationManager =
-      [[NotificationManager alloc] initWithAudioAPIModule:self];
+  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
 
-  auto jsiRuntime =
-      reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
+  auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
 #if defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = _callInvoker.callInvoker;
@@ -80,12 +76,10 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 
   assert(jsiRuntime != nullptr);
 
-  _eventHandler =
-      std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
+  _eventHandler = std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
 
 #if RN_AUDIO_API_ENABLE_WORKLETS
-  WorkletsModule *workletsModule =
-      [_moduleRegistry moduleForName:"WorkletsModule"];
+  WorkletsModule *workletsModule = [_moduleRegistry moduleForName:"WorkletsModule"];
 
   if (!workletsModule) {
     NSLog(@"WorkletsModule not found in module registry");
@@ -109,8 +103,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   audioapi::AudioAPIModuleInstaller::injectJSIBindings(
       jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
 #else
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(
-      jsiRuntime, jsCallInvoker, _eventHandler);
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
 #endif
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
@@ -126,22 +119,21 @@ RCT_EXPORT_METHOD(
     setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)
         resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  dispatch_async(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        if (!self.audioSessionManager.shouldManageSession) {
-          [self.audioSessionManager setShouldManageSession:true];
-        }
-        if ([self.audioSessionManager setActive:enabled]) {
-          resolve(@"true");
-          return;
-        }
-        resolve(@"false");
-      });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    if (!self.audioSessionManager.shouldManageSession) {
+      [self.audioSessionManager setShouldManageSession:true];
+    }
+    if ([self.audioSessionManager setActive:enabled]) {
+      resolve(@"true");
+      return;
+    }
+    resolve(@"false");
+  });
 }
 
 RCT_EXPORT_METHOD(
-    setAudioSessionOptions : (NSString *)category mode : (NSString *)
-        mode options : (NSArray *)options allowHaptics : (BOOL)allowHaptics)
+    setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
+        options allowHaptics : (BOOL)allowHaptics)
 {
   if (!self.audioSessionManager.shouldManageSession) {
     [self.audioSessionManager setShouldManageSession:true];
@@ -162,8 +154,7 @@ RCT_EXPORT_METHOD(resetLockScreenInfo)
   [self.lockScreenManager resetLockScreenInfo];
 }
 
-RCT_EXPORT_METHOD(
-    enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
+RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
 {
   [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
 }
@@ -187,31 +178,27 @@ RCT_EXPORT_METHOD(
     requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  dispatch_async(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        [self.audioSessionManager requestRecordingPermissions:resolve
-                                                       reject:reject];
-      });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
     checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  dispatch_async(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        [self.audioSessionManager checkRecordingPermissions:resolve
-                                                     reject:reject];
-      });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
     getDevicesInfo : (nonnull RCTPromiseResolveBlock)
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  dispatch_async(
-      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-      ^{ [self.audioSessionManager getDevicesInfo:resolve reject:reject]; });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(disableSessionManagement)
@@ -227,8 +214,7 @@ RCT_EXPORT_METHOD(disableSessionManagement)
 }
 #endif // RCT_NEW_ARCH_ENABLED
 
-- (void)invokeHandlerWithEventName:(NSString *)eventName
-                         eventBody:(NSDictionary *)eventBody
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody
 {
   auto name = [eventName UTF8String];
 
@@ -262,8 +248,7 @@ RCT_EXPORT_METHOD(disableSessionManagement)
 
 - (dispatch_queue_t)methodQueue
 {
-  return dispatch_queue_create(
-      "swmansion.audioapi.Queue", DISPATCH_QUEUE_SERIAL);
+  return dispatch_queue_create("swmansion.audioapi.Queue", DISPATCH_QUEUE_SERIAL);
 }
 
 @end

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -13,45 +13,36 @@ IOSAudioPlayer::IOSAudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      channelCount_(channelCount),
-      audioBus_(0),
-      isRunning_(false)
+    : renderAudio_(renderAudio), channelCount_(channelCount), audioBus_(0), isRunning_(false)
 {
-  RenderAudioBlock renderAudioBlock =
-      ^(AudioBufferList *outputData, int numFrames) {
-        int processedFrames = 0;
-
-        while (processedFrames < numFrames) {
-          int framesToProcess =
-              std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
-
-          if (isRunning_.load()) {
-            renderAudio_(audioBus_, framesToProcess);
-          } else {
-            audioBus_->zero();
-          }
-
-          for (int channel = 0; channel < channelCount_; channel += 1) {
-            float *outputChannel = (float *)outputData->mBuffers[channel].mData;
-            auto *inputChannel = audioBus_->getChannel(channel)->getData();
-
-            memcpy(
-                outputChannel + processedFrames,
-                inputChannel,
-                framesToProcess * sizeof(float));
-          }
-
-          processedFrames += framesToProcess;
-        }
-      };
+  RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
+    int processedFrames = 0;
+
+    while (processedFrames < numFrames) {
+      int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+
+      if (isRunning_.load()) {
+        renderAudio_(audioBus_, framesToProcess);
+      } else {
+        audioBus_->zero();
+      }
+
+      for (int channel = 0; channel < channelCount_; channel += 1) {
+        float *outputChannel = (float *)outputData->mBuffers[channel].mData;
+        auto *inputChannel = audioBus_->getChannel(channel)->getData();
+
+        memcpy(outputChannel + processedFrames, inputChannel, framesToProcess * sizeof(float));
+      }
+
+      processedFrames += framesToProcess;
+    }
+  };
 
   audioPlayer_ = [[NativeAudioPlayer alloc] initWithRenderAudio:renderAudioBlock
                                                      sampleRate:sampleRate
                                                    channelCount:channelCount_];
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate);
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate);
 }
 
 IOSAudioPlayer::~IOSAudioPlayer()