react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

package/ios/audioapi/ios/core/IOSAudioFileOptions.mm

@@ -0,0 +1,140 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/IOSAudioFileOptions.h>
+
+namespace audioapi {
+
+IOSAudioFileOptions::IOSAudioFileOptions(float sampleRate, size_t channelCount, size_t bitRate, size_t flags)
+{
+  sampleRate_ = sampleRate;
+  channelCount_ = channelCount;
+  bitRate_ = bitRate;
+
+  format_ = static_cast<uint8_t>(((flags >> 0) & 0xF));
+  quality_ = static_cast<uint8_t>(((flags >> 4) & 0xF));
+  flacCompressionLevel_ = static_cast<uint8_t>(((flags >> 8) & 0xF));
+  directory_ = static_cast<uint8_t>(((flags >> 12) & 0xF));
+  bitDepth_ = static_cast<uint8_t>(((flags >> 16) & 0xF));
+}
+
+AudioFormatID IOSAudioFileOptions::getFormat() const
+{
+  switch (format_) {
+    case 1:
+      return kAudioFormatLinearPCM; // WAV <-> Linear PCM container
+    case 2:
+      return kAudioFormatLinearPCM; // CAF <-> Linear PCM container
+    case 3:
+      return kAudioFormatMPEG4AAC; // M4A <-> AAC
+    case 4:
+      return kAudioFormatFLAC; // FLAC <-> FLAC
+    default:
+      return kAudioFormatLinearPCM; // Default to Linear PCM
+  }
+}
+
+NSInteger IOSAudioFileOptions::getQuality() const
+{
+  switch (quality_) {
+    case 1:
+      return AVAudioQualityMin;
+    case 2:
+      return AVAudioQualityLow;
+    case 3:
+      return AVAudioQualityMedium;
+    case 4:
+      return AVAudioQualityHigh;
+    case 5:
+      return AVAudioQualityMax;
+    default:
+      return AVAudioQualityMedium; // Default to Medium
+  }
+}
+
+NSInteger IOSAudioFileOptions::getFlacCompressionLevel() const
+{
+  // Shift the quality from 1-9 to 0-8 for real values
+  // Default to 5 if out of range
+  return (flacCompressionLevel_ >= 1 && flacCompressionLevel_ <= 9) ? flacCompressionLevel_ - 1 : 5;
+}
+
+NSSearchPathDirectory IOSAudioFileOptions::getDirectory() const
+{
+  switch (directory_) {
+    case 1:
+      return NSDocumentDirectory;
+    case 2:
+      return NSCachesDirectory;
+    default:
+      return NSCachesDirectory; // Default to Caches
+  }
+}
+
+NSString *IOSAudioFileOptions::getFileExtension() const
+{
+  switch (format_) {
+    case 1:
+      return @"wav"; // WAV <-> Linear PCM container
+    case 2:
+      return @"caf"; // CAF <-> Linear PCM container
+    case 3:
+      return @"m4a"; // M4A <-> AAC
+    case 4:
+      return @"flac"; // FLAC <-> FLAC
+    default:
+      return @"wav"; // Default to WAV
+  }
+}
+
+NSInteger IOSAudioFileOptions::getBitDepth() const
+{
+  switch (bitDepth_) {
+    case 1:
+      return 16;
+    case 2:
+      return 24;
+    case 3:
+      return 32;
+    default:
+      return 24; // Default to 24-bit
+  }
+}
+
+NSDictionary *IOSAudioFileOptions::getFileSettings()
+{
+  AudioFormatID format = getFormat();
+  NSMutableDictionary *settings = [NSMutableDictionary dictionary];
+
+  settings[AVFormatIDKey] = @(format);
+  settings[AVSampleRateKey] = @(sampleRate_);
+  settings[AVNumberOfChannelsKey] = @(channelCount_);
+
+  settings[AVEncoderAudioQualityKey] = @(getQuality());
+
+  if (format == kAudioFormatMPEG4AAC) {
+    settings[AVEncoderBitRateKey] = @(bitRate_);
+  }
+
+  if (format == kAudioFormatLinearPCM) {
+    NSInteger bitDepth = getBitDepth();
+
+    settings[AVLinearPCMBitDepthKey] = @(bitDepth);
+    settings[AVLinearPCMIsFloatKey] = @(bitDepth == 32);
+    settings[AVLinearPCMIsBigEndianKey] = @(NO);
+    settings[AVLinearPCMIsNonInterleaved] = @(NO);
+  }
+
+  if (format == kAudioFormatFLAC) {
+    settings[@"FLACCompressionLevel"] = @(getFlacCompressionLevel());
+  }
+
+  return settings;
+}
+
+float IOSAudioFileOptions::getSampleRate()
+{
+  return sampleRate_;
+}
+
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioFileWriter.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#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 IOSAudioFileOptions;
+
+class IOSAudioFileWriter {
+ public:
+  IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags);
+  ~IOSAudioFileWriter();
+
+  std::string openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  std::tuple<double, double> closeFile();
+
+  bool writeAudioData(const AudioBufferList *audioBufferList, int numFrames);
+
+  double getCurrentDuration() const;
+
+ private:
+  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_;
+  NSURL *fileURL_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioFileWriter.mm

@@ -0,0 +1,223 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/IOSAudioFileOptions.h>
+#include <audioapi/ios/core/IOSAudioFileWriter.h>
+
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
+namespace audioapi {
+IOSAudioFileWriter::IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags)
+{
+  fileOptions_ = std::make_shared<IOSAudioFileOptions>(sampleRate, channelCount, bitRate, iosFlags);
+}
+
+IOSAudioFileWriter::~IOSAudioFileWriter()
+{
+  fileURL_ = nil;
+  audioFile_ = nil;
+  converter_ = nil;
+  bufferFormat_ = nil;
+}
+
+std::string IOSAudioFileWriter::openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    if (audioFile_ != nil) {
+      NSLog(@"⚠️ createFileForWriting: currentAudioFile_ already exists");
+      return "";
+    }
+    framesWritten_.store(0);
+
+    bufferFormat_ = bufferFormat;
+
+    NSError *error = nil;
+    NSDictionary *settings = fileOptions_->getFileSettings();
+    fileURL_ = getFileURL();
+
+    NSLog(@"ℹ️ Creating audio file at URL: %@", [fileURL_ absoluteString]);
+
+    audioFile_ = [[AVAudioFile alloc] initForWriting:fileURL_
+                                            settings:settings
+                                        commonFormat:AVAudioPCMFormatFloat32
+                                         interleaved:bufferFormat.interleaved
+                                               error:&error];
+    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, fileOptions_->getSampleRate() / bufferFormat.sampleRate * maxInputBufferLength);
+
+    converterInputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat
+                                                          frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
+    converterOutputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile_ processingFormat]
+                                                           frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
+
+    if (error != nil || audioFile_ == nil) {
+      NSLog(@"Error creating audio file for writing: %@", [error debugDescription]);
+      audioFile_ = nil;
+
+      return "";
+    }
+
+    return [[fileURL_ path] UTF8String];
+  }
+}
+
+std::tuple<double, double> IOSAudioFileWriter::closeFile()
+{
+  @autoreleasepool {
+    NSError *error;
+    std::string filePath = [[fileURL_ path] UTF8String];
+
+    if (audioFile_ == nil) {
+      return {0, 0};
+    }
+
+    // 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]) /
+        BYTES_TO_MB;
+
+    NSLog(
+        @"ℹ️ Closed audio file at path: %s, duration: %.2f sec, size: %.2f MB",
+        filePath.c_str(),
+        fileDuration,
+        fileSizeBytesMb);
+
+    if (error != nil) {
+      NSLog(@"⚠️ closeFile: error while retrieving file size");
+      fileSizeBytesMb = 0;
+    }
+
+    fileURL_ = nil;
+
+    return {fileSizeBytesMb, fileDuration};
+  }
+}
+
+bool IOSAudioFileWriter::writeAudioData(const AudioBufferList *audioBufferList, int numFrames)
+{
+  if (audioFile_ == nil) {
+    NSLog(@"⚠️ writeAudioData: audioFile is nil, cannot write data");
+    return false;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+    AVAudioFormat *fileFormat = [audioFile_ processingFormat];
+
+    if (bufferFormat_.sampleRate == fileFormat.sampleRate && bufferFormat_.channelCount == fileFormat.channelCount &&
+        bufferFormat_.isInterleaved == fileFormat.isInterleaved) {
+      AVAudioPCMBuffer *processingBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:fileFormat
+                                                                      bufferListNoCopy:audioBufferList
+                                                                           deallocator:NULL];
+      processingBuffer.frameLength = (AVAudioFrameCount)numFrames;
+
+      [audioFile_ writeFromBuffer:processingBuffer error:&error];
+
+      if (error != nil) {
+        NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
+        return false;
+      }
+
+      framesWritten_.fetch_add(numFrames);
+      return true;
+    }
+
+    size_t outputFrameCount = ceil(numFrames * fileFormat.sampleRate / bufferFormat_.sampleRate);
+
+    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;
+
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      // this line is probably an delusion, but for my sanity lets keep it
+      inNumberOfPackets = numFrames;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+
+    if (error != nil) {
+      NSLog(@"Error during audio conversion: %@", [error debugDescription]);
+      return false;
+    }
+
+    [audioFile_ writeFromBuffer:converterOutputBuffer_ error:&error];
+
+    if (error != nil) {
+      NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
+      return false;
+    }
+
+    framesWritten_.fetch_add(numFrames);
+    return true;
+  }
+}
+
+NSString *IOSAudioFileWriter::getISODateStringForDirectory()
+{
+  NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
+  fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+  fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"]; // or local if you prefer
+  fmt.dateFormat = @"yyyy-MM-dd";
+  return [fmt stringFromDate:[NSDate date]];
+}
+
+NSString *IOSAudioFileWriter::getTimestampForFilename()
+{
+  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]];
+}
+
+NSURL *IOSAudioFileWriter::getFileURL()
+{
+  NSError *error = nil;
+
+  NSSearchPathDirectory searchDirectory = fileOptions_->getDirectory();
+  NSString *directory = [NSString stringWithFormat:@"AudioAPI/%@", getISODateStringForDirectory()];
+
+  NSURL *baseURL = [[[NSFileManager defaultManager] URLsForDirectory:searchDirectory
+                                                           inDomains:NSUserDomainMask] firstObject];
+  NSURL *dirURL = [baseURL URLByAppendingPathComponent:directory isDirectory:YES];
+
+  [[NSFileManager defaultManager] createDirectoryAtURL:dirURL
+                           withIntermediateDirectories:YES
+                                            attributes:nil
+                                                 error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error creating directory for audio recordings: %@", [error debugDescription]);
+    dirURL = baseURL;
+  }
+
+  NSString *fileName =
+      [NSString stringWithFormat:@"audio_%@.%@", getTimestampForFilename(), fileOptions_->getFileExtension()];
+  return [dirURL URLByAppendingPathComponent:fileName];
+}
+
+double IOSAudioFileWriter::getCurrentDuration() const
+{
+  return static_cast<double>(framesWritten_.load()) / bufferFormat_.sampleRate;
+}
+
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -1,8 +1,11 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as C++
 #import <NativeAudioRecorder.h>
