react-native-audio-api 0.11.0-nightly-010ea11-20251110 → 0.11.0-nightly-141c86f-20251112

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -26,7 +26,7 @@ using namespace worklets;
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 // nothing
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
 @interface RCTBridge (RCTTurboModule)
 - (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
 - (void)_tryAndHandleError:(dispatch_block_t)block;
@@ -62,24 +62,30 @@ 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;
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = self.bridge.jsCallInvoker;
 #endif // defined(RCT_NEW_ARCH_ENABLED)
 
   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");
@@ -100,9 +106,11 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   }
 
   // Get the actual JSI Runtime reference
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
+  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!");
@@ -115,29 +123,33 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 }
 
 RCT_EXPORT_METHOD(
-    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
-        reject)
+    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];
   }
-  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options allowHaptics:allowHaptics];
+  [self.audioSessionManager setAudioSessionOptions:category
+                                              mode:mode
+                                           options:options
+                                      allowHaptics:allowHaptics];
 }
 
 RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
@@ -150,7 +162,8 @@ 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];
 }
@@ -171,28 +184,34 @@ RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
 }
 
 RCT_EXPORT_METHOD(
-    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)
-        reject)
+    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)
+    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)
+    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)
@@ -208,7 +227,8 @@ 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];
 
@@ -242,7 +262,8 @@ 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.h

@@ -2,7 +2,7 @@
 
 #ifdef __OBJC__ // when compiled as Objective-C++
 #import <NativeAudioPlayer.h>
-#else // when compiled as C++
+#else  // when compiled as C++
 typedef struct objc_object NativeAudioPlayer;
 #endif // __OBJC__
 

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

@@ -13,36 +13,45 @@ 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()

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -2,7 +2,7 @@
 
 #ifdef __OBJC__ // when compiled as Objective-C++
 #import <NativeAudioRecorder.h>
-#else // when compiled as C++
+#else  // when compiled as C++
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
@@ -18,7 +18,8 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;
 

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -18,7 +18,8 @@ IOSAudioRecorder::IOSAudioRecorder(
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
     : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
 {
-  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+  AudioReceiverBlock audioReceiverBlock = ^(
+      const AudioBufferList *inputBuffer, int numFrames) {
     if (isRunning_.load()) {
       auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
       writeToBuffers(inputChannel, numFrames);
@@ -34,9 +35,10 @@ IOSAudioRecorder::IOSAudioRecorder(
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  audioRecorder_ =
+      [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
+                                            bufferLength:bufferLength
+                                              sampleRate:sampleRate];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -15,7 +15,10 @@
 
     __weak typeof(self) weakSelf = self;
     self.renderBlock = ^OSStatus(
-        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
+        BOOL *isSilence,
+        const AudioTimeStamp *timestamp,
+        AVAudioFrameCount frameCount,
+        AudioBufferList *outputData) {
       if (outputData->mNumberBuffers != weakSelf.channelCount) {
         return kAudioServicesBadPropertySizeError;
       }
@@ -25,8 +28,11 @@
       return kAudioServicesNoError;
     };
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
+    _format = [[AVAudioFormat alloc]
+        initStandardFormatWithSampleRate:self.sampleRate
+                                channels:self.channelCount];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
+                                                renderBlock:self.renderBlock];
   }
 
   return self;
@@ -39,15 +45,18 @@
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
-  // AudioEngine allows us to attach and connect nodes at runtime but with few limitations
-  // in this case if it is the first player and recorder started the engine we need to restart.
-  // It can be optimized by tracking if we haven't break rules of at runtime modifications from docs
+  // AudioEngine allows us to attach and connect nodes at runtime but with few
+  // limitations in this case if it is the first player and recorder started the
+  // engine we need to restart. It can be optimized by tracking if we haven't
+  // break rules of at runtime modifications from docs
   // https://developer.apple.com/documentation/avfaudio/avaudioengine?language=objc
   //
-  // Currently we are restarting because we do not see any significant performance issue and case when
-  // you will need to start and stop player very frequently
+  // Currently we are restarting because we do not see any significant
+  // performance issue and case when you will need to start and stop player very
+  // frequently
   [audioEngine stopEngine];
-  self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
+  self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode
+                                             format:self.format];
   return [audioEngine startIfNecessary];
 }
 

package/ios/audioapi/ios/core/NativeAudioRecorder.h

@@ -3,7 +3,8 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
-typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFrames);
+typedef void (
+    ^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFrames);
 
 @interface NativeAudioRecorder : NSObject
 

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -14,34 +14,43 @@
 
     self.receiverBlock = [receiverBlock copy];
 
