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

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -15,7 +15,10 @@
 
     __weak typeof(self) weakSelf = self;
     self.renderBlock = ^OSStatus(
-        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
+        BOOL *isSilence,
+        const AudioTimeStamp *timestamp,
+        AVAudioFrameCount frameCount,
+        AudioBufferList *outputData) {
       if (outputData->mNumberBuffers != weakSelf.channelCount) {
         return kAudioServicesBadPropertySizeError;
       }
@@ -25,8 +28,10 @@
       return kAudioServicesNoError;
     };
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate
+                                                             channels:self.channelCount];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
+                                                renderBlock:self.renderBlock];
   }
 
   return self;
@@ -34,29 +39,27 @@
 
 - (bool)start
 {
-  NSLog(@"[AudioPlayer] start");
-
   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 player and recorder 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 player and recorder 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 player very frequently
-  [audioEngine stopEngine];
+  [audioEngine stopIfNecessary];
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
   return [audioEngine startIfNecessary];
 }
 
 - (void)stop
 {
-  NSLog(@"[AudioPlayer] stop");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
+
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
   [audioEngine stopIfNecessary];
   self.sourceNodeId = nil;
@@ -64,7 +67,6 @@
 
 - (bool)resume
 {
-  NSLog(@"[AudioPlayer] resume");
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -75,7 +77,8 @@
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine pauseEngine:self.sourceNodeId];
+
+  [audioEngine pauseIfNecessary];
 }
 
 - (void)cleanup

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

@@ -21,6 +21,10 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 - (void)stop;
 
+- (void)pause;
+
+- (void)resume;
+
 - (void)cleanup;
 
 @end

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

@@ -44,15 +44,32 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 
 - (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 +78,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];
 }
@@ -77,8 +95,25 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine detachInputNode];
   [audioEngine stopIfNecessary];
+  [audioEngine detachInputNode];
+  [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,31 @@
+#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__
+
+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,177 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+namespace audioapi::ios::fileoptions {
+
+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;
+  }
+}
+
+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;
+  }
+}
+
+NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  return properties->flacCompressionLevel;
+}
+
+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";
+  }
+}
+
+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;
+  }
+}
+
+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_;