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

package/common/cpp/audioapi/libs/ffmpeg/relinking.md

@@ -0,0 +1,24 @@
+## If you would like to relink ffmpeg to your implementation there are two options:
+
+### Option A)
+
+you can modify script in scripts/download-prebuilt-binaries.sh
+
+- ios dynamic frameworks are in `ffmpeg_ios.zip` directory
+- android shared libraries are in `jniLibs.zip`
+
+just replace way of downloading them that links to your binaries
+
+### Option B)
+
+directly modify libraries in source code
+
+- ios dynamic frameworks are placed in `common/cpp/audioapi/external`
+- android shared libraries are placed in `android/src/main/jniLibs`
+
+---
+`USED_LIBRARIES`:
+- libavcodec
+- libavformat
+- libavutil
+- libswresample

package/common/cpp/audioapi/utils/AlignedAllocator.hpp

@@ -0,0 +1,53 @@
+#pragma once
+#include <cstddef>
+#include <new>
+
+template <typename T, std::size_t Align = 16>
+class AlignedAllocator {
+ public:
+  using value_type = T;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  AlignedAllocator() noexcept = default;
+  template <class U>
+  AlignedAllocator(const AlignedAllocator<U, Align> &) noexcept {}
+
+  T *allocate(std::size_t n) {
+    // We want to maximize performance on hot paths, so we hint unlikely branches
+    if (n == 0) [[unlikely]] {
+      return nullptr;
+    }
+    std::size_t bytes = n * sizeof(T);
+    // C++17 aligned new
+    void *p = ::operator new(bytes, std::align_val_t(Align));
+
+    // We have more serious problems if this happens than speed concerns
+    // so we can opt the branch prediction
+    if (!p) [[unlikely]] {
+      throw std::bad_alloc();
+    }
+    return static_cast<T *>(p);
+  }
+
+  void deallocate(T *p, std::size_t) noexcept {
+    ::operator delete(p, std::align_val_t(Align));
+  }
+
+  // Rebind allocator to type U (required by std::vector)
+  template <class U>
+  struct rebind {
+    using other = AlignedAllocator<U, Align>;
+  };
+
+  // Comparison operators (required by std::vector)
+  template <typename U, std::size_t UAlign>
+  bool operator==(const AlignedAllocator<U, UAlign> &) const noexcept {
+    return Align == UAlign;
+  }
+
+  template <typename U, std::size_t UAlign>
+  bool operator!=(const AlignedAllocator<U, UAlign> &) const noexcept {
+    return Align != UAlign;
+  }
+};

package/common/cpp/audioapi/utils/AudioArray.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
+#include <algorithm>
 
 namespace audioapi {
 
@@ -93,10 +94,7 @@ void AudioArray::sum(
     size_t destinationStart,
     size_t length) {
   dsp::add(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      data_ + destinationStart,
-      length);
+      data_ + destinationStart, source->getData() + sourceStart, data_ + destinationStart, length);
 }
 
 void AudioArray::copy(const AudioArray *source) {
@@ -112,10 +110,7 @@ void AudioArray::copy(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) {
-  memcpy(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      length * sizeof(float));
+  memcpy(data_ + destinationStart, source->getData() + sourceStart, length * sizeof(float));
 }
 
 } // namespace audioapi

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

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <algorithm>
-#include <memory>
 #include <cstddef>
 #include <cstring>
+#include <memory>
 
 namespace audioapi {
 
@@ -29,19 +29,11 @@ class AudioArray {
 
   void sum(const AudioArray *source);
   void sum(const AudioArray *source, size_t start, size_t length);
-  void sum(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void sum(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
   void copy(const AudioArray *source);
   void copy(const AudioArray *source, size_t start, size_t length);
-  void copy(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void copy(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
  protected:
   float *data_;

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,