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

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

@@ -1,6 +1,7 @@
 #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>
@@ -30,7 +31,6 @@ AndroidAudioRecorder::AndroidAudioRecorder(
   streamSampleRate_ = mStream_->getSampleRate();
   streamChannelCount_ = mStream_->getChannelCount();
   streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
-
   nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
 }
 
@@ -44,9 +44,9 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   }
 }
 
-void AndroidAudioRecorder::start() {
+std::string AndroidAudioRecorder::start() {
   if (isRecording()) {
-    return;
+    return filePath_;
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
@@ -54,16 +54,18 @@ void AndroidAudioRecorder::start() {
         ANDROID_LOG_ERROR,
         "AndroidAudioRecorder",
         "Audio stream is not initialized.\n");
-    return;
+    return filePath_;
   }
 
   if (usesFileOutput()) {
-    fileWriter_->openFile(
+    filePath_ = fileWriter_->openFile(
         streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
   if (usesCallback()) {
     // TODO: create circular buffer and converter?
+    callback_->prepare(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
   if (isConnected()) {
@@ -72,12 +74,18 @@ void AndroidAudioRecorder::start() {
 
   nativeAudioRecorder_->start();
   mStream_->requestStart();
-  isRunning_.store(true);
+  state_.store(RecorderState::Recording);
+
+  return filePath_;
 }
 
-std::string AndroidAudioRecorder::stop() {
+std::tuple<std::string, double, double> AndroidAudioRecorder::stop() {
+  std::string filePath = filePath_;
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+
   if (!isRecording()) {
-    return "";
+    return {filePath_, 0.0, 0.0};
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
@@ -85,20 +93,25 @@ std::string AndroidAudioRecorder::stop() {
         ANDROID_LOG_ERROR,
         "AndroidAudioRecorder",
         "Audio stream is not initialized.\n");
-    return "";
+    return {filePath_, 0.0, 0.0};
   }
 
   nativeAudioRecorder_->stop();
   mStream_->requestStop();
-  isRunning_.store(false);
-
-  // TODO: sendRemainingData() ?
+  state_.store(RecorderState::Idle);
 
   if (usesFileOutput()) {
-    return fileWriter_->closeFile();
+    auto [size, duration] = fileWriter_->closeFile();
+    outputFileSize = size;
+    outputDuration = duration;
+  }
+
+  if (usesCallback()) {
+    callback_->cleanup();
   }
 
-  return "";
+  filePath_ = "";
+  return {filePath, outputFileSize, outputDuration};
 }
 
 void AndroidAudioRecorder::enableFileOutput(
@@ -125,33 +138,68 @@ void AndroidAudioRecorder::disableFileOutput() {
   fileWriter_ = nullptr;
 }
 
-void AndroidAudioRecorder::pause() {}
+void AndroidAudioRecorder::pause() {
+  if (!isRecording()) {
+    return;
+  }
+
+  mStream_->pause(0);
+  state_.store(RecorderState::Paused);
+}
 
-void AndroidAudioRecorder::resume() {}
+void AndroidAudioRecorder::resume() {
+  if (!isPaused()) {
+    return;
+  }
+
+  mStream_->start(0);
+  state_.store(RecorderState::Recording);
+}
+
+void AndroidAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId) {
+  callback_ = std::make_shared<AndroidRecorderCallback>(
+      audioEventHandlerRegistry_,
+      sampleRate,
+      bufferLength,
+      channelCount,
+      callbackId);
+  callbackOutputEnabled_.store(true);
+}
+
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  callbackOutputEnabled_.store(false);
+  callback_ = nullptr;
+}
 
 DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
+  if (isPaused()) {
+    return DataCallbackResult::Continue;
+  }
+
   if (usesFileOutput()) {
     fileWriter_->writeAudioData(audioData, numFrames);
   }
 
+  if (usesCallback()) {
+    callback_->receiveAudioData(audioData, numFrames);
+  }
+
   return DataCallbackResult::Continue;
 }
 
-} // namespace audioapi
-
-// if (isRunning_.load()) {
-//   auto *inputChannel = static_cast<float *>(audioData);
-//   writeToBuffers(inputChannel, numFrames);
-// }
-
-// while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-//   auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-//   auto *outputChannel = bus->getChannel(0)->getData();
+double AndroidAudioRecorder::getCurrentDuration() const {
+  if (usesFileOutput()) {
+    return fileWriter_->getCurrentDuration();
+  }
 
-//   circularBuffer_->pop_front(outputChannel, bufferLength_);
+  return 0.0;
+}
 
-//   invokeOnAudioReadyCallback(bus, bufferLength_);
-// }
+} // namespace audioapi

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

@@ -6,6 +6,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <tuple>
 
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
@@ -15,6 +16,7 @@ using namespace oboe;
 
 class AudioBus;
 class CircularAudioArray;
+class AndroidRecorderCallback;
 class AndroidFileWriterBackend;
 class AudioEventHandlerRegistry;
 
@@ -23,8 +25,8 @@ class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorde
   explicit AndroidAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AndroidAudioRecorder() override;
 
-  void start() override;
-  std::string stop() override;
+  std::string start() override;
+  std::tuple<std::string, double, double> stop() override;
 
   void enableFileOutput(
       float sampleRate,
@@ -37,18 +39,29 @@ class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorde
   void pause() override;
   void resume() override;
 
+  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  double getCurrentDuration() const override;
+
   DataCallbackResult onAudioReady(
           AudioStream *oboeStream,
           void *audioData,
           int32_t numFrames) override;
 
  private:
-  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
+  std::string filePath_;
   std::shared_ptr<AudioStream> mStream_;
-  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+
+  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
+  std::shared_ptr<AndroidRecorderCallback> callback_;
+
   int32_t streamSampleRate_;
   int32_t streamChannelCount_;
   int32_t streamMaxBufferSizeInFrames_;
+
+  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <tuple>
 #include <string>
 #include <memory>
 
@@ -15,15 +16,18 @@ class AndroidFileWriterBackend {
 
   virtual ~AndroidFileWriterBackend() = default;
 
-  virtual void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::string closeFile() = 0;
+  virtual std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
+  virtual std::tuple<double, double> closeFile() = 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_; }
+
  protected:
   std::string filePath_{""};
+  std::atomic<size_t> framesWritten_{0};
 
   int32_t streamSampleRate_{0};
   int32_t streamChannelCount_{0};

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp

@@ -0,0 +1,187 @@
+#include <android/log.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <memory>
+
+namespace audioapi {
+
+AndroidRecorderCallback::AndroidRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  ringBufferSize_ = std::max((int)bufferLength * 2, 8192);
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto busArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
+    circularBus_[i] = busArray;
+  }
+}
+
+AndroidRecorderCallback::~AndroidRecorderCallback() {
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i].reset();
+  }
+}
+
+void AndroidRecorderCallback::prepare(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    size_t maxInputBufferLength) {
+  ma_result result;
+
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  maxInputBufferLength_ = maxInputBufferLength;
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      ma_format_f32,
+      streamChannelCount_,
+      channelCount_,
+      streamSampleRate_,
+      static_cast<int32_t>(sampleRate_));
+
+  converter_ = std::make_unique<ma_data_converter>();
+  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
+
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidRecorderCallback",
+        "Failed to initialize miniaudio data converter");
+    return;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), maxInputBufferLength_, &processingBufferLength_);
+
+  processingBufferLength_ =
+      std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
+
+  deinterleavingArray_ = std::make_shared<AudioArray>(processingBufferLength_);
+  processingBuffer_ = ma_malloc(
+      processingBufferLength_ * channelCount_ *
+          ma_get_bytes_per_sample(ma_format_f32),
+      NULL);
+}
+
+void AndroidRecorderCallback::cleanup() {
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i].reset();
+  }
+}
+
+void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
+  ma_uint64 inputFrameCount = numFrames;
+  ma_uint64 outputFrameCount = 0;
+
+  if ((float)streamSampleRate_ == sampleRate_ ||
+      streamChannelCount_ == channelCount_) {
+    deinterleaveAndWriteAudioData(data, numFrames);
+    emitAudioData();
+    return;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), inputFrameCount, &outputFrameCount);
+
+  ma_data_converter_process_pcm_frames(
+      converter_.get(),
+      data,
+      &inputFrameCount,
+      processingBuffer_,
+      &outputFrameCount);
+
+  deinterleaveAndWriteAudioData(
+      processingBuffer_, static_cast<int>(outputFrameCount));
+  emitAudioData();
+}
+
+void AndroidRecorderCallback::deinterleaveAndWriteAudioData(
+    void *data,
+    int numFrames) {
+  auto *inputData = static_cast<float *>(data);
+
+  for (size_t channel = 0; channel < channelCount_; ++channel) {
+    float *channelData = deinterleavingArray_->getData();
+
+    for (int frame = 0; frame < numFrames; ++frame) {
+      channelData[frame] = inputData[frame * streamChannelCount_ + channel];
+    }
+
+    circularBus_[channel]->push_back(channelData, numFrames);
+  }
+}
+
+void AndroidRecorderCallback::emitAudioData() {
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus =
+        std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, bufferLength_);
+    }
+
+    invokeCallback(bus, (int)bufferLength_);
+  }
+}
+
+void AndroidRecorderCallback::invokeCallback(
+    const std::shared_ptr<AudioBus> &bus,
+    int numFrames) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject =
+      std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "audioReady", callbackId_, eventPayload);
+  }
+}
+
+void AndroidRecorderCallback::sendRemainingData() {
+  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
+  auto bus = std::make_shared<AudioBus>(
+      circularBus_[0]->getNumberOfAvailableFrames(),
+      channelCount_,
+      sampleRate_);
+
+  for (int i = 0; i < channelCount_; ++i) {
+    auto *outputChannel = bus->getChannel(i)->getData();
+    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
+  }
+
+  invokeCallback(bus, (int)numberOfFrames);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,57 @@
+#pragma once
+
+
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AndroidRecorderCallback {
+ public:
+  AndroidRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      size_t channelCount,
+      uint64_t callbackId);
+  ~AndroidRecorderCallback();
+
+  void prepare(int32_t streamSampleRate, int32_t streamChannelCount, size_t maxInputBufferLength);
+  void cleanup();
+
+  void receiveAudioData(void *data, int numFrames);
+  void emitAudioData();
+
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
+
+ private:
+  int32_t streamSampleRate_;
+  int32_t streamChannelCount_;
+  size_t maxInputBufferLength_;
+
+  float sampleRate_;
+  size_t bufferLength_;
+  size_t channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+
+  ma_uint64 processingBufferLength_{0};
+  void *processingBuffer_{nullptr};
+
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+  std::shared_ptr<AudioArray> deinterleavingArray_;
+
+  void deinterleaveAndWriteAudioData(void *data, int numFrames);
+};
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -1,13 +1,16 @@
 #include <android/log.h>
 #include <cmath>
