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

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -2,6 +2,10 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
 
 // Implementation of channel summing/mixing is based on the WebKit approach,
 // source:
@@ -16,9 +20,7 @@ namespace audioapi {
  */
 
 AudioBus::AudioBus(size_t size, int numberOfChannels, float sampleRate)
-    : numberOfChannels_(numberOfChannels),
-      sampleRate_(sampleRate),
-      size_(size) {
+    : numberOfChannels_(numberOfChannels), sampleRate_(sampleRate), size_(size) {
   createChannels();
 }
 
@@ -34,6 +36,34 @@ AudioBus::AudioBus(const AudioBus &other) {
   }
 }
 
+AudioBus::AudioBus(AudioBus &&other) noexcept
+    : channels_(std::move(other.channels_)),
+      numberOfChannels_(other.numberOfChannels_),
+      sampleRate_(other.sampleRate_),
+      size_(other.size_) {
+  other.numberOfChannels_ = 0;
+  other.sampleRate_ = 0.0f;
+  other.size_ = 0;
+}
+
+AudioBus &AudioBus::operator=(const AudioBus &other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  numberOfChannels_ = other.numberOfChannels_;
+  sampleRate_ = other.sampleRate_;
+  size_ = other.size_;
+
+  createChannels();
+
+  for (int i = 0; i < numberOfChannels_; i += 1) {
+    channels_[i] = std::make_shared<AudioArray>(*other.channels_[i]);
+  }
+
+  return *this;
+}
+
 AudioBus::~AudioBus() {
   channels_.clear();
 }
@@ -182,9 +212,7 @@ float AudioBus::maxAbsValue() const {
   return maxAbsValue;
 }
 
-void AudioBus::sum(
-    const AudioBus *source,
-    ChannelInterpretation interpretation) {
+void AudioBus::sum(const AudioBus *source, ChannelInterpretation interpretation) {
   sum(source, 0, 0, getSize(), interpretation);
 }
 
@@ -228,8 +256,7 @@ void AudioBus::sum(
 
   // Source and destination channel counts are the same. Just sum the channels.
   for (int i = 0; i < numberOfChannels_; i += 1) {
-    getChannel(i)->sum(
-        source->getChannel(i), sourceStart, destinationStart, length);
+    getChannel(i)->sum(source->getChannel(i), sourceStart, destinationStart, length);
   }
 }
 
@@ -252,8 +279,7 @@ void AudioBus::copy(
 
   if (source->getNumberOfChannels() == getNumberOfChannels()) {
     for (int i = 0; i < getNumberOfChannels(); i += 1) {
-      getChannel(i)->copy(
-          source->getChannel(i), sourceStart, destinationStart, length);
+      getChannel(i)->copy(source->getChannel(i), sourceStart, destinationStart, length);
     }
 
     return;
@@ -285,15 +311,13 @@ void AudioBus::discreteSum(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) const {
-  int numberOfChannels =
-      std::min(getNumberOfChannels(), source->getNumberOfChannels());
+  int numberOfChannels = std::min(getNumberOfChannels(), source->getNumberOfChannels());
 
   // In case of source > destination, we "down-mix" and drop the extra channels.
   // In case of source < destination, we "up-mix" as many channels as we have,
   // leaving the remaining channels untouched.
   for (int i = 0; i < numberOfChannels; i++) {
-    getChannel(i)->sum(
-        source->getChannel(i), sourceStart, destinationStart, length);
+    getChannel(i)->sum(source->getChannel(i), sourceStart, destinationStart, length);
   }
 }
 
@@ -306,14 +330,11 @@ void AudioBus::sumByUpMixing(
   int numberOfChannels = getNumberOfChannels();
 
   // Mono to stereo (1 -> 2, 4)
-  if (numberOfSourceChannels == 1 &&
-      (numberOfChannels == 2 || numberOfChannels == 4)) {
+  if (numberOfSourceChannels == 1 && (numberOfChannels == 2 || numberOfChannels == 4)) {
     AudioArray *sourceChannel = source->getChannelByType(ChannelMono);
 
-    getChannelByType(ChannelLeft)
-        ->sum(sourceChannel, sourceStart, destinationStart, length);
-    getChannelByType(ChannelRight)
-        ->sum(sourceChannel, sourceStart, destinationStart, length);
+    getChannelByType(ChannelLeft)->sum(sourceChannel, sourceStart, destinationStart, length);
+    getChannelByType(ChannelRight)->sum(sourceChannel, sourceStart, destinationStart, length);
     return;
   }
 
@@ -321,55 +342,30 @@ void AudioBus::sumByUpMixing(
   if (numberOfSourceChannels == 1 && numberOfChannels == 6) {
     AudioArray *sourceChannel = source->getChannel(0);
 
-    getChannelByType(ChannelCenter)
-        ->sum(sourceChannel, sourceStart, destinationStart, length);
+    getChannelByType(ChannelCenter)->sum(sourceChannel, sourceStart, destinationStart, length);
     return;
   }
 
   // Stereo 2 to stereo 4 or 5.1 (2 -> 4, 6)
-  if (numberOfSourceChannels == 2 &&
-      (numberOfChannels == 4 || numberOfChannels == 6)) {
+  if (numberOfSourceChannels == 2 && (numberOfChannels == 4 || numberOfChannels == 6)) {
     getChannelByType(ChannelLeft)
-        ->sum(
-            source->getChannelByType(ChannelLeft),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelRight)
-        ->sum(
-            source->getChannelByType(ChannelRight),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelRight), sourceStart, destinationStart, length);
     return;
   }
 
   // Stereo 4 to 5.1 (4 -> 6)
   if (numberOfSourceChannels == 4 && numberOfChannels == 6) {
     getChannelByType(ChannelLeft)
-        ->sum(
-            source->getChannelByType(ChannelLeft),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelRight)
-        ->sum(
-            source->getChannelByType(ChannelRight),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelRight), sourceStart, destinationStart, length);
     getChannelByType(ChannelSurroundLeft)
-        ->sum(
-            source->getChannelByType(ChannelSurroundLeft),
-            sourceStart,
-            destinationStart,
-            length);
+        ->sum(source->getChannelByType(ChannelSurroundLeft), sourceStart, destinationStart, length);
     getChannelByType(ChannelSurroundRight)
         ->sum(
-            source->getChannelByType(ChannelSurroundRight),
-            sourceStart,
-            destinationStart,
-            length);
+            source->getChannelByType(ChannelSurroundRight), sourceStart, destinationStart, length);
     return;
   }
 
@@ -392,15 +388,9 @@ void AudioBus::sumByDownMixing(
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.5f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.5f, destinationData + destinationStart, length);
     return;
   }
 
@@ -410,33 +400,19 @@ void AudioBus::sumByDownMixing(
   if (numberOfSourceChannels == 4 && numberOfChannels == 1) {
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
-    float *sourceSurroundLeft =
-        source->getChannelByType(ChannelSurroundLeft)->getData();
-    float *sourceSurroundRight =
-        source->getChannelByType(ChannelSurroundRight)->getData();
+    float *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.25f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.25f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.25f, destinationData + destinationStart, length);
     return;
   }
 
@@ -447,38 +423,24 @@ void AudioBus::sumByDownMixing(
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
     float *sourceCenter = source->getChannelByType(ChannelCenter)->getData();
-    float *sourceSurroundLeft =
-        source->getChannelByType(ChannelSurroundLeft)->getData();
-    float *sourceSurroundRight =
-        source->getChannelByType(ChannelSurroundRight)->getData();
+    float *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationData = getChannelByType(ChannelMono)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        SQRT_HALF,
-        destinationData + destinationStart,
-        length);
+        sourceLeft + sourceStart, SQRT_HALF, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        SQRT_HALF,
-        destinationData + destinationStart,
-        length);
+        sourceRight + sourceStart, SQRT_HALF, destinationData + destinationStart, length);
     dsp::add(
         sourceCenter + sourceStart,
         destinationData + destinationStart,
         destinationData + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.5f, destinationData + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.5f,
-        destinationData + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.5f, destinationData + destinationStart, length);
 
     return;
   }
@@ -489,35 +451,21 @@ void AudioBus::sumByDownMixing(
   if (numberOfSourceChannels == 4 && numberOfChannels == 2) {
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
-    float *sourceSurroundLeft =
-        source->getChannelByType(ChannelSurroundLeft)->getData();
-    float *sourceSurroundRight =
-        source->getChannelByType(ChannelSurroundRight)->getData();
+    float *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceLeft + sourceStart,
-        0.5f,
-        destinationLeft + destinationStart,
-        length);
+        sourceLeft + sourceStart, 0.5f, destinationLeft + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        0.5f,
-        destinationLeft + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, 0.5f, destinationLeft + destinationStart, length);
 
     dsp::multiplyByScalarThenAddToOutput(
-        sourceRight + sourceStart,
-        0.5f,
-        destinationRight + destinationStart,
-        length);
+        sourceRight + sourceStart, 0.5f, destinationRight + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        0.5f,
-        destinationRight + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, 0.5f, destinationRight + destinationStart, length);
     return;
   }
 
