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

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

@@ -0,0 +1,224 @@
+#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;
+  }
+}
+
+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]);
+  }
+}
+
+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));
+  }
+}
+
+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/{IOSRecorderCallback.h → utils/IOSRecorderCallback.h}

@@ -6,6 +6,8 @@ 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>
 
@@ -15,37 +17,25 @@ class AudioBus;
 class CircularAudioArray;
 class AudioEventHandlerRegistry;
 
-class IOSRecorderCallback {
+class IOSRecorderCallback : public AudioRecorderCallback {
  public:
   IOSRecorderCallback(
       const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       float sampleRate,
       size_t bufferLength,
-      size_t channelCount,
+      int channelCount,
       uint64_t callbackId);
   ~IOSRecorderCallback();
 
-  void prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
-  void cleanup();
+  Result<NoneType, std::string> prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  void cleanup() override;
 
   void receiveAudioData(const AudioBufferList *audioBufferList, int numFrames);
-  void emitAudioData();
 
-  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
-
- private:
-  float sampleRate_;
-  size_t bufferLength_;
-  size_t channelCount_;
-  uint64_t callbackId_;
-  size_t ringBufferSize_;
+ protected:
   size_t converterInputBufferSize_;
   size_t converterOutputBufferSize_;
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
-
   AVAudioFormat *bufferFormat_;
   AVAudioFormat *callbackFormat_;
   AVAudioConverter *converter_;

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

@@ -0,0 +1,172 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/utils/IOSRecorderCallback.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/Result.hpp>
+#include <algorithm>
+
+namespace audioapi {
+
+IOSRecorderCallback::IOSRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : AudioRecorderCallback(
+          audioEventHandlerRegistry,
+          sampleRate,
+          bufferLength,
+          channelCount,
+          callbackId)
+{
+}
+
+IOSRecorderCallback::~IOSRecorderCallback()
+{
+  @autoreleasepool {
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (int i = 0; i < channelCount_; ++i) {
+      circularBus_[i]->zero();
+    }
+  }
+}
+
+Result<NoneType, std::string> IOSRecorderCallback::prepare(
+    AVAudioFormat *bufferFormat,
+    size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    bufferFormat_ = bufferFormat;
+    converterInputBufferSize_ = maxInputBufferLength;
+
+    if (bufferFormat.sampleRate <= 0 || bufferFormat.channelCount == 0) {
+      return Result<NoneType, std::string>::Err(
+          "Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+
+    if (sampleRate_ <= 0 || channelCount_ == 0) {
+      return Result<NoneType, std::string>::Err(
+          "Invalid callback format: sampleRate and channelCount must be greater than 0");
+    }
+
+    converterOutputBufferSize_ = std::max(
+        (double)maxInputBufferLength, sampleRate_ / bufferFormat.sampleRate * maxInputBufferLength);
+
+    callbackFormat_ = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                       sampleRate:sampleRate_
+                                                         channels:channelCount_
+                                                      interleaved:NO];
+
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat toFormat:callbackFormat_];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    converterInputBuffer_ =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat_
+                                      frameCapacity:(AVAudioFrameCount)converterInputBufferSize_];
+    converterOutputBuffer_ =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:callbackFormat_
+                                      frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+void IOSRecorderCallback::cleanup()
+{
+  @autoreleasepool {
+    emitAudioData(true);
+
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (int i = 0; i < channelCount_; ++i) {
+      circularBus_[i]->zero();
+    }
+  }
+}
+
+void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+{
+  if (!isInitialized_.load(std::memory_order_acquire)) {
+    return;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+
+    if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
+        !bufferFormat_.isInterleaved) {
+      // Directly write to circular buffer
+      for (int i = 0; i < channelCount_; ++i) {
+        auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[i].mData);
+        circularBus_[i]->push_back(inputChannel, numFrames);
+      }
+
+      emitAudioData();
+      return;
+    }
+
+    size_t outputFrameCount = ceil(numFrames * (sampleRate_ / bufferFormat_.sampleRate));
+
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          inputBuffer->mBuffers[i].mData,
+          inputBuffer->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 = sampleRate_ / bufferFormat_.sampleRate * numFrames;
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error during audio conversion, native error: ") +
+          [[error debugDescription] UTF8String]);
+      return;
+    }
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *inputChannel =
+          static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
+      circularBus_[i]->push_back(inputChannel, outputFrameCount);
+    }
+
+    emitAudioData();
+  }
+}
+
+} // namespace audioapi

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

@@ -5,30 +5,26 @@
 
 @class AudioSessionManager;
 
+typedef NS_ENUM(NSInteger, AudioEngineState) {
+  AudioEngineStateIdle = 0,
+  AudioEngineStateRunning,
+  AudioEngineStatePaused,
+  AudioEngineStateInterrupted
+};
+
 @interface AudioEngine : NSObject
 
-@property (nonatomic, assign) bool isInterrupted;
-@property (nonatomic, assign) bool isSupposedToBeRunning;
+@property (nonatomic, assign) AudioEngineState state;
 @property (nonatomic, strong) AVAudioEngine *audioEngine;
 @property (nonatomic, strong) NSMutableDictionary *sourceNodes;
 @property (nonatomic, strong) NSMutableDictionary *sourceFormats;
-@property (nonatomic, strong) NSMutableDictionary *sourceStates;
 @property (nonatomic, strong) AVAudioSinkNode *inputNode;
 @property (nonatomic, weak) AudioSessionManager *sessionManager;
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager;
-
+- (instancetype)init;
 + (instancetype)sharedInstance;
+
 - (void)cleanup;
-- (bool)rebuildAudioEngineAndStartIfNecessary;
-- (bool)restartAudioEngine;
-- (bool)startEngine;
-- (void)stopEngine;
-- (void)pauseEngine:(NSString *)sourceNodeId;
-- (bool)isRunning;
-- (void)markAsInterrupted;
-- (void)unmarkAsInterrupted;
-- (bool)isSupposedToRun;
 
 - (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
@@ -36,10 +32,17 @@
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode;
 - (void)detachInputNode;
 
-- (void)logAudioEngineState;
+- (void)onInterruptionBegin;
+- (void)onInterruptionEnd:(bool)shouldResume;
+
+- (AudioEngineState)getState;
 
 - (bool)startIfNecessary;
-- (void)stopIfNecessary;
 - (void)pauseIfNecessary;
+- (void)stopIfNecessary;
+
+- (void)restartAudioEngine;
+
+- (void)logAudioEngineState;
 
 @end