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

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

@@ -0,0 +1,57 @@
+#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 <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class IOSRecorderCallback {
+ public:
+  IOSRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      size_t channelCount,
+      uint64_t callbackId);
+  ~IOSRecorderCallback();
+
+  void prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  void cleanup();
+
+  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_;
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+
+  AVAudioFormat *bufferFormat_;
+  AVAudioFormat *callbackFormat_;
+  AVAudioConverter *converter_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,189 @@
+#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/IOSRecorderCallback.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <algorithm>
+
+namespace audioapi {
+
+IOSRecorderCallback::IOSRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry),
+      sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId)
+{
+  ringBufferSize_ = std::max((int)bufferLength_ * 2, 8192);
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto busAudioArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
+    circularBus_[i] = busAudioArray;
+  }
+}
+
+IOSRecorderCallback::~IOSRecorderCallback()
+{
+  @autoreleasepool {
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i].reset();
+    }
+  }
+}
+
+void IOSRecorderCallback::prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    bufferFormat_ = bufferFormat;
+    converterInputBufferSize_ = maxInputBufferLength;
+
+    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_];
+  }
+}
+
+void IOSRecorderCallback::cleanup()
+{
+  @autoreleasepool {
+    sendRemainingData();
+
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i].reset();
+    }
+  }
+}
+
+void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+{
+  @autoreleasepool {
+    NSError *error = nil;
+
+    if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
+        !bufferFormat_.isInterleaved) {
+      // Directly write to circular buffer
+      for (size_t 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;
+
+    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;
+    }
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *inputChannel = static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
+      circularBus_[i]->push_back(inputChannel, outputFrameCount);
+    }
+
+    emitAudioData();
+  }
+}
+
+void IOSRecorderCallback::emitAudioData()
+{
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus = std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, bufferLength_);
+    }
+
+    invokeCallback(bus, bufferLength_);
+  }
+}
+
+void IOSRecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames)
+{
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+  }
+}
+
+void IOSRecorderCallback::sendRemainingData()
+{
+  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
+  auto bus = std::make_shared<AudioBus>(circularBus_[0]->getNumberOfAvailableFrames(), channelCount_, sampleRate_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto *outputChannel = bus->getChannel(i)->getData();
+    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
+  }
+
+  invokeCallback(bus, numberOfFrames);
+}
+
+} // namespace audioapi

package/ios/audioapi/ios/core/NativeAudioRecorder.h

@@ -7,20 +7,15 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 @interface NativeAudioRecorder : NSObject
 
-@property (nonatomic, assign) int bufferLength;
-@property (nonatomic, assign) float sampleRate;
-
 @property (nonatomic, strong) AVAudioSinkNode *sinkNode;
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
 @property (nonatomic, copy) AudioReceiverBlock receiverBlock;
 
-@property (nonatomic, strong) AVAudioConverter *audioConverter;
-@property (nonatomic, strong) AVAudioFormat *inputFormat;
-@property (nonatomic, strong) AVAudioFormat *outputFormat;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
+
+- (AVAudioFormat *)getInputFormat;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate;
+- (int)getBufferSize;
 
 - (void)start;
 

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

@@ -4,41 +4,36 @@
 
 @implementation NativeAudioRecorder
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate
+static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
-  if (self = [super init]) {
-    self.bufferLength = bufferLength;
-    self.sampleRate = sampleRate;
-
-    self.receiverBlock = [receiverBlock copy];
-
-    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
+  if (x == 0) {
+    return 1;
+  }
 
-    if (!devicePrefferedSampleRate) {
-      NSError *error;
-      devicePrefferedSampleRate = sampleRate;
+  x--;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  x++;
 
-      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
-    }
+  return x;
+}
 
