react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.10

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

@@ -42,17 +42,35 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   return self;
 }
 
+// Note: this method should be called only after the session is activated
 - (AVAudioFormat *)getInputFormat
 {
-  return [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
+  AVAudioFormat *format = [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
+
+  if (format.sampleRate == 0 || format.channelCount == 0) {
+    AudioSessionManager *sessionManager = [AudioSessionManager sharedInstance];
+
+    format = [[AVAudioFormat alloc]
+        initStandardFormatWithSampleRate:[[sessionManager getDevicePreferredSampleRate] doubleValue]
+                                channels:[[sessionManager getDevicePreferredInputChannelCount]
+                                             intValue]];
+  }
+
+  return format;
 }
 
 - (int)getBufferSize
 {
   // NOTE: this method should be called only after the session is activated
   AVAudioSession *audioSession = [AVAudioSession sharedInstance];
-  float bufferDuration = audioSession.IOBufferDuration > 0 ? audioSession.IOBufferDuration : 0.02;
 
+  // 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);
+
+  // IOS returns buffer duration rounded, but expects the buffer size to be power of two in runtime
   return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
 }
 
@@ -61,14 +79,15 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   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
-  [audioEngine stopEngine];
+  [audioEngine stopIfNecessary];
   [audioEngine attachInputNode:self.sinkNode];
   [audioEngine startIfNecessary];
 }
@@ -78,7 +97,30 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
   [audioEngine detachInputNode];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
+
+  // 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

@@ -9,7 +9,9 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/libs/audio-stretch/stretch.h>
 #include <audioapi/libs/base64/base64.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
@@ -63,19 +65,27 @@ 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"})) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       NSLog(@"Failed to decode with FFmpeg: %s", path.c_str());
       return nullptr;
     }
     return buffer;
+#else
+    NSLog(@"FFmpeg is disabled, cannot decode file: %s", path.c_str());
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   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_decoding_backend_vtable *customBackends[] = {
+      ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
   config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
@@ -94,21 +104,28 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(const std::string
   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) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       NSLog(@"Failed to decode with FFmpeg");
       return nullptr;
     }
     return buffer;