@@ -529,10 +477,8 @@ void AudioBus::sumByDownMixing(
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
     float *sourceCenter = source->getChannelByType(ChannelCenter)->getData();
-    float *sourceSurroundLeft =
-        source->getChannelByType(ChannelSurroundLeft)->getData();
-    float *sourceSurroundRight =
-        source->getChannelByType(ChannelSurroundRight)->getData();
+    float *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
@@ -543,15 +489,9 @@ void AudioBus::sumByDownMixing(
         destinationLeft + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceCenter + sourceStart,
-        SQRT_HALF,
-        destinationLeft + destinationStart,
-        length);
+        sourceCenter + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundLeft + sourceStart,
-        SQRT_HALF,
-        destinationLeft + destinationStart,
-        length);
+        sourceSurroundLeft + sourceStart, SQRT_HALF, destinationLeft + destinationStart, length);
 
     dsp::add(
         sourceRight + sourceStart,
@@ -559,15 +499,9 @@ void AudioBus::sumByDownMixing(
         destinationRight + destinationStart,
         length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceCenter + sourceStart,
-        SQRT_HALF,
-        destinationRight + destinationStart,
-        length);
+        sourceCenter + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
     dsp::multiplyByScalarThenAddToOutput(
-        sourceSurroundRight + sourceStart,
-        SQRT_HALF,
-        destinationRight + destinationStart,
-        length);
+        sourceSurroundRight + sourceStart, SQRT_HALF, destinationRight + destinationStart, length);
     return;
   }
 