-    self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                        sampleRate:devicePrefferedSampleRate
-                                                          channels:1
-                                                       interleaved:NO];
-    self.outputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                         sampleRate:sampleRate
-                                                           channels:1
-                                                        interleaved:NO];
-    self.audioConverter = [[AVAudioConverter alloc] initFromFormat:self.inputFormat toFormat:self.outputFormat];
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+{
+  if (self = [super init]) {
+    self.receiverBlock = [receiverBlock copy];
 
     __weak typeof(self) weakSelf = self;
     self.receiverSinkBlock = ^OSStatus(
         const AudioTimeStamp *_Nonnull timestamp,
         AVAudioFrameCount frameCount,
         const AudioBufferList *_Nonnull inputData) {
-      return [weakSelf processAudioInput:inputData withFrameCount:frameCount atTimestamp:timestamp];
+      weakSelf.receiverBlock(inputData, frameCount);
+
+      return kAudioServicesNoError;
     };
 
     self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
@@ -47,55 +42,18 @@
   return self;
 }
 
-- (OSStatus)processAudioInput:(const AudioBufferList *)inputData
-               withFrameCount:(AVAudioFrameCount)frameCount
-                  atTimestamp:(const AudioTimeStamp *)timestamp
+- (AVAudioFormat *)getInputFormat
 {
-  float inputSampleRate = self.inputFormat.sampleRate;
-  float outputSampleRate = self.outputFormat.sampleRate;
-
-  if (inputSampleRate != outputSampleRate) {
-    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
-                                                                  frameCapacity:frameCount];
-    memcpy(
-        inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
-        inputData->mBuffers[0].mData,
-        inputData->mBuffers[0].mDataByteSize);
-    inputBuffer.frameLength = frameCount;
-
-    int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
-
-    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
-                                                                   frameCapacity:outputFrameCount];
-
-    NSError *error = nil;
-    AVAudioConverterInputBlock inputBlock =
-        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-    {
-      *outStatus = AVAudioConverterInputStatus_HaveData;
-      return inputBuffer;
-    };
-
-    /// IMPORTANT: AVAudioConverter leaks memory without autorelease pool
-    /// more details here: https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
-    /// we can try to remove it in the future or refactor to reuse buffers to minimize allocations
-    @autoreleasepool {
-      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
-    }
-
-    if (error) {
-      NSLog(@"Error during audio conversion: %@", error.localizedDescription);
-      return kAudioServicesBadSpecifierSizeError;
-    }
-
-    self.receiverBlock(outputBuffer.audioBufferList, outputBuffer.frameLength);
-
-    return kAudioServicesNoError;
-  }
+  return [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
+}
 
-  self.receiverBlock(inputData, frameCount);
+- (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;
 
-  return kAudioServicesNoError;
+  return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
 }
 
 - (void)start

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

@@ -59,6 +59,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
       channelData[i] = buffer[i * outputChannels + ch];
     }
   }
+
   return std::make_shared<AudioBuffer>(audioBus);
 }
 

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -118,9 +118,9 @@ static AudioEngine *_sharedInstance = nil;
 - (void)stopEngine
 {
   NSLog(@"[AudioEngine] stopEngine");
-  if (![self.audioEngine isRunning]) {
-    return;
-  }
+  //  if (![self.audioEngine isRunning]) {
+  //    return;
+  //  }
 
   self.isSupposedToBeRunning = false;
   [self.audioEngine stop];

package/ios/audioapi/ios/system/AudioSessionManager.mm

@@ -213,15 +213,6 @@
 
 - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
-  // if there is no entry NSMicrophoneUsageDescription calling requestRecordPermission will quit an app
-  if (value == nil) {
-    reject(
-        nil,
-        @"There is no NSMicrophoneUsageDescription entry in info.plist file. App cannot access microphone without it.",
-        nil);
-    return;
-  }
   if (@available(iOS 17, *)) {
     [AVAudioSession.sharedInstance requestRecordPermission:^(BOOL granted) {
       if (granted) {

package/ios/audioapi/ios/system/LockScreenManager.h

@@ -12,6 +12,7 @@
 
 @property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
 @property (nonatomic, copy) NSString *artworkUrl;
+@property (nonatomic, assign) bool isReceivingRemoteCommands;
 
 - (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
 - (void)cleanup;

package/ios/audioapi/ios/system/LockScreenManager.mm

@@ -19,28 +19,40 @@
   if (self = [super init]) {
     self.audioAPIModule = audioAPIModule;
     self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+    self.isReceivingRemoteCommands = false;
+  }
+
+  return self;
+}
 
+- (void)toggleRemoteCommands:(bool)enable
+{
+  if (enable && !self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = true;
     dispatch_async(dispatch_get_main_queue(), ^{
       [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
     });
+    return;
+  } else if (!enable && self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = false;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
+    });
+    return;
   }
-
-  return self;
 }
 
 - (void)cleanup
 {
   NSLog(@"[LockScreenManager] cleanup");
+  [self toggleRemoteCommands:false];
   [self resetLockScreenInfo];
-
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
-  });
 }
 
 - (void)setLockScreenInfo:(NSDictionary *)info
 {
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+  [self toggleRemoteCommands:true];
 
   // now playing info(lock screen info)
   NSMutableDictionary *lockScreenInfoDict;
@@ -79,6 +91,7 @@
 
 - (void)resetLockScreenInfo
 {
+  [self toggleRemoteCommands:false];
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
   self.playingInfoCenter.nowPlayingInfo = nil;
   self.artworkUrl = nil;