+#else
+    NSLog(@"FFmpeg is disabled, cannot decode memory block");
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   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_decoding_backend_vtable *customBackends[] = {
+      ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
   config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object NSURL;
+typedef struct objc_object AudioBufferList;
+#endif // __OBJC__
+
+#include <memory>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace ios::fileoptions {
+
+AudioFormatID getFormat(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getQuality(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &properties);
+NSString *getFileExtension(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getBitDepth(const std::shared_ptr<AudioFileProperties> &properties);
+float getSampleRate(const std::shared_ptr<AudioFileProperties> &properties);
+
+NSDictionary *getFileSettings(const std::shared_ptr<AudioFileProperties> &properties);
+NSURL *getFileURL(const std::shared_ptr<AudioFileProperties> &properties);
+NSSearchPathDirectory getDirectory(const std::shared_ptr<AudioFileProperties> &properties);
+
+NSString *getDateString();
+NSString *getTimestampString();
+
+} // namespace ios::fileoptions
+
+} // namespace audioapi

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

@@ -0,0 +1,195 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+namespace audioapi::ios::fileoptions {
+
+/// @brief Maps AudioFileProperties to iOS AVFoundation AudioFormatID.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns Corresponding AudioFormatID for AVFoundation.
+AudioFormatID getFormat(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return kAudioFormatLinearPCM;
+
+    case AudioFileProperties::Format::CAF:
+      return kAudioFormatLinearPCM;
+
+    case AudioFileProperties::Format::M4A:
+      return kAudioFormatMPEG4AAC;
+
+    case AudioFileProperties::Format::FLAC:
+      return kAudioFormatFLAC;
+
+    default:
+      return kAudioFormatLinearPCM;
+  }
+}
+
+/// @brief Maps AudioFileProperties to iOS AVFoundation audio quality settings.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns Corresponding NSInteger value for AVAudioQuality.
+NSInteger getQuality(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->iosAudioQuality) {
+    case AudioFileProperties::IOSAudioQuality::Min:
+      return AVAudioQualityMin;
+
+    case AudioFileProperties::IOSAudioQuality::Low:
+      return AVAudioQualityLow;
+
+    case AudioFileProperties::IOSAudioQuality::Medium:
+      return AVAudioQualityMedium;
+
+    case AudioFileProperties::IOSAudioQuality::High:
+      return AVAudioQualityHigh;
+
+    case AudioFileProperties::IOSAudioQuality::Max:
+      return AVAudioQualityMax;
+
+    default:
+      return AVAudioQualityMedium;
+  }
+}
+
+/// @brief Retrieves the FLAC compression level from AudioFileProperties.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns NSInteger representing the FLAC compression level.
+NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  return properties->flacCompressionLevel;
+}
+
+/// @brief Retrieves the file extension based on AudioFileProperties format.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns NSString representing the file extension.
+NSString *getFileExtension(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return @"wav";
+
+    case AudioFileProperties::Format::CAF:
+      return @"caf";
+
+    case AudioFileProperties::Format::M4A:
+      return @"m4a";
+
+    case AudioFileProperties::Format::FLAC:
+      return @"flac";
+
+    default:
+      return @"wav";
+  }
+}
+
+/// @brief Retrieves the bit depth from AudioFileProperties.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns NSInteger representing the bit depth.
+NSInteger getBitDepth(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return 16;
+
+    case AudioFileProperties::BitDepth::Bit24:
+      return 24;
+
+    case AudioFileProperties::BitDepth::Bit32:
+      return 32;
+
+    default:
+      return 32;
+  }
+}
+
+/// @brief Constructs AVFoundation file settings dictionary from AudioFileProperties.
+/// @param properties Shared pointer to AudioFileProperties.
+/// @returns NSDictionary containing AVFoundation audio file settings.
+NSDictionary *getFileSettings(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  AudioFormatID format = getFormat(properties);
+  NSMutableDictionary *settings = [NSMutableDictionary dictionary];
+
+  settings[AVFormatIDKey] = @(format);
+  settings[AVSampleRateKey] = @(properties->sampleRate);
+  settings[AVNumberOfChannelsKey] = @(properties->channelCount);
+  settings[AVEncoderAudioQualityKey] = @(getQuality(properties));
+
+  if (format == kAudioFormatMPEG4AAC) {
+    settings[AVEncoderBitRateKey] = @(properties->bitRate);
+  }
+
+  if (format == kAudioFormatLinearPCM) {
+    NSInteger bitDepth = getBitDepth(properties);
+
+    settings[AVLinearPCMBitDepthKey] = @(bitDepth);
+    settings[AVLinearPCMIsFloatKey] = @(bitDepth == 32);
+    settings[AVLinearPCMIsBigEndianKey] = @(NO);
+    settings[AVLinearPCMIsNonInterleaved] = @(NO);
+  }
+
+  if (format == kAudioFormatFLAC) {
+    settings[@"FLACCompressionLevel"] = @(getFlacCompressionLevel(properties));
+  }
+
+  return settings;
+}
+
+NSURL *getFileURL(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  NSError *error = nil;
+
+  NSSearchPathDirectory directory = getDirectory(properties);
+  NSString *subDirectory = [NSString stringWithUTF8String:properties->subDirectory.c_str()];
+
+  NSURL *baseURL = [[[NSFileManager defaultManager] URLsForDirectory:directory
+                                                           inDomains:NSUserDomainMask] firstObject];
+  NSURL *directoryURL = [baseURL URLByAppendingPathComponent:subDirectory isDirectory:YES];
+
+  [[NSFileManager defaultManager] createDirectoryAtURL:directoryURL
+                           withIntermediateDirectories:YES
+                                            attributes:nil
+                                                 error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error creating directory for audio recordings: %@", [error debugDescription]);
+    directoryURL = baseURL;
+  }
+
+  NSString *fileNamePrefix = [NSString stringWithUTF8String:properties->fileNamePrefix.c_str()];
+  NSString *timestamp = getTimestampString();
+  NSString *fileExtension = getFileExtension(properties);
+
+  NSString *fileName =
+      [NSString stringWithFormat:@"%@_%@.%@", fileNamePrefix, timestamp, fileExtension];
+  return [directoryURL URLByAppendingPathComponent:fileName];
+}
+
+NSSearchPathDirectory getDirectory(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->directory) {
+    case AudioFileProperties::FileDirectory::Document:
+      return NSDocumentDirectory;
+
+    case AudioFileProperties::FileDirectory::Cache:
+      return NSCachesDirectory;
+
+    default:
+      return NSCachesDirectory;
+  }
+}
+
+NSString *getTimestampString()
+{
+  NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
+  fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+  fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"]; // or local if you prefer
+  fmt.dateFormat = @"yyyyMMdd_HHmmss_SSS";
+  return [fmt stringFromDate:[NSDate date]];
+}
+
+} // namespace audioapi::ios::fileoptions

