react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -4,6 +4,23 @@
 
 @implementation NativeAudioRecorder
 
+static inline uint32_t nextPowerOfTwo(uint32_t x)
+{
+  if (x == 0) {
+    return 1;
+  }
+
+  x--;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  x++;
+
+  return x;
+}
+
 - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
 {
   if (self = [super init]) {
@@ -25,9 +42,36 @@
   return self;
 }
 
+// Note: this method should be called only after the session is activated
 - (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];
+
+  // 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));
 }
 
 - (void)start
@@ -35,14 +79,15 @@
   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];
 }
@@ -52,7 +97,30 @@
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
   [audioEngine detachInputNode];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
+
+  // This makes sure that the engine releases the input properly when we no longer need it
+  // (i.e. no more misleading dot)
+  // Restart only if is not running to avoid interruptions of playback
+  if ([audioEngine getState] != AudioEngineStateRunning) {
+    [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>
 
@@ -59,22 +61,31 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
       channelData[i] = buffer[i * outputChannels + ch];
     }
   }
+
   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]);
@@ -93,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,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