react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

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

@@ -1,70 +1,346 @@
 #import <AVFoundation/AVFoundation.h>
+#import <AudioEngine.h>
+#import <AudioSessionManager.h>
+#import <Foundation/Foundation.h>
 
+#include <unordered_map>
+
+#include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/utils/AudioFileWriter.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
+#include <audioapi/ios/core/utils/IOSFileWriter.h>
+#include <audioapi/ios/core/utils/IOSRecorderCallback.h>
+#include <audioapi/ios/system/AudioEngine.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
-#include <unordered_map>
+#include <audioapi/utils/Result.hpp>
 
 namespace audioapi {
 
+/// @brief Constructs an IOSAudioRecorder instance.
+/// This constructor initializes the receiver block and native side recorder wrapper (AVAudioSinkNode).
+/// All other necessary fields (like buffers) are initialized in start() method.
+/// This "method" should be called from the JS thread only.
+/// @param audioEventHandlerRegistry Shared pointer to the AudioEventHandlerRegistry for event handling.
 IOSAudioRecorder::IOSAudioRecorder(
-    float sampleRate,
-    int bufferLength,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry)
 {
-  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (isRunning_.load()) {
-      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-      writeToBuffers(inputChannel, numFrames);
+  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (usesFileOutput()) {
+      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+        std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+            ->writeAudioData(inputBuffer, numFrames);
+      }
     }
 
-    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-      auto *outputChannel = bus->getChannel(0)->getData();
+    if (usesCallback()) {
+      if (auto lock = Locker::tryLock(callbackMutex_)) {
+        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+            ->receiveAudioData(inputBuffer, numFrames);
+      }
+    }
 
-      circularBuffer_->pop_front(outputChannel, bufferLength_);
+    if (isConnected()) {
+      if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
+        for (size_t channel = 0; channel < adapterNode_->channelCount_; ++channel) {
+          float *channelData = (float *)inputBuffer->mBuffers[channel].mData;
 
-      invokeOnAudioReadyCallback(bus, bufferLength_);
+          adapterNode_->buff_[channel]->write(channelData, numFrames);
+        }
+      }
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [audioRecorder_ cleanup];
+  [nativeRecorder_ cleanup];
+}
+
+/// @brief Starts the audio recording process and prepares necessary resources.
+/// This method should be called from the JS thread only.
+/// @returns Result containing the file path if recording started successfully, or an error message.
+Result<std::string, std::string> IOSAudioRecorder::start()
+{
+  if (isRecording()) {
+    return Result<std::string, std::string>::Err("Already recording");
+  }
+
+  std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
+
+  if ([[audioSessionManager checkRecordingPermissions] isEqual:@"Denied"]) {
+    return Result<std::string, std::string>::Err("Microphone permissions are not granted");
+  }
+
+  // TODO: recorder should probably request the options if not set by user
+  // but lets handle that in another PR
+  if (![audioSessionManager isSessionActive]) {
+    return Result<std::string, std::string>::Err("Audio session is not active");
+  }
+
+  // TODO: this is a bit ugly, and could be written slightly better
+  // we need to stop the audio engine if it's running, to be able to get
+  // proper input format values, otherwise the system my zero out the sample rate or channel count
+  // if input wasn't used yet
+  // (especially on simulators)
+  // Engine will be started again once the native recorder starts
+  [AudioEngine.sharedInstance stopIfNecessary];
+
+  // Estimate the maximum input buffer lengths that can be expected from the sink node
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+  auto inputFormat = [nativeRecorder_ getInputFormat];
+
+  if (usesFileOutput()) {
+    auto fileResult = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+                          ->openFile(inputFormat, maxInputBufferLength);
+
+    if (fileResult.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
+  }
+
+  if (usesCallback()) {
+    auto callbackResult = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                              ->prepare(inputFormat, maxInputBufferLength);
+
+    if (callbackResult.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to prepare callback: " + callbackResult.unwrap_err());
+    }
+  }
+
+  if (isConnected()) {
+    // TODO: pass sample rate, in case conversion is necessary
+    adapterNode_->init(maxInputBufferLength, inputFormat.channelCount);
+  }
+
+  [nativeRecorder_ start];
+  state_.store(RecorderState::Recording, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
+}
+
+/// @brief Stops the audio recording process and releases resources.
+/// It finalizes any data receiver and closes the stream.
+/// This method should be called from the JS thread only.
+/// @returns Result containing a tuple of the output file path, size, and duration if stopped successfully, or an error message.
+Result<std::tuple<std::string, double, double>, std::string> IOSAudioRecorder::stop()
+{
+  std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
+  std::string filePath = filePath_;
+  double outputFileSize = 0;
+  double outputDuration = 0;
+
+  if (isIdle()) {
+    return Result<std::tuple<std::string, double, double>, std::string>::Err("Not recording");
+  }
+
+  state_.store(RecorderState::Idle, std::memory_order_release);
+  [nativeRecorder_ stop];
+
+  if (usesFileOutput()) {
+    auto fileResult = fileWriter_->closeFile();
+
+    if (fileResult.is_err()) {
+      return Result<std::tuple<std::string, double, double>, std::string>::Err(
+          "Failed to close file: " + fileResult.unwrap_err());
+    }
+
+    outputFileSize = std::get<0>(fileResult.unwrap());
+    outputDuration = std::get<1>(fileResult.unwrap());
+  }
+
+  if (usesCallback()) {
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
+  }
+
+  filePath_ = "";
+  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
+      std::make_tuple(filePath, outputFileSize, outputDuration));
+}
+
+/// @brief Enables file output for the recorder with specified properties.
+/// If the recorder is already active, it will open the file for writing immediately.
+/// This method should be called from the JS thread only.
+/// @param properties Shared pointer to AudioFileProperties defining the output file format.
+/// @returns Result containing the output file path if enabled successfully, or an error message.
+Result<std::string, std::string> IOSAudioRecorder::enableFileOutput(
+    std::shared_ptr<AudioFileProperties> properties)
+{
+  std::scoped_lock lock(fileWriterMutex_, errorCallbackMutex_);
+  fileWriter_ = std::make_shared<IOSFileWriter>(audioEventHandlerRegistry_, properties);
+
+  if (!isIdle()) {
+    auto result = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+                      ->openFile([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (result.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + result.unwrap_err());
+    }
+
+    filePath_ = result.unwrap();
+  }
+
+  fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
+
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
+}
+
+void IOSAudioRecorder::disableFileOutput()
+{
+  std::scoped_lock lock(fileWriterMutex_);
+  fileOutputEnabled_.store(false, std::memory_order_release);
+  fileWriter_ = nullptr;
 }
 
-void IOSAudioRecorder::start()
+/// @brief Connects a RecorderAdapterNode to the recorder for audio data routing.
+/// If the recorder is already active, it will initialize the adapter node immediately.
+/// This method should be called from the JS thread only.
+/// @param node Shared pointer to the RecorderAdapterNode to connect.
+void IOSAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
 {
-  if (isRunning_.load()) {
+  std::scoped_lock lock(adapterNodeMutex_);
+  adapterNode_ = node;
+
+  if (!isIdle()) {
+    adapterNode_->init(
+        [nativeRecorder_ getBufferSize], [nativeRecorder_ getInputFormat].channelCount);
+  }
+
+  isConnected_.store(true, std::memory_order_release);
+}
+
+/// @brief Disconnects the currently connected RecorderAdapterNode from the recorder.
+/// If the recorder is currently active, it will stop routing audio data immediately.
+/// This method should be called from the JS thread only.
+void IOSAudioRecorder::disconnect()
+{
+  std::scoped_lock lock(adapterNodeMutex_);
+  adapterNode_ = nullptr;
+  isConnected_.store(false, std::memory_order_release);
+}
+
+void IOSAudioRecorder::pause()
+{
+  if (!isRecording()) {
     return;
   }
 
-  [audioRecorder_ start];
-  isRunning_.store(true);
+  [nativeRecorder_ pause];
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
-void IOSAudioRecorder::stop()
+void IOSAudioRecorder::resume()
 {
-  if (!isRunning_.load()) {
+  if (!isPaused()) {
     return;
   }
 
-  isRunning_.store(false);
-  [audioRecorder_ stop];
+  [nativeRecorder_ resume];
+  state_.store(RecorderState::Recording, std::memory_order_release);
+}
+
+/// @brief Checks if the recorder is currently recording.
+/// Besides recorder internal state, it also check if the audio engine is running.
+/// this helps with restarts after interruptions or other audio session changes.
+/// This method can be called from any thread.
+/// @returns True if recording, false otherwise.
+bool IOSAudioRecorder::isRecording() const
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
+}
+
+/// @brief Checks if the recorder is currently paused.
+/// Besides recorder internal state, it also check if the audio engine is running.
+/// this helps with restarts after interruptions or other audio session changes.
+/// This method can be called from any thread.
+/// @returns True if paused, false otherwise.
+bool IOSAudioRecorder::isPaused() const
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  auto currentState = state_.load(std::memory_order_acquire);
+
+  if (currentState == RecorderState::Idle) {
+    return false;
+  }
+
+  return currentState == RecorderState::Paused ||
+      [audioEngine getState] != AudioEngineState::AudioEngineStateRunning;
+}
+
+/// @brief Checks if the recorder is currently idle (not recording or paused).
+/// This method can be called from any thread.
+/// @returns True if idle, false otherwise.
+bool IOSAudioRecorder::isIdle() const
+{
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-  sendRemainingData();
+/// @brief Sets the callback to be invoked when audio data is ready.
+/// If the recorder is already active, it will prepare the callback for receiving audio data immediately.
+/// This method should be called from the JS thread only.
+/// @param sampleRate Desired sample rate for the callback audio data.
+/// @param bufferLength Desired buffer length in frames for the callback audio data.
+/// @param channelCount Number of channels for the callback audio data.
+/// @param callbackId Identifier for the JS callback to be invoked.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> IOSAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+{
+  std::scoped_lock lock(callbackMutex_, errorCallbackMutex_);
+
+  dataCallback_ = std::make_shared<IOSRecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+
+  if (!isIdle()) {
+    auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                      ->prepare([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (result.is_err()) {
+      return Result<NoneType, std::string>::Err(result.unwrap_err());
+    }
+  }
+
+  dataCallback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
+
+  callbackOutputEnabled_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @brief Clears the audio data callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void IOSAudioRecorder::clearOnAudioReadyCallback()
+{
+  std::scoped_lock lock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
 }
 
 } // namespace audioapi

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

@@ -39,8 +39,6 @@
 
 - (bool)start
 {
-  NSLog(@"[AudioPlayer] start");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -50,28 +48,25 @@
   // 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
-  [audioEngine stopEngine];
+  // 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 stopIfNecessary];
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
   return [audioEngine startIfNecessary];
 }
 
 - (void)stop
 {
-  NSLog(@"[AudioPlayer] stop");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
+
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   self.sourceNodeId = nil;
 }
 
 - (bool)resume
 {
-  NSLog(@"[AudioPlayer] resume");
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -82,7 +77,8 @@
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine pauseEngine:self.sourceNodeId];
+
+  [audioEngine pauseIfNecessary];
 }
 
 - (void)cleanup

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

@@ -7,25 +7,24 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 @interface NativeAudioRecorder : NSObject
 
-@property (nonatomic, assign) int bufferLength;
-@property (nonatomic, assign) float sampleRate;
-
 @property (nonatomic, strong) AVAudioSinkNode *sinkNode;
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
 @property (nonatomic, copy) AudioReceiverBlock receiverBlock;
 
-@property (nonatomic, strong) AVAudioConverter *audioConverter;
-@property (nonatomic, strong) AVAudioFormat *inputFormat;
-@property (nonatomic, strong) AVAudioFormat *outputFormat;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
+
+- (AVAudioFormat *)getInputFormat;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate;
+- (int)getBufferSize;
 
 - (void)start;
 
 - (void)stop;
 
+- (void)pause;
+
+- (void)resume;
+
 - (void)cleanup;
 
 @end

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

@@ -4,42 +4,36 @@
 
 @implementation NativeAudioRecorder
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate
+static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
-  if (self = [super init]) {
-    self.bufferLength = bufferLength;
-    self.sampleRate = sampleRate;
-
-    self.receiverBlock = [receiverBlock copy];
-
-    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
+  if (x == 0) {
+    return 1;
+  }
 
-    if (!devicePrefferedSampleRate) {
-      NSError *error;
-      devicePrefferedSampleRate = sampleRate;
+  x--;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  x++;
 
-      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
-    }
+  return x;
+}
 
-    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];
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+{
+  if (self = [super init]) {
+    self.receiverBlock = [receiverBlock copy];
 
     __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];
+      weakSelf.receiverBlock(inputData, frameCount);
+
+      return kAudioServicesNoError;
     };
 
     self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
@@ -48,58 +42,36 @@
   return self;
 }
 
-- (OSStatus)processAudioInput:(const AudioBufferList *)inputData
-               withFrameCount:(AVAudioFrameCount)frameCount
-                  atTimestamp:(const AudioTimeStamp *)timestamp
+// Note: this method should be called only after the session is activated
+- (AVAudioFormat *)getInputFormat
 {
-  float inputSampleRate = self.inputFormat.sampleRate;
-  float outputSampleRate = self.outputFormat.sampleRate;
-
-  if (inputSampleRate != outputSampleRate) {
-    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
-                                                                  frameCapacity:frameCount];
-    memcpy(
-        inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
-        inputData->mBuffers[0].mData,
-        inputData->mBuffers[0].mDataByteSize);
-    inputBuffer.frameLength = frameCount;
-
-    int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
-
-    AVAudioPCMBuffer *outputBuffer =
-        [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
-                                      frameCapacity:outputFrameCount];
-
-    NSError *error = nil;
-    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
-        AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-    {
-      *outStatus = AVAudioConverterInputStatus_HaveData;
-      return inputBuffer;
-    };
+  AVAudioFormat *format = [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
 
-    /// 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
-    @autoreleasepool {
-      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
-    }
+  if (format.sampleRate == 0 || format.channelCount == 0) {
+    AudioSessionManager *sessionManager = [AudioSessionManager sharedInstance];
 
-    if (error) {
-      NSLog(@"Error during audio conversion: %@", error.localizedDescription);
-      return kAudioServicesBadSpecifierSizeError;
-    }
+    format = [[AVAudioFormat alloc]
+        initStandardFormatWithSampleRate:[[sessionManager getDevicePreferredSampleRate] doubleValue]
+                                channels:[[sessionManager getDevicePreferredInputChannelCount]
+                                             intValue]];
+  }
 
-    self.receiverBlock(outputBuffer.audioBufferList, outputBuffer.frameLength);
+  return format;
+}
 
-    return kAudioServicesNoError;
-  }
+- (int)getBufferSize
+{
+  // NOTE: this method should be called only after the session is activated
+  AVAudioSession *audioSession = [AVAudioSession sharedInstance];
 
-  self.receiverBlock(inputData, frameCount);
+  // TMPfix: it seems that buffer duration in some cases (background/device change) can switch
+  // to longer values, exceeding buffer size predicted after session start
+  // since it is just a couple of buffers we can set min value of 200ms
+  // to enforce we always have enough frames allocated to pass further down the pipeline
+  float bufferDuration = MAX(audioSession.IOBufferDuration, 0.2);
 
-  return kAudioServicesNoError;
+  // IOS returns buffer duration rounded, but expects the buffer size to be power of two in runtime
+  return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
 }
 
 - (void)start
@@ -113,10 +85,9 @@
   // 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
-  [audioEngine stopEngine];
+  // 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 stopIfNecessary];
   [audioEngine attachInputNode:self.sinkNode];
   [audioEngine startIfNecessary];
 }
@@ -125,8 +96,31 @@
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
+  [audioEngine stopIfPossible];
   [audioEngine detachInputNode];
-  [audioEngine stopIfNecessary];
+
+  // This makes sure that the engine releases the input properly when we no longer need it
+  // (i.e. no more misleading dot)
+  // Restart only if is not running to avoid interruptions of playback
+  if ([audioEngine getState] != AudioEngineStateRunning) {
+    [audioEngine restartAudioEngine];
+  }
+}
+
+- (void)pause
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+
+  [audioEngine pauseIfNecessary];
+}
+
+- (void)resume
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+
+  [audioEngine startIfNecessary];
 }
 
 - (void)cleanup

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

@@ -61,6 +61,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
       channelData[i] = buffer[i * outputChannels + ch];
     }
   }
+
   return std::make_shared<AudioBuffer>(audioBus);
 }