-#else // when compiled as C++
+#else
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object NSURL;
+typedef struct objc_object AudioBufferList;
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
@@ -12,21 +15,36 @@ namespace audioapi {
 
 class AudioBus;
 class CircularAudioArray;
+class IOSAudioFileWriter;
+class IOSRecorderCallback;
+class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
-  IOSAudioRecorder(
-      float sampleRate,
-      int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-
+  IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~IOSAudioRecorder() override;
 
-  void start() override;
-  void stop() override;
+  std::string start() override;
+  std::tuple<std::string, double, double> stop() override;
+
+  void enableFileOutput(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags, size_t androidFlags)
+      override;
+  void disableFileOutput() override;
+
+  void pause() override;
+  void resume() override;
+
+  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  double getCurrentDuration() const override;
 
  private:
-  NativeAudioRecorder *audioRecorder_;
+  std::shared_ptr<IOSAudioFileWriter> fileWriter_;
+  std::shared_ptr<IOSRecorderCallback> callback_;
+  std::string filePath_{""};
+  NativeAudioRecorder *nativeRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,70 +1,157 @@
 #import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+#include <unordered_map>
 
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/IOSAudioFileWriter.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
+#include <audioapi/ios/core/IOSRecorderCallback.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
-#include <unordered_map>
 
 namespace audioapi {
 
-IOSAudioRecorder::IOSAudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
+IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
 {
-  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()) {
+      fileWriter_->writeAudioData(inputBuffer, numFrames);
     }
 
-    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-      auto *outputChannel = bus->getChannel(0)->getData();
-
-      circularBuffer_->pop_front(outputChannel, bufferLength_);
-
-      invokeOnAudioReadyCallback(bus, bufferLength_);
+    if (usesCallback()) {
+      callback_->receiveAudioData(inputBuffer, numFrames);
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [audioRecorder_ cleanup];
+  [nativeRecorder_ cleanup];
+}
+std::string IOSAudioRecorder::start()
+{
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+
+  if (isRecording()) {
+    return filePath_;
+  }
+
+  if (usesFileOutput()) {
+    filePath_ = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
+  }
+
+  if (usesCallback()) {
+    callback_->prepare([nativeRecorder_ getInputFormat], maxInputBufferLength);
+  }
+
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  [nativeRecorder_ start];
+  state_.store(RecorderState::Recording);
+
+  return filePath_;
 }
 
-void IOSAudioRecorder::start()
+std::tuple<std::string, double, double> IOSAudioRecorder::stop()
 {
-  if (isRunning_.load()) {
+  std::string filePath = filePath_;
+  double outputFileSize = 0;
+  double outputDuration = 0;
+
+  if (!isRecording()) {
+    return {filePath, 0, 0};
+  }
+
+  [nativeRecorder_ stop];
+  state_.store(RecorderState::Idle);
+
+  if (usesFileOutput()) {
+    auto [size, duration] = fileWriter_->closeFile();
+    outputFileSize = size;
+    outputDuration = duration;
+  }
+
+  if (usesCallback()) {
+    callback_->cleanup();
+  }
+
+  filePath_ = "";
+  return {filePath, outputFileSize, outputDuration};
+}
+
+void IOSAudioRecorder::enableFileOutput(
+    float sampleRate,
+    size_t channelCount,
+    size_t bitRate,
+    size_t iosFlags,
+    size_t androidFlags)
+{
+  fileOutputEnabled_.store(true);
+  fileWriter_ = std::make_shared<IOSAudioFileWriter>(sampleRate, channelCount, bitRate, iosFlags);
+}
+
+void IOSAudioRecorder::disableFileOutput()
+{
+  fileOutputEnabled_.store(false);
+  fileWriter_ = nullptr;
+}
+
+void IOSAudioRecorder::pause()
+{
+  if (!isRecording()) {
     return;
   }
 
-  [audioRecorder_ start];
-  isRunning_.store(true);
+  [nativeRecorder_ stop];
+  state_.store(RecorderState::Paused);
 }
 
-void IOSAudioRecorder::stop()
+void IOSAudioRecorder::resume()
 {
-  if (!isRunning_.load()) {
+  if (!isPaused()) {
     return;
   }
 
-  isRunning_.store(false);
-  [audioRecorder_ stop];
+  [nativeRecorder_ start];
+  state_.store(RecorderState::Recording);
+}
+
+void IOSAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+{
+  callback_ = std::make_shared<IOSRecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+  callbackOutputEnabled_.store(true);
+}
+
+void IOSAudioRecorder::clearOnAudioReadyCallback()
+{
+  callbackOutputEnabled_.store(false);
+  callback_ = nullptr;
+}
+
+double IOSAudioRecorder::getCurrentDuration() const
+{
+  double duration = 0.0;
+
+  if (usesFileOutput() && fileWriter_) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  sendRemainingData();
+  return duration;
 }
 
 } // namespace audioapi