package/ios/audioapi/ios/core/{IOSAudioFileWriter.h → utils/IOSFileWriter.h}

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/utils/Result.hpp>
 #include <memory>
 #include <string>
 #include <tuple>
@@ -15,30 +17,30 @@ typedef struct objc_object AVAudioConverter;
 
 namespace audioapi {
 
-class IOSAudioFileOptions;
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
 
-class IOSAudioFileWriter {
+class IOSFileWriter : public AudioFileWriter {
  public:
-  IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags);
-  ~IOSAudioFileWriter();
+  IOSFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~IOSFileWriter();
 
-  std::string openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
-  std::tuple<double, double> closeFile();
+  Result<std::string, std::string> openFile(
+      AVAudioFormat *bufferFormat,
+      size_t maxInputBufferLength);
+  Result<std::tuple<double, double>, std::string> closeFile() override;
 
   bool writeAudioData(const AudioBufferList *audioBufferList, int numFrames);
+  double getCurrentDuration() const override;
 
-  double getCurrentDuration() const;
+  std::string getFilePath() const override;
 
- private:
+ protected:
   size_t converterInputBufferSize_;
   size_t converterOutputBufferSize_;
-  std::atomic<size_t> framesWritten_{0};
 
-  NSString *getISODateStringForDirectory();
-  NSString *getTimestampForFilename();
-  NSURL *getFileURL();
-
-  std::shared_ptr<IOSAudioFileOptions> fileOptions_;
   AVAudioFile *audioFile_;
   AVAudioFormat *bufferFormat_;
   AVAudioConverter *converter_;

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

@@ -0,0 +1,239 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/ios/core/utils/IOSFileWriter.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/Result.hpp>
+#include <audioapi/utils/UnitConversion.h>
+
+namespace audioapi {
+IOSFileWriter::IOSFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : AudioFileWriter(audioEventHandlerRegistry, fileProperties)
+{
+}
+
+IOSFileWriter::~IOSFileWriter()
+{
+  @autoreleasepool {
+    fileURL_ = nil;
+    audioFile_ = nil;
+    converter_ = nil;
+    bufferFormat_ = nil;
+  }
+}
+
+/// @brief Opens an audio file for writing with the specified buffer format and maximum input buffer length.
+/// This method initializes the AVAudioFile and AVAudioConverter for audio data writing and conversion.
+/// This method should be called from the JS thread only.
+/// @param bufferFormat The audio format of the input buffer.
+/// @param maxInputBufferLength The maximum length of the input buffer in frames.
+/// @returns An OpenFileResult indicating success with the file path or an error message.
+OpenFileResult IOSFileWriter::openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    if (audioFile_ != nil) {
+      return OpenFileResult::Err("file already open");
+    }
+
+    framesWritten_.store(0, std::memory_order_release);
+    bufferFormat_ = bufferFormat;
+
+    NSError *error = nil;
+    NSDictionary *settings = ios::fileoptions::getFileSettings(fileProperties_);
+    fileURL_ = ios::fileoptions::getFileURL(fileProperties_);
+
+    if (fileProperties_->sampleRate == 0 || fileProperties_->channelCount == 0) {
+      return OpenFileResult::Err(
+          "Invalid file properties: sampleRate and channelCount must be greater than 0");
+    }
+
+    if (bufferFormat.sampleRate == 0 || bufferFormat.channelCount == 0) {
+      return OpenFileResult::Err(
+          "Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+
+    audioFile_ = [[AVAudioFile alloc] initForWriting:fileURL_
+                                            settings:settings
+                                        commonFormat:AVAudioPCMFormatFloat32
+                                         interleaved:bufferFormat.interleaved
+                                               error:&error];
+
+    if (error != nil) {
+      return OpenFileResult::Err(
+          std::string("Error creating audio file for writing: ") +
+          [[error debugDescription] UTF8String]);
+    }
+
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat
+                                                 toFormat:[audioFile_ processingFormat]];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    converterInputBufferSize_ = maxInputBufferLength;
+    converterOutputBufferSize_ = std::max(
+        (double)maxInputBufferLength,
+        fileProperties_->sampleRate / bufferFormat.sampleRate * maxInputBufferLength);
+
+    converterInputBuffer_ =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat
+                                      frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
+    converterOutputBuffer_ =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile_ processingFormat]
+                                      frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
+
+    if (converterInputBuffer_ == nil || converterOutputBuffer_ == nil || audioFile_ == nil ||
+        converter_ == nil) {
+      audioFile_ = nil;
+      converter_ = nil;
+      converterInputBuffer_ = nil;
+      converterOutputBuffer_ = nil;
+
+      return OpenFileResult::Err("Error creating converter buffers");
+    }
+
+    return OpenFileResult::Ok([[fileURL_ path] UTF8String]);
+  }
+}
+
+/// @brief Closes the currently open audio file and finalizes writing.
+/// This method retrieves the final file duration and size before closing.
+/// This method should be called from the JS thread only.
+/// @returns A CloseFileResult indicating success with file duration and size or an error message.
+CloseFileResult IOSFileWriter::closeFile()
+{
+  @autoreleasepool {
+    NSError *error;
+    std::string filePath = [[fileURL_ path] UTF8String];
+
+    if (audioFile_ == nil) {
+      return CloseFileResult::Err("file is not open: " + filePath);
+    }
+
+    // AVAudioFile automatically finalizes the file when deallocated
+    audioFile_ = nil;
+
+    double fileDuration = CMTimeGetSeconds([[AVURLAsset URLAssetWithURL:fileURL_
+                                                                options:nil] duration]);
+    double fileSizeBytesMb = static_cast<double>([[[NSFileManager defaultManager]
+                                 attributesOfItemAtPath:fileURL_.path
+                                                  error:&error] fileSize]) /
+        MB_IN_BYTES;
+
+    if (error != nil) {
+      NSLog(@"⚠️ closeFile: error while retrieving file size");
+      fileSizeBytesMb = 0;
+    }
+
+    fileURL_ = nil;
+    framesWritten_.store(0, std::memory_order_release);
+
+    return CloseFileResult::Ok(std::make_tuple(fileDuration, fileSizeBytesMb));
+  }
+}
+
+/// @brief Writes audio data to the open audio file, performing format conversion if necessary.
+/// This method should be called from the audio thread.
+/// @param audioBufferList Pointer to the AudioBufferList containing the audio data to write.
+/// @param numFrames Number of audio frames in the audioBufferList.
+/// @returns True if the write operation was successful, false otherwise.
+bool IOSFileWriter::writeAudioData(const AudioBufferList *audioBufferList, int numFrames)
+{
+  if (audioFile_ == nil) {
+    invokeOnErrorCallback("Attempted to write audio data when file is not open");
+    return false;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+    AVAudioFormat *fileFormat = [audioFile_ processingFormat];
+
+    if (bufferFormat_.sampleRate == fileFormat.sampleRate &&
+        bufferFormat_.channelCount == fileFormat.channelCount &&
+        bufferFormat_.isInterleaved == fileFormat.isInterleaved) {
+      // We can use the converter input buffer as a "transport" layer to the file
+      for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+        memcpy(
+            converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mDataByteSize);
+      }
+      converterInputBuffer_.frameLength = numFrames;
+
+      [audioFile_ writeFromBuffer:converterInputBuffer_ error:&error];
+
+      if (error != nil) {
+        invokeOnErrorCallback(
+            std::string("Error writing audio data to file, native error: ") +
+            [[error debugDescription] UTF8String]);
+        return false;
+      }
+
+      framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+      return true;
+    }
+
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mDataByteSize);
+    }
+
+    converterInputBuffer_.frameLength = numFrames;
+
+    __block BOOL handedOff = false;
+    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
+        AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      if (handedOff) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+
+      handedOff = true;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+    converterOutputBuffer_.frameLength =
+        fileProperties_->sampleRate / bufferFormat_.sampleRate * numFrames;
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error during audio conversion, native error: ") +
+          [[error debugDescription] UTF8String]);
+      return false;
+    }
+
+    [audioFile_ writeFromBuffer:converterOutputBuffer_ error:&error];
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error writing audio data to file, native error: ") +
+          [[error debugDescription] UTF8String]);
+      return false;
+    }
+
+    framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+    return true;
+  }
+}
+
+double IOSFileWriter::getCurrentDuration() const
+{
+  return static_cast<double>(framesWritten_.load(std::memory_order_acquire)) /
+      bufferFormat_.sampleRate;
+}
+
+std::string IOSFileWriter::getFilePath() const
+{
+  return [[fileURL_ path] UTF8String];
+}
+
+} // namespace audioapi