-    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
+    float devicePrefferedSampleRate =
+        [[AVAudioSession sharedInstance] sampleRate];
 
     if (!devicePrefferedSampleRate) {
       NSError *error;
       devicePrefferedSampleRate = sampleRate;
 
-      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
+      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate
+                                                        error:&error];
     }
 
-    self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                        sampleRate:devicePrefferedSampleRate
-                                                          channels:1
-                                                       interleaved:NO];
-    self.outputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                         sampleRate:sampleRate
-                                                           channels:1
-                                                        interleaved:NO];
-    self.audioConverter = [[AVAudioConverter alloc] initFromFormat:self.inputFormat toFormat:self.outputFormat];
+    self.inputFormat =
+        [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                         sampleRate:devicePrefferedSampleRate
+                                           channels:1
+                                        interleaved:NO];
+    self.outputFormat =
+        [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                         sampleRate:sampleRate
+                                           channels:1
+                                        interleaved:NO];
+    self.audioConverter =
+        [[AVAudioConverter alloc] initFromFormat:self.inputFormat
+                                        toFormat:self.outputFormat];
 
     __weak typeof(self) weakSelf = self;
     self.receiverSinkBlock = ^OSStatus(
         const AudioTimeStamp *_Nonnull timestamp,
         AVAudioFrameCount frameCount,
         const AudioBufferList *_Nonnull inputData) {
-      return [weakSelf processAudioInput:inputData withFrameCount:frameCount atTimestamp:timestamp];
+      return [weakSelf processAudioInput:inputData
+                          withFrameCount:frameCount
+                             atTimestamp:timestamp];
     };
 
-    self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
+    self.sinkNode =
+        [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
   }
 
   return self;
@@ -55,8 +64,9 @@
   float outputSampleRate = self.outputFormat.sampleRate;
 
   if (inputSampleRate != outputSampleRate) {
-    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
-                                                                  frameCapacity:frameCount];
+    AVAudioPCMBuffer *inputBuffer =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
+                                      frameCapacity:frameCount];
     memcpy(
         inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
         inputData->mBuffers[0].mData,
@@ -65,22 +75,28 @@
 
     int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
 
-    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
-                                                                   frameCapacity:outputFrameCount];
+    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc]
+        initWithPCMFormat:self.audioConverter.outputFormat
+            frameCapacity:outputFrameCount];
 
     NSError *error = nil;
-    AVAudioConverterInputBlock inputBlock =
-        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
+        AVAudioPacketCount inNumberOfPackets,
+        AVAudioConverterInputStatus *outStatus)
     {
       *outStatus = AVAudioConverterInputStatus_HaveData;
       return inputBuffer;
     };
 
     /// IMPORTANT: AVAudioConverter leaks memory without autorelease pool