+
 extern "C" {
-#include <libavutil/log.h>
+#include <libavformat/avio.h>
 }
 
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
 
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
 namespace audioapi {
 
 FFmpegAudioFileWriter::FFmpegAudioFileWriter(
@@ -20,16 +23,6 @@ FFmpegAudioFileWriter::FFmpegAudioFileWriter(
           channelCount,
           bitRate,
           androidFlags) {
-  av_log_set_level(AV_LOG_DEBUG);
-
-  av_log_set_callback([](void *, int level, const char *fmt, va_list vl) {
-    if (level > av_log_get_level())
-      return;
-    char msg[1024];
-    vsnprintf(msg, sizeof(msg), fmt, vl);
-    __android_log_print(ANDROID_LOG_INFO, "FFmpeg", "%s", msg);
-  });
-
   fileOptions_ = std::make_shared<FFmpegAudioFileOptions>(
       sampleRate, channelCount, bitRate, androidFlags);
 }
@@ -39,7 +32,7 @@ FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
   fileOptions_.reset();
 }
 
-void FFmpegAudioFileWriter::openFile(
+std::string FFmpegAudioFileWriter::openFile(
     int32_t streamSampleRate,
     int32_t streamChannelCount,
     int32_t streamMaxBufferSize) {
@@ -48,6 +41,7 @@ void FFmpegAudioFileWriter::openFile(
   streamSampleRate_ = streamSampleRate;
   streamChannelCount_ = streamChannelCount;
   streamMaxBufferSize_ = streamMaxBufferSize;
+  framesWritten_.store(0);
   nextPts_ = 0;
 
   const AVCodec *codec = fileOptions_->getCodec();
@@ -64,7 +58,7 @@ void FFmpegAudioFileWriter::openFile(
         "FFmpegFileWriter",
         "Failed to allocate FFmpeg format context for file: %s",
         filePath_.c_str());
-    return;
+    return "";
   }
 
   formatCtx_ = AVFormatContextPtr(rawFormatCtx);
@@ -77,7 +71,7 @@ void FFmpegAudioFileWriter::openFile(
         ANDROID_LOG_ERROR,
         "FFmpegFileWriter",
         "Failed to allocate FFmpeg codec context for file");
-    return;
+    return "";
   }
 
   AVDictionary *codecOptions = nullptr;
@@ -104,7 +98,7 @@ void FFmpegAudioFileWriter::openFile(
         "FFmpegFileWriter",
         "Failed to open FFmpeg codec for file");
     av_dict_free(&codecOptions);
-    return;
+    return "";
   }
 
   av_dict_free(&codecOptions);
@@ -115,7 +109,7 @@ void FFmpegAudioFileWriter::openFile(
         ANDROID_LOG_ERROR,
         "FFmpegFileWriter",
         "Failed to copy codec parameters to stream for file");
-    return;
+    return "";
   }
 
   if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
