react-native-audio-api 0.13.4 → 0.13.5

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

@@ -57,7 +57,6 @@ class RecorderAdapterNode : public AudioNode {
   AudioBuffer overflowBuffer_;
   size_t overflowSize_ = 0;
 
-  std::atomic<bool> isInitialized_{false};
   /// Incremented around each processNode() call; adapterCleanup waits for quiescence.
   std::atomic<uint32_t> currentProcesses_{0};
 };

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

@@ -2,6 +2,7 @@
 #import <AudioEngine.h>
 #import <AudioSessionManager.h>
 #import <Foundation/Foundation.h>
+#include <algorithm>
 #include <mutex>
 #include <unordered_map>
 #include <vector>
@@ -93,7 +94,9 @@ void IOSAudioRecorder::runSideEffects(const AudioBufferList *inputBuffer, int nu
 
   if (isConnected()) {
     if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
-      for (size_t channel = 0; channel < adapterNode_->getChannelCount(); ++channel) {
+      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);
       }
@@ -204,7 +207,6 @@ Result<NoneType, std::string> IOSAudioRecorder::reprepareFileWriter(
   }
 
   filePath_ = result.unwrap();
-  recordingSegmentPaths_.push_back(filePath_);
   fileOutputConfigured_.store(true, std::memory_order_release);
   return Result<NoneType, std::string>::Ok(None);
 }
@@ -237,6 +239,8 @@ void IOSAudioRecorder::reprepareAdapter(AVAudioFormat *inputFormat, int maxInput
     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),
@@ -407,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);
@@ -565,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

@@ -26,7 +26,7 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 - (void)pause;
 
-- (void)resume;
+- (BOOL)resume;
 
 - (void)cleanup;
 

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

@@ -164,18 +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]) {
-    if (self.onInputConfigurationChange != nil) {
-      self.onInputConfigurationChange();
-    } else {
-      self.inputArmed = YES;
-    }
+  if (![audioEngine startIfNecessary]) {
+    return NO;
   }
+
+  if (self.onInputConfigurationChange != nil) {
+    self.onInputConfigurationChange();
+  }
+
+  return YES;
 }
 
 - (void)cleanup

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

@@ -67,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,39 +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);
   }
 }
 
+/// @brief Tears down the converter, conversion buffers and offloader, draining pending writes.
+void IOSFileWriter::releaseConversionPipeline()
+{
+  offloader_.reset();
+  freeSlots_.reset();
+  inputBufferPool_.clear();
+  inputBufferBytesPerBuffer_ = 0;
+
+  converter_ = nil;
+  converterInputBuffer_ = nil;
+  converterOutputBuffer_ = nil;
+}
+
 OpenFileResult IOSFileWriter::reopenForInputFormatChange(
     AVAudioFormat *bufferFormat,
     size_t maxInputBufferLength)
 {
   @autoreleasepool {
-    if (isFileOpen()) {
-      auto closeResult = closeFile();
-      if (closeResult.is_err()) {
-        return OpenFileResult::Err(
-            "Failed to finalize recording segment: " + closeResult.unwrap_err());
-      }
+    if (!isFileOpen() || audioFile_ == nil) {
+      return openFile(bufferFormat, maxInputBufferLength, "");
     }
 
-    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()
 {
-  offloader_.reset();
-  freeSlots_.reset();
-  inputBufferPool_.clear();
-  inputBufferBytesPerBuffer_ = 0;
+  releaseConversionPipeline();
 
   audioFile_ = nil;
-  converter_ = nil;
-  converterInputBuffer_ = nil;
-  converterOutputBuffer_ = nil;
   bufferFormat_ = nil;
 
   if (fileURL_ != nil) {

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

@@ -58,13 +58,8 @@ OpenFileResult IOSRotatingFileWriter::reprepareStreamFormat(
     return openInnerWriter();
   }
 
-  rotateFiles();
-
-  if (currentWriter_ == nullptr) {
-    return OpenFileResult::Err("Failed to reopen file for writing after input format change");
-  }
-
-  return OpenFileResult::Ok(currentWriter_->getFilePath());
+  auto inner = std::static_pointer_cast<IOSFileWriter>(currentWriter_);
+  return inner->reopenForInputFormatChange(streamFormat_, streamMaxBufferSizeInFrames_);
 }
 
 void IOSRotatingFileWriter::writeAudioData(AudioDataType data, int numFrames)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.13.4",
+  "version": "0.13.5",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"