-    /// more details here: https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
-    /// we can try to remove it in the future or refactor to reuse buffers to minimize allocations
+    /// more details here:
+    /// https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
+    /// we can try to remove it in the future or refactor to reuse buffers to
+    /// minimize allocations
     @autoreleasepool {
-      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
+      [self.audioConverter convertToBuffer:outputBuffer
+                                     error:&error
+                        withInputFromBlock:inputBlock];
     }
 
     if (error) {
@@ -103,13 +119,15 @@
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
-  // AudioEngine allows us to attach and connect nodes at runtime but with few limitations
-  // in this case if it is the first recorder node and player started the engine we need to restart.
-  // It can be optimized by tracking if we haven't break rules of at runtime modifications from docs
+  // AudioEngine allows us to attach and connect nodes at runtime but with few
+  // limitations in this case if it is the first recorder node and player
+  // started the engine we need to restart. It can be optimized by tracking if
+  // we haven't break rules of at runtime modifications from docs
   // https://developer.apple.com/documentation/avfaudio/avaudioengine?language=objc
   //
-  // Currently we are restarting because we do not see any significant performance issue and case when
-  // you will need to start and stop recorder very frequently
+  // Currently we are restarting because we do not see any significant
+  // performance issue and case when you will need to start and stop recorder
+  // very frequently
   [audioEngine stopEngine];
   [audioEngine attachInputNode:self.sinkNode];
   [audioEngine startIfNecessary];

package/ios/audioapi/ios/core/utils/AudioDecoder.mm

@@ -18,7 +18,9 @@ namespace audioapi {
 // Decoding audio in fixed-size chunks because total frame count can't be
 // determined in advance. Note: ma_decoder_get_length_in_pcm_frames() always
 // returns 0 for Vorbis decoders.
-std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outputChannels)
+std::vector<float> AudioDecoder::readAllPcmFrames(
+    ma_decoder &decoder,
+    int outputChannels)
 {
   std::vector<float> buffer;
   std::vector<float> temp(CHUNK_SIZE * outputChannels);
@@ -26,12 +28,16 @@ std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outpu
 
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
-    ma_decoder_read_pcm_frames(&decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
+    ma_decoder_read_pcm_frames(
+        &decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
     if (tempFramesDecoded == 0) {
       break;
     }
 
-    buffer.insert(buffer.end(), temp.data(), temp.data() + tempFramesDecoded * outputChannels);
+    buffer.insert(
+        buffer.end(),
+        temp.data(),
+        temp.data() + tempFramesDecoded * outputChannels);
     outFramesRead += tempFramesDecoded;
   }
 
@@ -51,7 +57,8 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
   }
 
   auto outputFrames = buffer.size() / outputChannels;
-  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, outputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(
+      outputFrames, outputChannels, outputSampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();
@@ -62,10 +69,13 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
   return std::make_shared<AudioBuffer>(audioBus);
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(const std::string &path, float sampleRate)
+std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
+    const std::string &path,
+    float sampleRate)
 {
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
-    auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
+    auto buffer =
+        ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       NSLog(@"Failed to decode with FFmpeg: %s", path.c_str());
       return nullptr;
@@ -73,11 +83,14 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(const std::string
     return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
-  ma_decoding_backend_vtable *customBackends[] = {ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoding_backend_vtable *customBackends[] = {
+      ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount =
+      sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_file(path.c_str(), &config, &decoder) != MA_SUCCESS) {
     NSLog(@"Failed to initialize decoder for file: %s", path.c_str());
@@ -90,14 +103,20 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(const std::string
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
+  return makeAudioBufferFromFloatBuffer(
+      buffer, outputSampleRate, outputChannels);
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleRate)
+std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
+    const void *data,
+    size_t size,
+    float sampleRate)
 {
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
-  if (format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC) {
-    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
+  if (format == AudioFormat::MP4 || format == AudioFormat::M4A ||
+      format == AudioFormat::AAC) {
+    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(
+        data, size, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       NSLog(@"Failed to decode with FFmpeg");
       return nullptr;
@@ -105,12 +124,15 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(const void *dat
     return buffer;
   }
   ma_decoder decoder;
-  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
 
-  ma_decoding_backend_vtable *customBackends[] = {ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
+  ma_decoding_backend_vtable *customBackends[] = {
+      ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount =
+      sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_memory(data, size, &config, &decoder) != MA_SUCCESS) {
     NSLog(@"Failed to initialize decoder for memory block");
@@ -123,7 +145,8 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(const void *dat
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
+  return makeAudioBufferFromFloatBuffer(
+      buffer, outputSampleRate, outputChannels);
 }
 
 std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
@@ -134,9 +157,11 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
 {
   auto decodedData = base64_decode(data, false);
   const auto uint8Data = reinterpret_cast<uint8_t *>(decodedData.data());
-  size_t numFramesDecoded = decodedData.size() / (inputChannelCount * sizeof(int16_t));
+  size_t numFramesDecoded =
+      decodedData.size() / (inputChannelCount * sizeof(int16_t));
 
-  auto audioBus = std::make_shared<AudioBus>(numFramesDecoded, inputChannelCount, inputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(
+      numFramesDecoded, inputChannelCount, inputSampleRate);
 
   for (int ch = 0; ch < inputChannelCount; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();

package/ios/audioapi/ios/system/AudioEngine.h

@@ -16,7 +16,8 @@
 @property (nonatomic, strong) AVAudioSinkNode *inputNode;
 @property (nonatomic, weak) AudioSessionManager *sessionManager;
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager;
+- (instancetype)initWithAudioSessionManager:
+    (AudioSessionManager *)sessionManager;
 
 + (instancetype)sharedInstance;
 - (void)cleanup;
@@ -30,7 +31,8 @@
 - (void)unmarkAsInterrupted;
 - (bool)isSupposedToRun;
 
-- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;
+- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode
+                        format:(AVAudioFormat *)format;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
 
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode;