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

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp

@@ -4,6 +4,8 @@
 #include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
 namespace audioapi {
 
 MiniAudioFileWriter::MiniAudioFileWriter(
@@ -41,7 +43,7 @@ MiniAudioFileWriter::~MiniAudioFileWriter() {
   }
 }
 
-void MiniAudioFileWriter::openFile(
+std::string MiniAudioFileWriter::openFile(
     int32_t streamSampleRate,
     int32_t streamChannelCount,
     int32_t streamMaxBufferSize) {
@@ -58,21 +60,23 @@ void MiniAudioFileWriter::openFile(
   success = initializeConverterIfNeeded();
 
   if (!success) {
-    return;
+    return "";
   }
 
   success = initializeEncoder();
 
   if (!success) {
-    return;
+    return "";
   }
 
   isFileOpen_.store(true);
+
+  return filePath_;
 }
 
-std::string MiniAudioFileWriter::closeFile() {
+std::tuple<double, double> MiniAudioFileWriter::closeFile() {
   if (!isFileOpen()) {
-    return "";
+    return {0.0, 0.0};
   }
 
   isFileOpen_.store(false);
@@ -93,10 +97,36 @@ std::string MiniAudioFileWriter::closeFile() {
     processingBufferLength_ = 0;
   }
 
-  std::string closedFilePath = filePath_;
-  filePath_ = "";
+  // Retrieve duration and file size
+  std::string filePath = filePath_;
+  double durationInSeconds = 0.0;
+  double fileSizeInMB = 0.0;
+
+  ma_decoder decoder;
+
+  if (ma_decoder_init_file(filePath_.c_str(), NULL, &decoder) == MA_SUCCESS) {
+    ma_uint64 frameCount = 0;
 
-  return closedFilePath;
+    if (ma_decoder_get_length_in_pcm_frames(&decoder, &frameCount) ==
+        MA_SUCCESS) {
+      durationInSeconds =
+          static_cast<double>(frameCount) / decoder.outputSampleRate;
+    }
+
+    ma_decoder_uninit(&decoder);
+  }
+
+  FILE *file = fopen(filePath_.c_str(), "rb");
+
+  if (file != nullptr) {
+    fseek(file, 0, SEEK_END);
+    long fileSizeInBytes = ftell(file);
+    fclose(file);
+    fileSizeInMB = static_cast<double>(fileSizeInBytes) / BYTES_TO_MB;
+  }
+
+  filePath_ = "";
+  return {fileSizeInMB, durationInSeconds};
 }
 
 bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
@@ -126,6 +156,7 @@ bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
           filePath_.c_str());
     }
 
+    framesWritten_.fetch_add(numFrames);
     return result == MA_SUCCESS;
   }
 
@@ -142,6 +173,7 @@ bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
         filePath_.c_str());
   }
 
+  framesWritten_.fetch_add(numFrames);
   return result == MA_SUCCESS;
 }
 

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h

@@ -5,6 +5,7 @@
 
 #include <string>
 #include <memory>
+#include <tuple>
 
 namespace audioapi {
 
@@ -19,8 +20,8 @@ class MiniAudioFileWriter : public AndroidFileWriterBackend {
     size_t androidFlags);
   ~MiniAudioFileWriter() override;
 
-  void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::string closeFile() override;
+  std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  std::tuple<double, double> closeFile() override;
 
   bool writeAudioData(void *data, int numFrames) override;
 

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp

@@ -35,25 +35,36 @@ AudioRecorderHostObject::AudioRecorderHostObject(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, setOnAudioReady),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnAudioReady));
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, getCurrentDuration));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
-  audioRecorder_->start();
+  std::string filePath = audioRecorder_->start();
 
-  return jsi::Value::undefined();
+  return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, filePath));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
-  std::string filePath = audioRecorder_->stop();
+  auto [path, size, duration] = audioRecorder_->stop();
+  auto result = jsi::Object(runtime);
 
-  return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, filePath));
+  result.setProperty(
+      runtime, "path", jsi::String::createFromUtf8(runtime, path));
+  result.setProperty(runtime, "size", size);
+  result.setProperty(runtime, "duration", duration);
+
+  return result;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isRecording) {
   return jsi::Value(audioRecorder_->isRecording());
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isPaused) {
+  return jsi::Value(audioRecorder_->isPaused());
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, enableFileOutput) {
   auto options = args[0].getObject(runtime);
 
@@ -115,8 +126,9 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, setOnAudioReady) {
       options.getProperty(runtime, "bufferLength").getNumber());
   auto channelCount = static_cast<size_t>(
       options.getProperty(runtime, "channelCount").getNumber());
-  auto callbackId = static_cast<uint64_t>(
-      options.getProperty(runtime, "callbackId").getNumber());
+  uint64_t callbackId = std::stoull(options.getProperty(runtime, "callbackId")
+                                        .getString(runtime)
+                                        .utf8(runtime));
 
   audioRecorder_->setOnAudioReadyCallback(
       sampleRate, bufferLength, channelCount, callbackId);
@@ -128,4 +140,9 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, clearOnAudioReady) {
   return jsi::Value::undefined();
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, getCurrentDuration) {
+  double duration = audioRecorder_->getCurrentDuration();
+  return jsi::Value(duration);
+}
+
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h

@@ -22,6 +22,7 @@ class AudioRecorderHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(start);
   JSI_HOST_FUNCTION_DECL(stop);
   JSI_HOST_FUNCTION_DECL(isRecording);
+  JSI_HOST_FUNCTION_DECL(isPaused);
 
   JSI_HOST_FUNCTION_DECL(enableFileOutput);
   JSI_HOST_FUNCTION_DECL(disableFileOutput);
@@ -35,6 +36,8 @@ class AudioRecorderHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(setOnAudioReady);
   JSI_HOST_FUNCTION_DECL(clearOnAudioReady);
 
+  JSI_HOST_FUNCTION_DECL(getCurrentDuration);
+
  private:
   std::shared_ptr<AudioRecorder> audioRecorder_;
 };

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,112 +1,19 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
-
-namespace audioapi {
-
-AudioRecorder::AudioRecorder(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  isRunning_.store(false);
-  fileOutputEnabled_.store(false);
-  callbackOutputEnabled_.store(false);
-  isConnected_.store(false);
-}
-
-bool AudioRecorder::isRecording() {
-  return isRunning_.load();
-}
-
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  // node->init();
-  // adapterNodeLock_.lock();
-  // adapterNode_ = node;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(true);
-  //   node->init(ringBufferSize_);
-  //   adapterNodeLock_.lock();
-  //   adapterNode_ = node;
-  //   adapterNodeLock_.unlock();
-}
-
-void AudioRecorder::disconnect() {
-  // adapterNodeLock_.lock();
-  // adapterNode_ = nullptr;
-  // adapterNodeLock_.unlock();
-  // isConnected_.store(false);
-}
-
-void AudioRecorder::setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId) {
-  callbackProperties_.sampleRate = sampleRate;
-  callbackProperties_.bufferLength = bufferLength;
-  callbackProperties_.channelCount = channelCount;
-  callbackProperties_.callbackId = callbackId;
-
-  callbackOutputEnabled_.store(true);
-}
-
-void AudioRecorder::clearOnAudioReadyCallback() {
-  callbackOutputEnabled_.store(false);
-  callbackProperties_ = CallbackProperties{};
-}
-
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
-
-  //   auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  //   auto audioBufferHostObject =
-  //       std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  //   std::unordered_map<std::string, EventValue> body = {};
-  //   body.insert({"buffer", audioBufferHostObject});
-  //   body.insert({"numFrames", numFrames});
-
-  //   if (audioEventHandlerRegistry_ != nullptr) {
-  //     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-  //         "audioReady", onAudioReadyCallbackId_, body);
-  //   }
-}
-
-void AudioRecorder::sendRemainingCallbackData() {
-  //   if (!hasCallback()) {
-  //     return;
-  //   }
-
-  //   auto bus = std::make_shared<AudioBus>(
-  //       circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  //   auto *outputChannel = bus->getChannel(0)->getData();
-  //   auto availableFrames =
-  //       static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
-
-  //   circularBuffer_->pop_front(
-  //       outputChannel, circularBuffer_->getNumberOfAvailableFrames());
-
-  //   invokeOnAudioReadyCallback(bus, availableFrames);
-}
-
-bool AudioRecorder::usesCallback() const {
-  return callbackOutputEnabled_.load();
-}
-
-bool AudioRecorder::usesFileOutput() const {
-  return fileOutputEnabled_.load();
-}
+// void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
+// { node->init(); adapterNodeLock_.lock(); adapterNode_ = node;
+// adapterNodeLock_.unlock();
+// isConnected_.store(true);
+//   node->init(ringBufferSize_);
+//   adapterNodeLock_.lock();
+//   adapterNode_ = node;
+//   adapterNodeLock_.unlock();
+// }
 