@@ -580,17 +514,13 @@ void AudioBus::sumByDownMixing(
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
     float *sourceCenter = source->getChannelByType(ChannelCenter)->getData();
-    float *sourceSurroundLeft =
-        source->getChannelByType(ChannelSurroundLeft)->getData();
-    float *sourceSurroundRight =
-        source->getChannelByType(ChannelSurroundRight)->getData();
+    float *sourceSurroundLeft = source->getChannelByType(ChannelSurroundLeft)->getData();
+    float *sourceSurroundRight = source->getChannelByType(ChannelSurroundRight)->getData();
 
     float *destinationLeft = getChannelByType(ChannelLeft)->getData();
     float *destinationRight = getChannelByType(ChannelRight)->getData();
-    float *destinationSurroundLeft =
-        getChannelByType(ChannelSurroundLeft)->getData();
-    float *destinationSurroundRight =
-        getChannelByType(ChannelSurroundRight)->getData();
+    float *destinationSurroundLeft = getChannelByType(ChannelSurroundLeft)->getData();
+    float *destinationSurroundRight = getChannelByType(ChannelSurroundRight)->getData();
 
     dsp::add(
         sourceLeft + sourceStart,

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

@@ -3,9 +3,9 @@
 #include <audioapi/core/types/ChannelInterpretation.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 
@@ -24,8 +24,11 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
+  explicit AudioBus() = default;
   explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
   AudioBus(const AudioBus &other);
+  AudioBus(AudioBus &&other) noexcept;
+  AudioBus &operator=(const AudioBus &other);
 
   ~AudioBus();
 
@@ -46,21 +49,24 @@ class AudioBus {
   void zero();
   void zero(size_t start, size_t length);
 
-  void sum(const AudioBus *source, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
-  void sum(const AudioBus *source, size_t start, size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+  void sum(
+      const AudioBus *source,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+  void sum(
+      const AudioBus *source,
+      size_t start,
+      size_t length,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
   void sum(
       const AudioBus *source,
       size_t sourceStart,
       size_t destinationStart,
-      size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
+      size_t length,
+      ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
 
   void copy(const AudioBus *source);
   void copy(const AudioBus *source, size_t start, size_t length);
-  void copy(
-      const AudioBus *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void copy(const AudioBus *source, size_t sourceStart, size_t destinationStart, size_t length);
 
  private:
   std::vector<std::shared_ptr<AudioArray>> channels_;
@@ -75,11 +81,8 @@ class AudioBus {
       size_t sourceStart,
       size_t destinationStart,
       size_t length) const;
-  void sumByUpMixing(
-      const AudioBus *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void
+  sumByUpMixing(const AudioBus *source, size_t sourceStart, size_t destinationStart, size_t length);
   void sumByDownMixing(
       const AudioBus *source,
       size_t sourceStart,

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 Format {
+    WAV = 1,
+    CAF = 2,
+    M4A = 3,
+    FLAC = 4,
+  };
+
+  enum class BitDepth {
+    Bit16 = 1,
+    Bit24 = 2,
+    Bit32 = 3,
+  };
+
+  enum class IOSAudioQuality {
+    Min = 1,
+    Low = 2,
+    Medium = 3,
+    High = 4,
+    Max = 5,
+  };
+
+  enum class FileDirectory {
+    Document = 1,
+    Cache = 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

package/common/cpp/audioapi/utils/CircularAudioArray.cpp

@@ -4,10 +4,7 @@ namespace audioapi {
 
 CircularAudioArray::CircularAudioArray(size_t size) : AudioArray(size) {}
 
-void CircularAudioArray::push_back(
-    const float *data,
-    size_t size,
-    bool skipAvailableSpaceCheck) {
+void CircularAudioArray::push_back(const float *data, size_t size, bool skipAvailableSpaceCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -24,14 +21,10 @@ void CircularAudioArray::push_back(
     memcpy(data_ + vWriteIndex_, data, size * sizeof(float));
   }
 
-  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_
-                                             : vWriteIndex_ + size;
+  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_ : vWriteIndex_ + size;
 }
 
-void CircularAudioArray::pop_front(
-    float *data,
-    size_t size,
-    bool skipAvailableDataCheck) {
+void CircularAudioArray::pop_front(float *data, size_t size, bool skipAvailableDataCheck) {
   if (size > size_) {
     throw std::overflow_error("size exceeds CircularAudioArray size_");
   }
@@ -48,8 +41,7 @@ void CircularAudioArray::pop_front(
     memcpy(data, data_ + vReadIndex_, size * sizeof(float));
   }
 
-  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_
-                                           : vReadIndex_ + size;
+  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_ : vReadIndex_ + size;
 }
 
 void CircularAudioArray::pop_back(
@@ -66,10 +58,7 @@ void CircularAudioArray::pop_back(
   }
 
   if (vWriteIndex_ <= offset) {
-    memcpy(
-        data,
-        data_ + size_ - (offset - vWriteIndex_) - size,
-        size * sizeof(float));
+    memcpy(data, data_ + size_ - (offset - vWriteIndex_) - size, size * sizeof(float));
   } else if (vWriteIndex_ <= size + offset) {
     auto partSize = size + offset - vWriteIndex_;
     memcpy(data, data_ + size_ - partSize, partSize * sizeof(float));
@@ -78,8 +67,7 @@ void CircularAudioArray::pop_back(
     memcpy(data, data_ + vWriteIndex_ - size - offset, size * sizeof(float));
   }
 
-  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset
-                                          : vWriteIndex_ - offset;
+  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset : vWriteIndex_ - offset;
 }
 
 size_t CircularAudioArray::getNumberOfAvailableFrames() const {