react-native-audio-api 0.13.3 → 0.13.5

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

@@ -2,7 +2,9 @@
 #import <AudioEngine.h>
 #import <AudioSessionManager.h>
 #import <Foundation/Foundation.h>
-
+#include <algorithm>
+#include <mutex>
+#include <unordered_map>
 #include <vector>
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
@@ -19,62 +21,26 @@
 
 namespace audioapi {
 
-static inline NSNumber *recorderFormatNumber(id format, NSString *key)
+static double recorderFormatSampleRate(AVAudioFormat *format)
 {
-  if (format == nil) {
-    return nil;
-  }
-
-  if ([format isKindOfClass:[AVAudioFormat class]]) {
-    AVAudioFormat *audioFormat = (AVAudioFormat *)format;
-
-    if ([key isEqualToString:@"sampleRate"]) {
-      return @(audioFormat.sampleRate);
-    }
-
-    if ([key isEqualToString:@"channelCount"]) {
-      return @(audioFormat.channelCount);
-    }
-
-    if ([key isEqualToString:@"interleaved"]) {
-      return @(audioFormat.interleaved);
-    }
-  }
-
-  @try {
-    id value = [format valueForKey:key];
-    return [value isKindOfClass:[NSNumber class]] ? value : nil;
-  } @catch (__unused NSException *exception) {
-    return nil;
-  }
+  return format.sampleRate;
 }
 
-static inline double recorderFormatSampleRate(id format)
+static AVAudioChannelCount recorderFormatChannelCount(AVAudioFormat *format)
 {
-  return [recorderFormatNumber(format, @"sampleRate") doubleValue];
+  return format.channelCount;
 }
 
-static inline AVAudioChannelCount recorderFormatChannelCount(id format)
+static bool hasUsableRecorderFormat(AVAudioFormat *format)
 {
-  return (AVAudioChannelCount)[recorderFormatNumber(format, @"channelCount") unsignedIntegerValue];
+  return format != nil && format.sampleRate > 0 && format.channelCount > 0;
 }
 
-static inline bool recorderFormatInterleaved(id format)
+static std::string describeRecorderFormat(AVAudioFormat *format)
 {
-  return [recorderFormatNumber(format, @"interleaved") boolValue];
-}
-
-static inline bool hasUsableRecorderFormat(id format)
-{
-  return format != nil && recorderFormatSampleRate(format) > 0 &&
-      recorderFormatChannelCount(format) > 0;
-}
-
-static std::string describeRecorderFormat(id format)
-{
-  return "engineFormat={sampleRate=" + std::to_string(recorderFormatSampleRate(format)) +
-      ", channelCount=" + std::to_string(recorderFormatChannelCount(format)) +
-      ", interleaved=" + std::string(recorderFormatInterleaved(format) ? "true" : "false") + "}";
+  return "engineFormat={sampleRate=" + std::to_string(format.sampleRate) +
+      ", channelCount=" + std::to_string(format.channelCount) +
+      ", interleaved=" + (format.interleaved ? "true" : "false") + "}";
 }
 
 /// @brief Appends the shared input diagnostics (and, on the simulator, the host-mic hint)
@@ -103,31 +69,183 @@ IOSAudioRecorder::IOSAudioRecorder(
     : AudioRecorder(audioEventHandlerRegistry)
 {
   AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (usesFileOutput()) {
-      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
-        fileWriter_->writeAudioData(inputBuffer, numFrames);
-      }
+    runSideEffects(inputBuffer, numFrames);
+  };
+
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+
+  nativeRecorder_.onInputConfigurationChange = ^{ this->handleInputConfigurationChange(); };
+}
+
+void IOSAudioRecorder::runSideEffects(const AudioBufferList *inputBuffer, int numFrames)
+{
+  if (usesFileOutput()) {
+    if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+      fileWriter_->writeAudioData(inputBuffer, numFrames);
+    }
+  }
+
+  if (usesCallback()) {
+    if (auto lock = Locker::tryLock(callbackMutex_)) {
+      std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+          ->receiveAudioData(inputBuffer, numFrames);
     }
+  }
 
-    if (usesCallback()) {
-      if (auto lock = Locker::tryLock(callbackMutex_)) {
-        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
-            ->receiveAudioData(inputBuffer, numFrames);
+  if (isConnected()) {
+    if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
+      const size_t channelCount = std::min(
+          adapterNode_->getChannelCount(), static_cast<size_t>(inputBuffer->mNumberBuffers));
+      for (size_t channel = 0; channel < channelCount; ++channel) {
+        auto *data = static_cast<float *>(inputBuffer->mBuffers[channel].mData);
+        adapterNode_->buff_[channel]->write(data, numFrames);
       }
     }
+  }
+}
 
-    if (isConnected()) {
-      if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
-        for (size_t channel = 0; channel < adapterNode_->getChannelCount(); ++channel) {
-          auto data = (float *)inputBuffer->mBuffers[channel].mData;
+void IOSAudioRecorder::handleInputConfigurationChange()
+{
+  if (isIdle()) {
+    return;
+  }
 
-          adapterNode_->buff_[channel]->write(data, numFrames);
-        }
+  BOOL formatChanged = NO;
+  if (![nativeRecorder_ refreshResolvedInputFormatReturningChanged:&formatChanged]) {
+    return;
+  }
+
+  if (!formatChanged) {
+    if (state_.load(std::memory_order_acquire) == RecorderState::Recording) {
+      [nativeRecorder_ setInputArmed:true];
+    }
+    return;
+  }
+
+  reprepareForLiveInput();
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareForLiveInput()
+{
+  if (isIdle()) {
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  // those values are resolved earlier with actual correct values
+  AVAudioFormat *inputFormat = [nativeRecorder_ getResolvedInputFormat];
+  int maxInputBufferLength = [nativeRecorder_ getResolvedBufferSize];
+
+  if (!hasUsableRecorderFormat(inputFormat) || maxInputBufferLength <= 0) {
+    return Result<NoneType, std::string>::Err("Recorder input format is unavailable");
+  }
+
+  const bool shouldArmInput = state_.load(std::memory_order_acquire) == RecorderState::Recording;
+  [nativeRecorder_ setInputArmed:false];
+
+  if (usesFileOutput()) {
+    auto fileResult = reprepareFileWriter(inputFormat, maxInputBufferLength);
+    if (fileResult.is_err()) {
+      if (shouldArmInput) {
+        [nativeRecorder_ setInputArmed:true];
       }
+      return fileResult;
     }
-  };
+  }
 
-  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+  if (usesCallback()) {
+    auto callbackResult = reprepareCallback(inputFormat, maxInputBufferLength);
+    if (callbackResult.is_err()) {
+      if (shouldArmInput) {
+        [nativeRecorder_ setInputArmed:true];
+      }
+      return callbackResult;
+    }
+  }
+
+  if (isConnected() && adapterNode_ != nullptr) {
+    reprepareAdapter(inputFormat, maxInputBufferLength);
+  }
+
+  if (shouldArmInput) {
+    [nativeRecorder_ setInputArmed:true];
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareFileWriter(
+    AVAudioFormat *inputFormat,
+    int maxInputBufferLength)
+{
+  std::scoped_lock lock(fileWriterMutex_);
+
+  if (fileWriter_ == nullptr) {
+    return Result<NoneType, std::string>::Err("File writer is unavailable");
+  }
+
+  if (auto rotatingWriter = std::dynamic_pointer_cast<IOSRotatingFileWriter>(fileWriter_)) {
+    auto result = rotatingWriter->reprepareStreamFormat(
+        inputFormat, static_cast<size_t>(maxInputBufferLength));
+    if (result.is_err()) {
+      fileOutputConfigured_.store(false, std::memory_order_release);
+      return Result<NoneType, std::string>::Err(
+          "Failed to reopen file for writing: " + result.unwrap_err());
+    }
+
+    filePath_ = result.unwrap();
+    fileOutputConfigured_.store(true, std::memory_order_release);
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  auto iosWriter = std::static_pointer_cast<IOSFileWriter>(fileWriter_);
+  auto result =
+      iosWriter->reopenForInputFormatChange(inputFormat, static_cast<size_t>(maxInputBufferLength));
+  if (result.is_err()) {
+    fileOutputConfigured_.store(false, std::memory_order_release);
+    return Result<NoneType, std::string>::Err(
+        "Failed to reopen file for writing: " + result.unwrap_err());
+  }
+
+  filePath_ = result.unwrap();
+  fileOutputConfigured_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareCallback(
+    AVAudioFormat *inputFormat,
+    int maxInputBufferLength)
+{
+  std::scoped_lock lock(callbackMutex_);
+
+  if (dataCallback_ == nullptr) {
+    return Result<NoneType, std::string>::Err("Callback is unavailable");
+  }
+
+  auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                    ->prepare(inputFormat, static_cast<size_t>(maxInputBufferLength));
+  if (result.is_err()) {
+    callbackOutputConfigured_.store(false, std::memory_order_release);
+    return Result<NoneType, std::string>::Err("Failed to prepare callback: " + result.unwrap_err());
+  }
+
+  callbackOutputConfigured_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+void IOSAudioRecorder::reprepareAdapter(AVAudioFormat *inputFormat, int maxInputBufferLength)
+{
+  std::scoped_lock lock(adapterNodeMutex_);
+  if (adapterNode_ == nullptr) {
+    return;
+  }
+
+  // init() is a no-op on an initialized adapter, so the old format has to be torn down first.
+  adapterNode_->adapterCleanup();
+  adapterNode_->init(
+      static_cast<size_t>(maxInputBufferLength),
+      recorderFormatChannelCount(inputFormat),
+      recorderFormatSampleRate(inputFormat));
+  connectedConfigured_.store(true, std::memory_order_release);
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
@@ -136,6 +254,8 @@ IOSAudioRecorder::~IOSAudioRecorder()
     stop();
   }
 
+  nativeRecorder_.onInputConfigurationChange = nil;
+
   {
     std::scoped_lock lock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
     callbackOutputConfigured_.store(false, std::memory_order_release);
@@ -291,16 +411,16 @@ AudioRecorder::StopResult IOSAudioRecorder::stop()
   std::shared_ptr<RecorderAdapterNode> adapterNode;
   std::vector<std::string> outputPaths;
 
-  {
-    std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+  if (isIdle()) {
+    return StopResult::Err("Recorder is not in recording state.");
+  }
 
-    if (isIdle()) {
-      return StopResult::Err("Recorder is not in recording state.");
-    }
+  state_.store(RecorderState::Idle, std::memory_order_release);
+  [nativeRecorder_ setInputArmed:false];
+  [nativeRecorder_ stop];
 
-    [nativeRecorder_ setInputArmed:false];
-    state_.store(RecorderState::Idle, std::memory_order_release);
-    [nativeRecorder_ stop];
+  {
+    std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
 
     if (usesFileOutput()) {
       fileOutputConfigured_.store(false, std::memory_order_release);
@@ -449,8 +569,11 @@ void IOSAudioRecorder::resume()
     return;
   }
 
-  [nativeRecorder_ resume];
   state_.store(RecorderState::Recording, std::memory_order_release);
+
+  if (![nativeRecorder_ resume]) {
+    state_.store(RecorderState::Paused, std::memory_order_release);
+  }
 }
 
 /// @brief Checks if the recorder is currently recording.

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

@@ -12,19 +12,21 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 @property (nonatomic, strong) AVAudioFormat *resolvedInputFormat;
 @property (nonatomic, assign) int resolvedBufferSize;
 @property (atomic, assign) BOOL inputArmed;
+@property (nonatomic, copy) void (^onInputConfigurationChange)(void);
 
 - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
 
 - (int)getBufferSize;
 - (AVAudioFormat *)getResolvedInputFormat;
 - (int)getResolvedBufferSize;
+- (BOOL)refreshResolvedInputFormatReturningChanged:(BOOL *)formatChanged;
 - (BOOL)start:(NSError **)error;
 
 - (void)stop;
 
 - (void)pause;
 
-- (void)resume;
+- (BOOL)resume;
 
 - (void)cleanup;
 

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

@@ -57,17 +57,15 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 
 - (int)getBufferSize
 {
-  // NOTE: this method should be called only after the session is activated
   AVAudioSession *audioSession = [AVAudioSession sharedInstance];
+  double sampleRate = audioSession.sampleRate;
 
-  // 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);
+  if (self.resolvedInputFormat != nil && self.resolvedInputFormat.sampleRate > 0) {
+    sampleRate = self.resolvedInputFormat.sampleRate;
+  }
 
-  // IOS returns buffer duration rounded, but expects the buffer size to be power of two in runtime
-  return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
+  float bufferDuration = MAX(audioSession.IOBufferDuration, 0.2);
+  return nextPowerOfTwo(ceil(bufferDuration * sampleRate));
 }
 
 - (int)getResolvedBufferSize
@@ -75,6 +73,29 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   return self.resolvedBufferSize;
 }
 
+- (BOOL)refreshResolvedInputFormatReturningChanged:(BOOL *)formatChanged
+{
+  AVAudioFormat *liveFormat = [self readLiveInputFormat];
+
+  if (liveFormat == nil || liveFormat.sampleRate <= 0 || liveFormat.channelCount == 0) {
+    return NO;
+  }
+
+  AVAudioFormat *previousFormat = self.resolvedInputFormat;
+  BOOL changed = previousFormat == nil || previousFormat.sampleRate != liveFormat.sampleRate ||
+      previousFormat.channelCount != liveFormat.channelCount ||
+      previousFormat.isInterleaved != liveFormat.isInterleaved;
+
+  self.resolvedInputFormat = liveFormat;
+  self.resolvedBufferSize = [self getBufferSize];
+
+  if (formatChanged != nil) {
+    *formatChanged = changed;
+  }
+
+  return YES;
+}
+
 - (BOOL)start:(NSError **)error
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
@@ -93,7 +114,8 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.resolvedBufferSize = 0;
 
   [audioEngine stopIfNecessary];
-  [audioEngine attachInputNodeWithReceiverBlock:self.receiverSinkBlock];
+  [audioEngine attachInputNodeWithReceiverBlock:self.receiverSinkBlock
+                     onInputConfigurationChange:self.onInputConfigurationChange];
 
   if (![audioEngine startIfNecessary]) {
     [audioEngine detachInputNode];
@@ -128,8 +150,6 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.inputArmed = NO;
   [audioEngine detachInputNode];
   [audioEngine stopIfPossible];
-  // This makes sure that the engine releases the input properly when we no longer need it
-  // (i.e. no more misleading dot)
   [audioEngine restartAudioEngine];
   self.resolvedInputFormat = nil;
   self.resolvedBufferSize = 0;
@@ -144,14 +164,20 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   [audioEngine pauseIfNecessary];
 }
 
-- (void)resume
+- (BOOL)resume
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
-  if ([audioEngine startIfNecessary]) {
-    self.inputArmed = YES;
+  if (![audioEngine startIfNecessary]) {
+    return NO;
+  }
+
+  if (self.onInputConfigurationChange != nil) {
+    self.onInputConfigurationChange();
   }
+
+  return YES;
 }
 
 - (void)cleanup
@@ -161,6 +187,7 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.resolvedBufferSize = 0;
   self.receiverBlock = nil;
   self.receiverSinkBlock = nil;
+  self.onInputConfigurationChange = nil;
 }
 
 @end

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

@@ -166,13 +166,26 @@ NSURL *getFileURL(
   NSString *timestamp = getTimestampString();
   NSString *fileExtension = getFileExtension(properties);
 
-  NSString *fileName = fileNameOverride.length() > 0 && properties->rotateIntervalBytes == 0
-      ? [NSString stringWithFormat:@"%@.%@",
+  if (fileNameOverride.length() > 0 && properties->rotateIntervalBytes == 0) {
+    NSString *fileName =
+        [NSString stringWithFormat:@"%@.%@",
                                    [NSString stringWithUTF8String:fileNameOverride.c_str()],
-                                   fileExtension]
-      : [NSString stringWithFormat:@"%@_%@.%@", fileNamePrefix, timestamp, fileExtension];
+                                   fileExtension];
+    return [directoryURL URLByAppendingPathComponent:fileName];
+  }
+
+  NSString *fileName =
+      [NSString stringWithFormat:@"%@_%@.%@", fileNamePrefix, timestamp, fileExtension];
+  NSURL *fileURL = [directoryURL URLByAppendingPathComponent:fileName];
+
+  for (NSUInteger suffix = 1; [[NSFileManager defaultManager] fileExistsAtPath:fileURL.path];
+       ++suffix) {
+    fileName = [NSString
+        stringWithFormat:@"%@_%@_%lu.%@", fileNamePrefix, timestamp, (unsigned long)suffix, fileExtension];
+    fileURL = [directoryURL URLByAppendingPathComponent:fileName];
+  }
 
-  return [directoryURL URLByAppendingPathComponent:fileName];
+  return fileURL;
 }
 
 NSSearchPathDirectory getDirectory(const std::shared_ptr<AudioFileProperties> &properties)

package/ios/audioapi/ios/core/utils/IOSFileWriter.h

@@ -41,6 +41,9 @@ class IOSFileWriter : public AudioFileWriter {
       AVAudioFormat *bufferFormat,
       size_t maxInputBufferLength,
       const std::string &fileNameOverride);
+  OpenFileResult reopenForInputFormatChange(
+      AVAudioFormat *bufferFormat,
+      size_t maxInputBufferLength);
   CloseFileResult closeFile() override;
 
   void writeAudioData(const AudioBufferList *audioBufferList, int numFrames) override;
@@ -64,6 +67,11 @@ class IOSFileWriter : public AudioFileWriter {
  private:
   using FreeList = slots::SlotFreeList<FILE_WRITER_POOL_SIZE>;
 
+  Result<NoneType, std::string> prepareConversionPipeline(
+      AVAudioFormat *bufferFormat,
+      size_t maxInputBufferLength);
+  void releaseConversionPipeline();
+
   std::vector<ios::OwnedAudioBufferListPtr> inputBufferPool_;
   size_t inputBufferBytesPerBuffer_{0};
   std::unique_ptr<FreeList> freeSlots_;

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

@@ -83,6 +83,24 @@ OpenFileResult IOSFileWriter::openFile(
           [[error debugDescription] UTF8String]);
     }
 
+    auto pipelineResult = prepareConversionPipeline(bufferFormat, maxInputBufferLength);
+
+    if (pipelineResult.is_err()) {
+      rollbackFailedOpen();
+      return OpenFileResult::Err(pipelineResult.unwrap_err());
+    }
+
+    isFileOpen_.store(true, std::memory_order_release);
+    return OpenFileResult::Ok([[fileURL_ path] UTF8String]);
+  }
+}
+
+/// @brief Builds the converter, conversion buffers and offloader for the given input format.
+Result<NoneType, std::string> IOSFileWriter::prepareConversionPipeline(
+    AVAudioFormat *bufferFormat,
+    size_t maxInputBufferLength)
+{
+  @autoreleasepool {
     converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat
                                                  toFormat:[audioFile_ processingFormat]];
     converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
@@ -103,8 +121,7 @@ OpenFileResult IOSFileWriter::openFile(
 
     if (converterInputBuffer_ == nil || converterOutputBuffer_ == nil || audioFile_ == nil ||
         converter_ == nil) {
-      rollbackFailedOpen();
-      return OpenFileResult::Err("Error creating converter buffers");
+      return Result<NoneType, std::string>::Err("Error creating converter buffers");
     }
 
     auto offloaderLambda = [this](WriterData data) {
@@ -126,8 +143,7 @@ OpenFileResult IOSFileWriter::openFile(
     for (size_t i = 0; i < FILE_WRITER_POOL_SIZE; ++i) {
       OwnedAudioBufferListPtr buffer(allocateOwnedAudioBufferList(bufferCount, bytesPerBuffer));
       if (buffer == nullptr) {
-        rollbackFailedOpen();
-        return OpenFileResult::Err("Failed to preallocate iOS file writer buffers");
+        return Result<NoneType, std::string>::Err("Failed to preallocate iOS file writer buffers");
       }
       inputBufferPool_.push_back(std::move(buffer));
     }
@@ -135,22 +151,53 @@ OpenFileResult IOSFileWriter::openFile(
     freeSlots_ = std::make_unique<FreeList>();
     freeSlots_->seed();
 
-    isFileOpen_.store(true, std::memory_order_release);
-    return OpenFileResult::Ok([[fileURL_ path] UTF8String]);
+    return Result<NoneType, std::string>::Ok(None);
   }
 }
 
-void IOSFileWriter::rollbackFailedOpen()
+/// @brief Tears down the converter, conversion buffers and offloader, draining pending writes.
+void IOSFileWriter::releaseConversionPipeline()
 {
   offloader_.reset();
   freeSlots_.reset();
   inputBufferPool_.clear();
   inputBufferBytesPerBuffer_ = 0;
 
-  audioFile_ = nil;
   converter_ = nil;
   converterInputBuffer_ = nil;
   converterOutputBuffer_ = nil;
+}
+
+OpenFileResult IOSFileWriter::reopenForInputFormatChange(
+    AVAudioFormat *bufferFormat,
+    size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    if (!isFileOpen() || audioFile_ == nil) {
+      return openFile(bufferFormat, maxInputBufferLength, "");
+    }
+
+    // The file settings come from the recorder's file properties, not from the input, so the file
+    // stays open across a configuration change and the recording is not split. Only the conversion
+    // pipeline, which is built for the input format, is rebuilt.
+    releaseConversionPipeline();
+    bufferFormat_ = bufferFormat;
+
+    auto pipelineResult = prepareConversionPipeline(bufferFormat, maxInputBufferLength);
+
+    if (pipelineResult.is_err()) {
+      return OpenFileResult::Err(pipelineResult.unwrap_err());
+    }
+
+    return OpenFileResult::Ok([[fileURL_ path] UTF8String]);
+  }
+}
+
+void IOSFileWriter::rollbackFailedOpen()
+{
+  releaseConversionPipeline();
+
+  audioFile_ = nil;
   bufferFormat_ = nil;
 
   if (fileURL_ != nil) {

package/ios/audioapi/ios/core/utils/IOSRotatingFileWriter.h

@@ -30,6 +30,9 @@ class IOSRotatingFileWriter : public IOSFileWriter, public RotatingFileWriter {
       AVAudioFormat *streamFormat,
       size_t streamMaxBufferSizeInFrames,
       const std::string &fileNameOverride) override;
+  OpenFileResult reprepareStreamFormat(
+      AVAudioFormat *streamFormat,
+      size_t streamMaxBufferSizeInFrames);
   CloseFileResult closeFile() override;
   [[nodiscard]] double getCurrentDuration() const override;
 

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

@@ -46,6 +46,22 @@ OpenFileResult IOSRotatingFileWriter::openFile(
   return openInnerWriter();
 }
 
+OpenFileResult IOSRotatingFileWriter::reprepareStreamFormat(
+    AVAudioFormat *streamFormat,
+    size_t streamMaxBufferSizeInFrames)
+{
+  streamFormat_ = streamFormat;
+  streamMaxBufferSizeInFrames_ = streamMaxBufferSizeInFrames;
+
+  if (currentWriter_ == nullptr) {
+    currentWriter_ = writerFactory_(fileProperties_);
+    return openInnerWriter();
+  }
+
+  auto inner = std::static_pointer_cast<IOSFileWriter>(currentWriter_);
+  return inner->reopenForInputFormatChange(streamFormat_, streamMaxBufferSizeInFrames_);
+}
+
 void IOSRotatingFileWriter::writeAudioData(AudioDataType data, int numFrames)
 {
   if (currentWriter_ == nullptr) {

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

@@ -33,7 +33,8 @@ typedef NS_ENUM(NSInteger, AudioEngineState) {
                                  channelCount:(AVAudioChannelCount)channelCount;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
 
-- (void)attachInputNodeWithReceiverBlock:(AVAudioSinkNodeReceiverBlock)receiverBlock;
+- (void)attachInputNodeWithReceiverBlock:(AVAudioSinkNodeReceiverBlock)receiverBlock
+              onInputConfigurationChange:(void (^)(void))onInputConfigurationChange;
 - (void)detachInputNode;
 - (AVAudioFormat *)getLiveInputFormat;