-bool AudioRecorder::isConnected() const {
-  return isConnected_.load();
-}
+// void AudioRecorder::disconnect() {
+// adapterNodeLock_.lock();
+// adapterNode_ = nullptr;
+// adapterNodeLock_.unlock();
+// isConnected_.store(false);
+// }
 
 // AudioRecorder::AudioRecorder(
 //     const std::shared_ptr<AudioEventHandlerRegistry>
@@ -116,7 +23,7 @@ bool AudioRecorder::isConnected() const {
 //   ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
 
 //   circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-//   isRunning_.store(false);
+//   state_.store(RecorderState::Idle);
 // }
 
 // void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
@@ -126,10 +33,4 @@ bool AudioRecorder::isConnected() const {
 //     }
 //     adapterNodeLock_.unlock();
 //   }
-
-//   if (hasCallback()) {
-//     circularBuffer_->push_back(data, numFrames);
-//   }
 // }
-
-} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -4,6 +4,7 @@
 #include <atomic>
 #include <mutex>
 #include <string>
+#include <tuple>
 
 namespace audioapi {
 
@@ -14,13 +15,13 @@ class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  enum RecorderState { Idle, Recording, Paused };
+  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry):
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  virtual void start() = 0;
-  virtual std::string stop() = 0;
-
-  bool isRecording();
+  virtual std::string start() = 0;
+  virtual std::tuple<std::string, double, double> stop() = 0;
 
   virtual void enableFileOutput(
     float sampleRate,
@@ -33,49 +34,51 @@ class AudioRecorder {
   virtual void pause() = 0;
   virtual void resume() = 0;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
-  void disconnect();
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) {}
+  void disconnect() {}
 
-  void setOnAudioReadyCallback(
+  virtual void setOnAudioReadyCallback(
     float sampleRate,
     size_t bufferLength,
     size_t channelCount,
-    uint64_t callbackId);
-  void clearOnAudioReadyCallback();
+    uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
+
+  virtual double getCurrentDuration() const = 0;
+
+  bool usesCallback() const {
+    return callbackOutputEnabled_.load();
+  }
 
-  void invokeOnAudioReadyCallback(
-      const std::shared_ptr<AudioBus> &bus,
-      int numFrames);
-  void sendRemainingCallbackData();
+  bool usesFileOutput() const {
+    return fileOutputEnabled_.load();
+  }
 
-  bool usesCallback() const;
-  bool usesFileOutput() const;
-  bool isConnected() const;
+  bool isConnected() const {
+    return isConnected_.load();
+  }
+
+  bool isRecording() const {
+    return state_.load() == RecorderState::Recording;
+  }
+
+  bool isPaused() const {
+    return state_.load() == RecorderState::Paused;
+  }
 
  protected:
-  struct CallbackProperties {
-    float sampleRate;
-    size_t bufferLength;
-    size_t channelCount;
-    uint64_t callbackId;
-  };
-
-  CallbackProperties callbackProperties_;
   // size_t ringBufferSize_;
 
-  std::atomic<bool> isRunning_;
-  std::atomic<bool> fileOutputEnabled_;
-  std::atomic<bool> callbackOutputEnabled_;
-  std::atomic<bool> isConnected_;
+  std::atomic<RecorderState> state_{ RecorderState::Idle };
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
+  std::atomic<bool> isConnected_{false};
   // std::shared_ptr<CircularAudioArray> circularBuffer_;
 
   mutable std::mutex adapterNodeLock_;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
 
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
-
-  // void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioFileOptions.h

@@ -20,6 +20,7 @@ class IOSAudioFileOptions {
   NSString *getFileExtension() const;
   NSInteger getBitDepth() const;
   NSDictionary *getFileSettings();
+  float getSampleRate();
 
  private:
   uint8_t format_;

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

@@ -132,4 +132,9 @@ NSDictionary *IOSAudioFileOptions::getFileSettings()
   return settings;
 }
 
+float IOSAudioFileOptions::getSampleRate()
+{
+  return sampleRate_;
+}
+
 } // namespace audioapi

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

@@ -2,11 +2,15 @@
 
 #include <memory>
 #include <string>
+#include <tuple>
 
 #ifndef __OBJC__ // when compiled as C++
-typedef struct objc_object AVAudioFile;
 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 {
@@ -18,12 +22,18 @@ class IOSAudioFileWriter {
   IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags);
   ~IOSAudioFileWriter();
 
-  void openFile(AVAudioFormat *bufferFormat);
-  std::string closeFile();
+  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();
@@ -33,6 +43,9 @@ class IOSAudioFileWriter {
   AVAudioFormat *bufferFormat_;
   AVAudioConverter *converter_;
   NSURL *fileURL_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
 };
 
 } // namespace audioapi