react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

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

@@ -1,62 +1,82 @@
 #pragma once
 
+#include <audioapi/utils/Result.hpp>
 #include <atomic>
 #include <memory>
 #include <mutex>
+#include <string>
+#include <tuple>
 
 namespace audioapi {
 
-class RecorderAdapterNode;
 class AudioBus;
+class AudioFileWriter;
 class CircularAudioArray;
-class CircularOverflowableAudioArray;
+class RecorderAdapterNode;
+class AudioFileProperties;
+class AudioRecorderCallback;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
+  enum class RecorderState { Idle = 0, Recording, Paused };
   explicit AudioRecorder(
-      float sampleRate,
-      int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+      : audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
   virtual ~AudioRecorder() = default;
 
-  void setOnAudioReadyCallbackId(uint64_t callbackId);
-  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
+  virtual Result<std::string, std::string> start() = 0;
+  virtual Result<std::tuple<std::string, double, double>, std::string> stop() = 0;
+
+  virtual Result<std::string, std::string> enableFileOutput(
+      std::shared_ptr<AudioFileProperties> properties) = 0;
+  virtual void disableFileOutput() = 0;
+
+  virtual void pause() = 0;
+  virtual void resume() = 0;
+
+  virtual void connect(const std::shared_ptr<RecorderAdapterNode> &node) = 0;
+  virtual void disconnect() = 0;
 
-  /// @brief
-  /// # Connects the recorder to the adapter node.
-  ///
-  /// The adapter node will be used to read audio data from the recorder.
-  /// @note Few frames of audio might not yet be written to the buffer when connecting.
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
+  virtual Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
 
-  /// @brief
-  /// # Disconnects the recorder from the adapter node.
-  ///
-  /// The adapter node will no longer be used to read audio data from the recorder.
-  /// @note Last few frames of audio might be written to the buffer after disconnecting.
-  void disconnect();
+  virtual double getCurrentDuration() const;
 
-  virtual void start() = 0;
-  virtual void stop() = 0;
+  bool usesCallback() const;
+  bool usesFileOutput() const;
+  bool isConnected() const;
+
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
 
  protected:
-  float sampleRate_;
-  int bufferLength_;
-  size_t ringBufferSize_;
+  std::atomic<RecorderState> state_{RecorderState::Idle};
 
-  std::atomic<bool> isRunning_;
-  std::shared_ptr<CircularAudioArray> circularBuffer_;
+  std::atomic<bool> isConnected_{false};
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
 
-  mutable std::mutex adapterNodeLock_;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+  std::mutex errorCallbackMutex_;
+  mutable std::mutex adapterNodeMutex_;
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
+  std::atomic<uint64_t> errorCallbackId_{0};
 
-  void writeToBuffers(const float *data, int numFrames);
+  std::string filePath_{""};
+  std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
+  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp

@@ -1,5 +1,7 @@
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <memory>
@@ -15,34 +17,60 @@ RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
   isInitialized_ = false;
 }
 
-void RecorderAdapterNode::init(size_t bufferSize) {
+void RecorderAdapterNode::init(size_t bufferSize, int channelCount) {
   if (isInitialized_) {
-    throw std::runtime_error(
-        "RecorderAdapterNode should not be initialized more than once. Just create a new instance.");
+    return;
   }
+
+  channelCount_ = channelCount;
+
+  buff_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    buff_[i] = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+  }
+
+  // This assumes that the sample rate is the same in audio context and recorder.
+  // (recorder is not enforcing any sample rate on the system*). This means that only
+  // channel mixing might be required. To do so, we create an output bus with
+  // the desired channel count and will take advantage of the AudioBus sum method.
+  //
+  // * any allocations required by the recorder (including this method) are during recording start
+  // or after, which means that audio context has already setup the system in 99% of sane cases.
+  // But if we would like to support cases when context is created on the fly during recording,
+  // we would need to add sample rate conversion as well or other weird bullshit like resampling
+  // context output and not enforcing anything on the system output/input configuration.
+  // A lot of words for a couple of lines of implementation :shrug:
+  adapterOutputBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
   isInitialized_ = true;
-  buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
+}
+
+void RecorderAdapterNode::cleanup() {
+  isInitialized_ = false;
+  buff_.clear();
+  adapterOutputBus_.reset();
 }
 
 std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
-  float *outputChannel = processingBus->getChannel(0)->getData();
-  readFrames(outputChannel, framesToProcess);
-
-  for (int i = 1; i < processingBus->getNumberOfChannels(); i++) {
-    processingBus->getChannel(i)->copy(processingBus->getChannel(0), 0, framesToProcess);
+  if (!isInitialized_) {
+    processingBus->zero();
+    return processingBus;
   }
 
+  readFrames(framesToProcess);
+
+  processingBus->sum(adapterOutputBus_.get(), ChannelInterpretation::SPEAKERS);
   return processingBus;
 }
 
-void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {
-  size_t readFrames = buff_->read(output, framesToRead);
+void RecorderAdapterNode::readFrames(const size_t framesToRead) {
+  adapterOutputBus_->zero();
 
-  if (readFrames < framesToRead) {
-    // Fill the rest with silence
-    std::memset(output + readFrames, 0, (framesToRead - readFrames) * sizeof(float));
+  for (size_t channel = 0; channel < channelCount_; ++channel) {
+    buff_[channel]->read(adapterOutputBus_->getChannel(channel)->getData(), framesToRead);
   }
 }
 

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.h

@@ -6,6 +6,7 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -20,26 +21,28 @@ class RecorderAdapterNode : public AudioNode {
  public:
   explicit RecorderAdapterNode(BaseAudioContext *context);
 
-  /// @brief Initialize the RecorderAdapterNode with a buffer size.
+  /// @brief Initialize the RecorderAdapterNode with a buffer size and channel count.
   /// @note This method should be called ONLY ONCE when the buffer size is known.
-  /// @throws std::runtime_error if the node is already initialized.
   /// @param bufferSize The size of the buffer to be used.
-  void init(size_t bufferSize);
+  /// @param channelCount The number of channels.
+  void init(size_t bufferSize, int channelCount);
+  void cleanup();
+
+  int channelCount_;
+  // TODO: CircularOverflowableAudioBus
+  std::vector<std::shared_ptr<CircularOverflowableAudioArray>> buff_;
 
  protected:
   std::shared_ptr<AudioBus> processNode(
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override;
-  std::shared_ptr<CircularOverflowableAudioArray> buff_;
+  std::shared_ptr<AudioBus> adapterOutputBus_;
 
  private:
-  /// @brief Read audio frames from the recorder's internal adapterBuffer.
+  /// @brief Read audio frames from the recorder's internal circular buffer into output buss.
   /// @note If `framesToRead` is greater than the number of available frames, it will fill empty space with silence.
-  /// @param output Pointer to the output buffer.
   /// @param framesToRead Number of frames to read.
-  void readFrames(float *output, size_t framesToRead);
-
-  friend class AudioRecorder;
+  void readFrames(size_t framesToRead);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioFileWriter.cpp

@@ -0,0 +1,41 @@
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+AudioFileWriter::AudioFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry), fileProperties_(fileProperties) {}
+
+void AudioFileWriter::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioFileWriter::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+void AudioFileWriter::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
+  // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
+  // TL;DR: atomic szpont
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+bool AudioFileWriter::isFileOpen() {
+  return isFileOpen_.load(std::memory_order_acquire);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioFileWriter.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+typedef Result<std::string, std::string> OpenFileResult;
+typedef Result<std::tuple<double, double>, std::string> CloseFileResult;
+
+class AudioFileWriter {
+ public:
+  AudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  virtual ~AudioFileWriter() = default;
+
+  virtual CloseFileResult closeFile() = 0;
+
+  virtual std::string getFilePath() const = 0;
+  virtual double getCurrentDuration() const = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  bool isFileOpen();
+
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<size_t> framesWritten_{0};
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -0,0 +1,101 @@
+
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+/// @brief Constructor
+/// Allocates circular buffer (as every property to do so is already known at this point).
+/// @param audioEventHandlerRegistry The audio event handler registry
+/// @param sampleRate The user desired sample rate
+/// @param bufferLength The user desired buffer length
+/// @param channelCount The user desired channel count
+/// @param callbackId The callback identifier
+AudioRecorderCallback::AudioRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  ringBufferSize_ = std::max(bufferLength * 2, static_cast<size_t>(8192));
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    circularBus_[i] = std::make_shared<CircularAudioArray>(ringBufferSize_);
+  }
+
+  isInitialized_.store(true, std::memory_order_release);
+}
+
+AudioRecorderCallback::~AudioRecorderCallback() {
+  isInitialized_.store(false, std::memory_order_release);
+}
+
+/// @brief Emits audio data from the circular buffer when enough frames are available.
+/// @param flush If true, emits all available data regardless of buffer length.
+void AudioRecorderCallback::emitAudioData(bool flush) {
+  size_t sizeLimit = flush ? circularBus_[0]->getNumberOfAvailableFrames() : bufferLength_;
+
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= sizeLimit) {
+    auto bus = std::make_shared<AudioBus>(sizeLimit, channelCount_, sampleRate_);
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, sizeLimit);
+    }
+
+    invokeCallback(bus, static_cast<int>(sizeLimit));
+  }
+}
+
+void AudioRecorderCallback::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 AudioRecorderCallback::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioRecorderCallback::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+/// @brief Invokes the error callback with the provided message.
+/// @param message The error message to be sent to the callback.
+void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AudioRecorderCallback {
+ public:
+  AudioRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId);
+  virtual ~AudioRecorderCallback();
+
+  virtual void cleanup() = 0;
+
+  void emitAudioData(bool flush = false);
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  std::atomic<bool> isInitialized_{false};
+
+  float sampleRate_;
+  size_t bufferLength_;
+  int channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+
+  // TODO: CircularAudioBus
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/utils/AudioFileProperties.cpp

@@ -0,0 +1,92 @@
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <jsi/jsi.h>
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+AudioFileProperties::AudioFileProperties(
+    FileDirectory directory,
+    const std::string &subDirectory,
+    const std::string &fileNamePrefix,
+    int channelCount,
+    size_t batchDurationSeconds,
+    Format format,
+    float sampleRate,
+    size_t bitRate,
+    BitDepth bitDepth,
+    int flacCompressionLevel,
+    int androidFlushIntervalMs,
+    IOSAudioQuality iosAudioQuality)
+    : directory(directory),
+      subDirectory(subDirectory),
+      fileNamePrefix(fileNamePrefix),
+      channelCount(channelCount),
+      batchDurationSeconds(batchDurationSeconds),
+      format(format),
+      sampleRate(sampleRate),
+      bitRate(bitRate),
+      bitDepth(bitDepth),
+      flacCompressionLevel(flacCompressionLevel),
+      androidFlushIntervalMs(androidFlushIntervalMs),
+      iosAudioQuality(iosAudioQuality) {}
+
+std::shared_ptr<AudioFileProperties> AudioFileProperties::CreateFromJSIValue(
+    facebook::jsi::Runtime &runtime,
+    const facebook::jsi::Value &value) {
+  auto options = value.getObject(runtime);
+
+  FileDirectory directory =
+      static_cast<FileDirectory>(options.getProperty(runtime, "directory").getNumber());
+
+  std::string subDirectory =
+      options.getProperty(runtime, "subDirectory").asString(runtime).utf8(runtime);
+
+  std::string fileNamePrefix =
+      options.getProperty(runtime, "fileNamePrefix").asString(runtime).utf8(runtime);
+
+  int channelCount = static_cast<int>(options.getProperty(runtime, "channelCount").getNumber());
+
+  size_t batchDurationSeconds =
+      static_cast<size_t>(options.getProperty(runtime, "batchDurationSeconds").getNumber());
+
+  Format format = static_cast<Format>(options.getProperty(runtime, "format").getNumber());
+
+  int androidFlushIntervalMs =
+      static_cast<int>(options.getProperty(runtime, "androidFlushIntervalMs").getNumber());
+
+  auto presetOptions = options.getProperty(runtime, "preset").getObject(runtime);
+
+  float sampleRate =
+      static_cast<float>(presetOptions.getProperty(runtime, "sampleRate").getNumber());
+
+  size_t bitRate = static_cast<size_t>(presetOptions.getProperty(runtime, "bitRate").getNumber());
+
+  BitDepth bitDepth =
+      static_cast<BitDepth>(presetOptions.getProperty(runtime, "bitDepth").getNumber());
+
+  int flacCompressionLevel =
+      static_cast<int>(presetOptions.getProperty(runtime, "flacCompressionLevel").getNumber());
+
+  IOSAudioQuality iosAudioQuality =
+      static_cast<IOSAudioQuality>(presetOptions.getProperty(runtime, "iosQuality").getNumber());
+
+  return std::make_shared<AudioFileProperties>(
+      directory,
+      subDirectory,
+      fileNamePrefix,
+      channelCount,
+      batchDurationSeconds,
+      format,
+      sampleRate,
+      bitRate,
+      bitDepth,
+      flacCompressionLevel,
+      androidFlushIntervalMs,
+      iosAudioQuality);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/utils/AudioFileProperties.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+namespace facebook {
+namespace jsi {
+class Runtime;
+class Value;
+} // namespace jsi
+} // namespace facebook
+
+namespace audioapi {
+
+class AudioFileProperties {
+ public:
+  enum class FileDirectory {
+    Document = 0,
+    Cache = 1,
+  };
+
+  enum class Format {
+    WAV = 0,
+    CAF = 1,
+    M4A = 2,
+    FLAC = 3,
+  };
+
+  enum class IOSAudioQuality {
+    Min = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3,
+    Max = 4,
+  };
+
+  enum class BitDepth {
+    Bit16 = 0,
+    Bit24 = 1,
+    Bit32 = 2,
+  };
+
+  AudioFileProperties(
+      FileDirectory directory,
+      const std::string &subDirectory,
+      const std::string &fileNamePrefix,
+      int channelCount,
+      size_t batchDurationSeconds,
+      Format format,
+      float sampleRate,
+      size_t bitRate,
+      BitDepth bitDepth,
+      int flacCompressionLevel,
+      int androidFlushIntervalMs,
+      IOSAudioQuality iosAudioQuality);
+
+  static std::shared_ptr<AudioFileProperties> CreateFromJSIValue(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value &value);
+
+  FileDirectory directory;
+  std::string subDirectory;
+  std::string fileNamePrefix;
+  int channelCount;
+  size_t batchDurationSeconds;
+  Format format;
+  float sampleRate;
+  size_t bitRate;
+  BitDepth bitDepth;
+  int flacCompressionLevel;
+  int androidFlushIntervalMs;
+  IOSAudioQuality iosAudioQuality;
+};
+
+} // namespace audioapi