@@ -125,7 +119,7 @@ void FFmpegAudioFileWriter::openFile(
           "FFmpegFileWriter",
           "Failed to open output file: %s",
           filePath_.c_str());
-      return;
+      return "";
     }
   }
 
@@ -138,7 +132,7 @@ void FFmpegAudioFileWriter::openFile(
         "FFmpegFileWriter",
         "Failed to write header to file: %s",
         filePath_.c_str());
-    return;
+    return "";
   }
 
   frame_ = AVFramePtr(av_frame_alloc());
@@ -171,7 +165,7 @@ void FFmpegAudioFileWriter::openFile(
         "FFmpegFileWriter",
         "Failed to initialize resampler for file: %s",
         filePath_.c_str());
-    return;
+    return "";
   }
 
   int contextFrameRatio = 2;
@@ -198,11 +192,13 @@ void FFmpegAudioFileWriter::openFile(
       fifoSize);
 
   isFileOpen_.store(true);
+
+  return filePath_;
 }
 
-std::string FFmpegAudioFileWriter::closeFile() {
+std::tuple<double, double> FFmpegAudioFileWriter::closeFile() {
   if (!isFileOpen()) {
-    return "";
+    return {0.0, 0.0};
   }
 
   isFileOpen_.store(false);
@@ -273,6 +269,9 @@ std::string FFmpegAudioFileWriter::closeFile() {
         filePath_.c_str());
   }
 
+  double fileSizeInMB = avio_size(formatCtx_->pb) / BYTES_TO_MB;
+  double durationInSeconds = getCurrentDuration();
+
   if (formatCtx_ && formatCtx_->pb) {
     avio_closep(&formatCtx_->pb);
   }
@@ -284,10 +283,8 @@ std::string FFmpegAudioFileWriter::closeFile() {
   formatCtx_.reset();
   audioFifo_.reset();
 
-  std::string closedFilePath = filePath_;
   filePath_ = "";
-
-  return closedFilePath;
+  return {fileSizeInMB, durationInSeconds};
 }
 
 bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
@@ -409,6 +406,7 @@ bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
     av_frame_unref(frame_.get());
   }
 
+  framesWritten_.fetch_add(numFrames);
   return true;
 }
 

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h

@@ -13,6 +13,7 @@ extern "C" {
 
 #include <string>
 #include <memory>
+#include <tuple>
 
 namespace audioapi {
 
@@ -82,8 +83,8 @@ class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
     size_t androidFlags);
   ~FFmpegAudioFileWriter() 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;