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

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

@@ -6,31 +6,25 @@
 #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,97 +38,164 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   }
 }
 
-std::string 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 filePath_;
+    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 filePath_;
+    return Result<std::string, std::string>::Err("Audio stream is not initialized.");
   }
 
   if (usesFileOutput()) {
-    filePath_ = 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?
-    callback_->prepare(
-        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+    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();
-  state_.store(RecorderState::Recording);
+  auto result = mStream_->requestStart();
 
-  return filePath_;
+  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::tuple<std::string, double, double> AndroidAudioRecorder::stop() {
-  std::string filePath = filePath_;
+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 {filePath_, 0.0, 0.0};
+    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 {filePath_, 0.0, 0.0};
+    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();
-  state_.store(RecorderState::Idle);
 
   if (usesFileOutput()) {
-    auto [size, duration] = fileWriter_->closeFile();
-    outputFileSize = size;
-    outputDuration = duration;
+    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()) {
-    callback_->cleanup();
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
   }
 
   filePath_ = "";
-  return {filePath, outputFileSize, outputDuration};
+  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);
   }
 
-  fileOutputEnabled_.store(true);
+  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, 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;
 }
 
@@ -144,7 +205,7 @@ void AndroidAudioRecorder::pause() {
   }
 
   mStream_->pause(0);
-  state_.store(RecorderState::Paused);
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
 void AndroidAudioRecorder::resume() {
@@ -153,53 +214,127 @@ void AndroidAudioRecorder::resume() {
   }
 
   mStream_->start(0);
-  state_.store(RecorderState::Recording);
+  state_.store(RecorderState::Recording, std::memory_order_release);
 }
 
-void AndroidAudioRecorder::setOnAudioReadyCallback(
+Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
     float sampleRate,
     size_t bufferLength,
-    size_t channelCount,
+    int channelCount,
     uint64_t callbackId) {
-  callback_ = std::make_shared<AndroidRecorderCallback>(
-      audioEventHandlerRegistry_,
-      sampleRate,
-      bufferLength,
-      channelCount,
-      callbackId);
-  callbackOutputEnabled_.store(true);
+  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() {
-  callbackOutputEnabled_.store(false);
-  callback_ = nullptr;
+  std::scoped_lock callbackLock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
 }
 
-DataCallbackResult AndroidAudioRecorder::onAudioReady(
+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;
+}
+
+oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
   if (isPaused()) {
-    return DataCallbackResult::Continue;
+    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);
+    }
   }
 
   if (usesCallback()) {
-    callback_->receiveAudioData(audioData, numFrames);
+    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 DataCallbackResult::Continue;
+  return oboe::DataCallbackResult::Continue;
 }
 
-double AndroidAudioRecorder::getCurrentDuration() const {
-  if (usesFileOutput()) {
-    return fileWriter_->getCurrentDuration();
+bool AndroidAudioRecorder::isRecording() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      mStream_->getState() == oboe::StreamState::Started;
+}
+
+bool AndroidAudioRecorder::isPaused() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Paused;
+}
+
+bool AndroidAudioRecorder::isIdle() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
+
+void AndroidAudioRecorder::cleanup() {
+  state_.store(RecorderState::Idle, std::memory_order_release);
+
+  if (mStream_) {
+    mStream_->close();
+    mStream_.reset();
   }
+}
 
-  return 0.0;
+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,67 +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();
 
-  std::string start() override;
-  std::tuple<std::string, double, double> 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;
 
-  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+  Result<NoneType, std::string> setOnAudioReadyCallback(float sampleRate, size_t bufferLength, int channelCount, uint64_t callbackId)
       override;
   void clearOnAudioReadyCallback() override;
 
-  double getCurrentDuration() const 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::string filePath_;
-  std::shared_ptr<AudioStream> mStream_;
+  std::string filePath_{""};
+  std::shared_ptr<AudioArray> deinterleavingBuffer_;
 
-  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
-  std::shared_ptr<AndroidRecorderCallback> callback_;
-
-  int32_t streamSampleRate_;
+  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,37 +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 std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::tuple<double, double> 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_; }
-
-  double getCurrentDuration() const { return static_cast<double>(framesWritten_.load()) / streamSampleRate_; }
+  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_{""};
-  std::atomic<size_t> framesWritten_{0};
-
-  int32_t streamSampleRate_{0};
+  float streamSampleRate_{0};
   int32_t streamChannelCount_{0};
   int32_t streamMaxBufferSize_{0};
+  std::string filePath_{""};
 };
 
 } // namespace audioapi