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

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -1,36 +1,30 @@
 #include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
 #include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 
+#include <memory>
+#include <string>
+
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(audioEventHandlerRegistry) {
-  AudioStreamBuilder builder;
-
-  builder.setSharingMode(SharingMode::Exclusive)
-      ->setDirection(Direction::Input)
-      ->setFormat(AudioFormat::Float)
-      ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(PerformanceMode::None)
-      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
-      ->setDataCallback(this)
-      ->openStream(mStream_);
-
-  streamSampleRate_ = mStream_->getSampleRate();
-  streamChannelCount_ = mStream_->getChannelCount();
-  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
-
+    : AudioRecorder(audioEventHandlerRegistry),
+      streamSampleRate_(0.0),
+      streamChannelCount_(0),
+      streamMaxBufferSizeInFrames_(0) {
   nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
 }
 
@@ -44,114 +38,303 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   }
 }
 
-void AndroidAudioRecorder::start() {
+Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
+  if (mStream_) {
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  oboe::AudioStreamBuilder builder;
+  builder.setSharingMode(oboe::SharingMode::Exclusive)
+      ->setDirection(oboe::Direction::Input)
+      ->setFormat(oboe::AudioFormat::Float)
+      ->setFormatConversionAllowed(true)
+      ->setPerformanceMode(oboe::PerformanceMode::None)
+      ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::Medium)
+      ->setDataCallback(this)
+      ->setErrorCallback(this);
+
+  auto result = builder.openStream(mStream_);
+
+  if (result != oboe::Result::OK || mStream_ == nullptr) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to open audio stream: " + std::string(oboe::convertToText(result)));
+  }
+
+  streamSampleRate_ = static_cast<float>(mStream_->getSampleRate());
+  streamChannelCount_ = mStream_->getChannelCount();
+  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+Result<std::string, std::string> AndroidAudioRecorder::start() {
+  std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
   if (isRecording()) {
-    return;
+    return Result<std::string, std::string>::Ok(std::format("file://{}", filePath_));
+  }
+
+  auto streamResult = openAudioStream();
+
+  if (!streamResult.is_ok()) {
+    return Result<std::string, std::string>::Err(streamResult.unwrap_err());
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidAudioRecorder",
-        "Audio stream is not initialized.\n");
-    return;
+    return Result<std::string, std::string>::Err("Audio stream is not initialized.");
   }
 
   if (usesFileOutput()) {
-    fileWriter_->openFile(
-        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+    auto fileResult =
+        std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.is_ok()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
   }
 
   if (usesCallback()) {
-    // TODO: create circular buffer and converter?
+    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+        ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
   if (isConnected()) {
-    // TODO: set adapter node properties?
+    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_);
   }
 
-  nativeAudioRecorder_->start();
-  mStream_->requestStart();
-  isRunning_.store(true);
+  auto result = mStream_->requestStart();
+
+  if (result != oboe::Result::OK) {
+    return Result<std::string, std::string>::Err(
+        "Failed to start stream: " + std::string(oboe::convertToText(result)));
+  }
+
+  jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->start(); });
+
+  state_.store(RecorderState::Recording, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(std::format("file://{}", filePath_));
 }
 
-std::string AndroidAudioRecorder::stop() {
+Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorder::stop() {
+  std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
+  std::string filePath = std::format("file://{}", filePath_);
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+
   if (!isRecording()) {
-    return "";
+    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+        "Recorder is not in recording state.");
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidAudioRecorder",
-        "Audio stream is not initialized.\n");
-    return "";
+    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+        "Audio stream is not initialized.");
   }
 
-  nativeAudioRecorder_->stop();
+  state_.store(RecorderState::Idle, std::memory_order_release);
+  jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });
   mStream_->requestStop();
-  isRunning_.store(false);
-
-  // TODO: sendRemainingData() ?
 
   if (usesFileOutput()) {
-    return fileWriter_->closeFile();
+    auto fileResult = fileWriter_->closeFile();
+
+    if (!fileResult.is_ok()) {
+      return Result<std::tuple<std::string, double, double>, std::string>::Err(
+          "Failed to close file: " + fileResult.unwrap_err());
+    }
+
+    outputFileSize = std::get<0>(fileResult.unwrap());
+    outputDuration = std::get<1>(fileResult.unwrap());
+  }
+
+  if (usesCallback()) {
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
   }
 
-  return "";
+  filePath_ = "";
+  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
+      {filePath, outputFileSize, outputDuration});
 }
 
-void AndroidAudioRecorder::enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) {
-  uint8_t format = static_cast<uint8_t>(androidFlags & 0xF);
-
-  if (format == 1) {
-    fileWriter_ = std::make_shared<MiniAudioFileWriter>(
-        sampleRate, channelCount, bitRate, androidFlags);
+Result<std::string, std::string> AndroidAudioRecorder::enableFileOutput(
+    std::shared_ptr<AudioFileProperties> properties) {
+  std::scoped_lock fileWriterLock(fileWriterMutex_);
+
+  if (properties->format == AudioFileProperties::Format::WAV) {
+    fileWriter_ = std::make_shared<MiniAudioFileWriter>(audioEventHandlerRegistry_, properties);
   } else {
-    fileWriter_ = std::make_shared<FFmpegAudioFileWriter>(
-        sampleRate, channelCount, bitRate, androidFlags);
+    fileWriter_ = std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
+        audioEventHandlerRegistry_, properties);
+  }
+
+  if (!isIdle()) {
+    auto fileResult =
+        std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.is_ok()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
   }
 
-  fileOutputEnabled_.store(true);
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
 }
 
 void AndroidAudioRecorder::disableFileOutput() {
-  fileOutputEnabled_.store(false);
+  std::scoped_lock fileWriterLock(fileWriterMutex_);
+  fileOutputEnabled_.store(false, std::memory_order_release);
   fileWriter_ = nullptr;
 }
 
-void AndroidAudioRecorder::pause() {}
+void AndroidAudioRecorder::pause() {
+  if (!isRecording()) {
+    return;
+  }
 
-void AndroidAudioRecorder::resume() {}
+  mStream_->pause(0);
+  state_.store(RecorderState::Paused, std::memory_order_release);
+}
+
+void AndroidAudioRecorder::resume() {
+  if (!isPaused()) {
+    return;
+  }
+
+  mStream_->start(0);
+  state_.store(RecorderState::Recording, std::memory_order_release);
+}
+
+Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId) {
+  std::scoped_lock callbackLock(callbackMutex_);
+  dataCallback_ = std::make_shared<AndroidRecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+
+  if (!isIdle()) {
+    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+        ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  callbackOutputEnabled_.store(true, std::memory_order_release);
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  std::scoped_lock callbackLock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
+}
+
+void AndroidAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+  std::scoped_lock adapterLock(adapterNodeMutex_);
+  adapterNode_ = node;
+  deinterleavingBuffer_ = std::make_shared<AudioArray>(streamMaxBufferSizeInFrames_);
+
+  if (!isIdle()) {
+    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_);
+  }
+
+  isConnected_.store(true, std::memory_order_release);
+}
+
+void AndroidAudioRecorder::disconnect() {
+  std::scoped_lock adapterLock(adapterNodeMutex_);
+  isConnected_.store(false, std::memory_order_release);
+  deinterleavingBuffer_ = nullptr;
+  adapterNode_ = nullptr;
+}
 
-DataCallbackResult AndroidAudioRecorder::onAudioReady(
+oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
+  if (isPaused()) {
+    return oboe::DataCallbackResult::Continue;
+  }
+
   if (usesFileOutput()) {
-    fileWriter_->writeAudioData(audioData, numFrames);
+    if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
+      std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+          ->writeAudioData(audioData, numFrames);
+    }
   }
 
-  return DataCallbackResult::Continue;
+  if (usesCallback()) {
+    if (auto callbackLock = Locker::tryLock(callbackMutex_)) {
+      std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+          ->receiveAudioData(audioData, numFrames);
+    }
+  }
+
+  if (isConnected()) {
+    if (auto adapterLock = Locker::tryLock(adapterNodeMutex_)) {
+      for (int channel = 0; channel < streamChannelCount_; ++channel) {
+        for (int frame = 0; frame < numFrames; ++frame) {
+          deinterleavingBuffer_->getData()[frame] =
+              static_cast<float *>(audioData)[frame * streamChannelCount_ + channel];
+        }
+
+        adapterNode_->buff_[channel]->write(deinterleavingBuffer_->getData(), numFrames);
+      }
+    }
+  }
+
+  return oboe::DataCallbackResult::Continue;
 }
 
-} // namespace audioapi
+bool AndroidAudioRecorder::isRecording() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      mStream_->getState() == oboe::StreamState::Started;
+}
 
-// if (isRunning_.load()) {
-//   auto *inputChannel = static_cast<float *>(audioData);
-//   writeToBuffers(inputChannel, numFrames);
-// }
+bool AndroidAudioRecorder::isPaused() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Paused;
+}
 
-// while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-//   auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-//   auto *outputChannel = bus->getChannel(0)->getData();
+bool AndroidAudioRecorder::isIdle() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-//   circularBuffer_->pop_front(outputChannel, bufferLength_);
+void AndroidAudioRecorder::cleanup() {
+  state_.store(RecorderState::Idle, std::memory_order_release);
 
-//   invokeOnAudioReadyCallback(bus, bufferLength_);
-// }
+  if (mStream_) {
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
+  if (error == oboe::Result::ErrorDisconnected) {
+    cleanup();
+
+    auto streamResult = openAudioStream();
+
+    if (!streamResult.is_ok()) {
+      // TODO: call error callback
+      return;
+    }
+
+    mStream_->requestStart();
+    state_.store(RecorderState::Recording, std::memory_order_release);
+  }
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -1,54 +1,68 @@
 #pragma once
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-
 #include <oboe/Oboe.h>
 #include <functional>
 #include <memory>
 #include <string>
-
+#include <tuple>
+#include <mutex>
+#include <audioapi/utils/Result.hpp>
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
 namespace audioapi {
 
-using namespace oboe;
-
 class AudioBus;
+class AudioArray;
 class CircularAudioArray;
+class AudioFileProperties;
+class AndroidRecorderCallback;
 class AndroidFileWriterBackend;
 class AudioEventHandlerRegistry;
 
-class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
+class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecorder {
  public:
   explicit AndroidAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AndroidAudioRecorder() override;
+  void cleanup();
 
-  void start() override;
-  std::string stop() override;
+  Result<std::string, std::string> start() override;
+  Result<std::tuple<std::string, double, double>, std::string> stop() override;
 
-  void enableFileOutput(
-      float sampleRate,
-      size_t channelCount,
-      size_t bitRate,
-      size_t iosFlags,
-      size_t androidFlags) override;
+  Result<std::string, std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) override;
   void disableFileOutput() override;
 
   void pause() override;
   void resume() override;
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
+
+  Result<NoneType, std::string> setOnAudioReadyCallback(float sampleRate, size_t bufferLength, int channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void disconnect() override;
 
-  DataCallbackResult onAudioReady(
-          AudioStream *oboeStream,
+  oboe::DataCallbackResult onAudioReady(
+          oboe::AudioStream *oboeStream,
           void *audioData,
           int32_t numFrames) override;
+  void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
 
  private:
-  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
-  std::shared_ptr<AudioStream> mStream_;
-  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
-  int32_t streamSampleRate_;
+  std::string filePath_{""};
+  std::shared_ptr<AudioArray> deinterleavingBuffer_;
+
+  float streamSampleRate_;
   int32_t streamChannelCount_;
   int32_t streamMaxBufferSizeInFrames_;
+
+  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+
+  std::shared_ptr<oboe::AudioStream> mStream_;
+  Result<NoneType, std::string> openAudioStream();
 };
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -4,6 +4,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <jni.h>
+
+#include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
@@ -11,9 +15,7 @@ AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      sampleRate_(sampleRate),
-      channelCount_(channelCount) {
+    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
   isInitialized_ = openAudioStream();
 
   nativeAudioPlayer_ = jni::make_global(NativeAudioPlayer::create());
@@ -35,21 +37,17 @@ bool AudioPlayer::openAudioStream() {
   auto result = builder.openStream(mStream_);
   if (result != oboe::Result::OK || mStream_ == nullptr) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioPlayer",
-        "Failed to open stream: %s",
-        oboe::convertToText(result));
+        ANDROID_LOG_ERROR, "AudioPlayer", "Failed to open stream: %s", oboe::convertToText(result));
     return false;
   }
 
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
+  mBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
   return true;
 }
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    nativeAudioPlayer_->start();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->start(); });
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -59,7 +57,7 @@ bool AudioPlayer::start() {
 
 void AudioPlayer::stop() {
   if (mStream_) {
-    nativeAudioPlayer_->stop();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->stop(); });
     mStream_->requestStop();
   }
 }
@@ -92,10 +90,8 @@ bool AudioPlayer::isRunning() const {
   return mStream_ && mStream_->getState() == oboe::StreamState::Started;
 }
 
-DataCallbackResult AudioPlayer::onAudioReady(
-    AudioStream *oboeStream,
-    void *audioData,
-    int32_t numFrames) {
+DataCallbackResult
+AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) {
   if (!isInitialized_) {
     return DataCallbackResult::Continue;
   }
@@ -106,8 +102,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   assert(buffer != nullptr);
 
   while (processedFrames < numFrames) {
-    int framesToProcess =
-        std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+    int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
     renderAudio_(mBus_, framesToProcess);
 
     // TODO: optimize this with SIMD?
@@ -124,9 +119,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   return DataCallbackResult::Continue;
 }
 
-void AudioPlayer::onErrorAfterClose(
-    oboe::AudioStream *stream,
-    oboe::Result error) {
+void AudioPlayer::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
   if (error == oboe::Result::ErrorDisconnected) {
     cleanup();
     if (openAudioStream()) {

package/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -1,33 +1,33 @@
 #pragma once
 
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <tuple>
 #include <string>
 #include <memory>
+#include <audioapi/utils/Result.hpp>
 
 namespace audioapi {
 
-class AndroidFileWriterBackend {
- public:
-  AndroidFileWriterBackend(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags) {}
-
-  virtual ~AndroidFileWriterBackend() = default;
+class AudioFileProperties;
 
-  virtual void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::string closeFile() = 0;
+class AndroidFileWriterBackend : public AudioFileWriter {
+ public:
+  explicit AndroidFileWriterBackend(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+      : AudioFileWriter(audioEventHandlerRegistry, fileProperties) {}
 
+  virtual OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
   virtual bool writeAudioData(void *data, int numFrames) = 0;
 
-  std::string getFilePath() const { return filePath_; }
+  std::string getFilePath() const override { return filePath_; }
+  double getCurrentDuration() const override { return static_cast<double>(framesWritten_.load(std::memory_order_acquire)) / streamSampleRate_; }
 
  protected:
-  std::string filePath_{""};
-
-  int32_t streamSampleRate_{0};
+  float streamSampleRate_{0};
   int32_t streamChannelCount_{0};
   int32_t streamMaxBufferSize_{0};
+  std::string filePath_{""};
 };
 
 } // namespace audioapi