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

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/utils/IOSFileWriter.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/utils/Result.hpp>
+#include <memory>
+#include <string>
+#include <tuple>
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object NSURL;
+typedef struct objc_object NSString;
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object AVAudioFormat;
+typedef struct objc_object AudioBufferList;
+typedef struct objc_object AVAudioConverter;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+class IOSFileWriter : public AudioFileWriter {
+ public:
+  IOSFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~IOSFileWriter();
+
+  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;
+
+  std::string getFilePath() const override;
+
+ protected:
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+
+  AVAudioFile *audioFile_;
+  AVAudioFormat *bufferFormat_;
+  AVAudioConverter *converter_;
+  NSURL *fileURL_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi

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

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

@@ -0,0 +1,47 @@
+#pragma once
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object AVAudioFormat;
+typedef struct objc_object AudioBufferList;
+typedef struct objc_object AVAudioConverter;
+#endif
+
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+#include <audioapi/utils/Result.hpp>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class IOSRecorderCallback : public AudioRecorderCallback {
+ public:
+  IOSRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId);
+  ~IOSRecorderCallback();
+
+  Result<NoneType, std::string> prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  void cleanup() override;
+
+  void receiveAudioData(const AudioBufferList *audioBufferList, int numFrames);
+
+ protected:
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+
+  AVAudioFormat *bufferFormat_;
+  AVAudioFormat *callbackFormat_;
+  AVAudioConverter *converter_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi