react-native-audio-api 0.4.8-rc2 → 0.4.8

package/android/build.gradle

@@ -118,13 +118,36 @@ android {
                   "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                   "-DANDROID_TOOLCHAIN=clang",
                   "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
-                  "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}"
+                  "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}",
+                  "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
       }
     }
   }
 
   packagingOptions {
-    excludes = ["**/libc++_shared.so", "**/libfbjni.so", "**/libjsi.so", "**/libreactnativejni.so", "**/libfolly_json.so", "**/libreanimated.so", "**/libjscexecutor.so", "**/libhermes.so"]
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libhermestooling.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreactnative.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libreact_render*.so",
+      "**/librrc_root.so",
+      "**/libjscexecutor.so",
+      "**/libv8executor.so",
+      "**/libreanimated.so"
+    ]
   }
 
   externalNativeBuild {

package/android/src/main/cpp/core/AudioDecoder.cpp

@@ -20,6 +20,9 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
         "AudioDecoder",
         "Failed to initialize decoder for file: %s",
         path.c_str());
+
+    ma_decoder_uninit(&decoder);
+
     return nullptr;
   }
 
@@ -27,7 +30,7 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
   ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
 
   auto *audioBus =
-      new AudioBus(sampleRate_, static_cast<int>(totalFrameCount), 2);
+      new AudioBus(static_cast<int>(totalFrameCount), 2, sampleRate_);
   auto *buffer = new float[totalFrameCount * 2];
 
   ma_uint64 framesDecoded;
@@ -38,6 +41,12 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
         "AudioDecoder",
         "Failed to decode audio file: %s",
         path.c_str());
+
+    delete[] buffer;
+    delete audioBus;
+    ma_decoder_uninit(&decoder);
+
+    return nullptr;
   }
 
   for (int i = 0; i < decoder.outputChannels; ++i) {

package/android/src/main/cpp/core/AudioPlayer.cpp

@@ -1,8 +1,9 @@
+#include <cassert>
 
-#include "AudioPlayer.h"
 #include "AudioArray.h"
 #include "AudioBus.h"
 #include "AudioContext.h"
+#include "AudioPlayer.h"
 #include "Constants.h"
 
 namespace audioapi {
@@ -23,7 +24,7 @@ AudioPlayer::AudioPlayer(
 
   sampleRate_ = static_cast<float>(mStream_->getSampleRate());
   mBus_ = std::make_shared<AudioBus>(
-      sampleRate_, RENDER_QUANTUM_SIZE, CHANNEL_COUNT);
+      RENDER_QUANTUM_SIZE, CHANNEL_COUNT, sampleRate_);
   isInitialized_ = true;
 }
 
@@ -45,7 +46,7 @@ AudioPlayer::AudioPlayer(
 
   sampleRate_ = sampleRate;
   mBus_ = std::make_shared<AudioBus>(
-      sampleRate_, RENDER_QUANTUM_SIZE, CHANNEL_COUNT);
+      RENDER_QUANTUM_SIZE, CHANNEL_COUNT, sampleRate_);
   isInitialized_ = true;
 }
 
@@ -80,6 +81,8 @@ DataCallbackResult AudioPlayer::onAudioReady(
   auto buffer = static_cast<float *>(audioData);
   int processedFrames = 0;
 
+  assert(buffer != nullptr);
+
   while (processedFrames < numFrames) {
     int framesToProcess =
         std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);

package/common/cpp/core/AnalyserNode.cpp

@@ -21,7 +21,7 @@ AnalyserNode::AnalyserNode(audioapi::BaseAudioContext *context)
   inputBuffer_ = std::make_unique<AudioArray>(MAX_FFT_SIZE * 2);
   magnitudeBuffer_ = std::make_unique<AudioArray>(fftSize_ / 2);
   downMixBus_ = std::make_unique<AudioBus>(
-      context_->getSampleRate(), RENDER_QUANTUM_SIZE, 1);
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   fftFrame_ = std::make_unique<FFTFrame>(fftSize_);
 
@@ -145,14 +145,10 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
 void AnalyserNode::processNode(
     audioapi::AudioBus *processingBus,
     int framesToProcess) {
-  if (!isInitialized_) {
-    processingBus->zero();
-    return;
-  }
-
   // Analyser should behave like a sniffer node, it should not modify the
   // processingBus but instead copy the data to its own input buffer.
 
+  // Down mix the input bus to mono
   downMixBus_->copy(processingBus);
 
   if (vWriteIndex_ + framesToProcess > inputBuffer_->getSize()) {

package/common/cpp/core/AudioBuffer.cpp

@@ -8,7 +8,7 @@ AudioBuffer::AudioBuffer(
     int numberOfChannels,
     size_t length,
     float sampleRate) {
-  bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
+  bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
 }
 
 AudioBuffer::AudioBuffer(AudioBus *bus) {

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <cassert>
 
 #include "AudioArray.h"
 #include "AudioBufferSourceNode.h"
@@ -17,7 +18,8 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       loopEnd_(0),
       vReadIndex_(0.0) {
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-  alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
+  alignedBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
 
   detuneParam_ = std::make_shared<AudioParam>(0.0, MIN_DETUNE, MAX_DETUNE);
   playbackRateParam_ = std::make_shared<AudioParam>(
@@ -67,26 +69,33 @@ void AudioBufferSourceNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer) {
   if (!buffer) {
     buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
-    alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
+    alignedBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
     loopEnd_ = 0;
     return;
   }
 
   buffer_ = buffer;
-  alignedBus_ = std::make_shared<AudioBus>(
-      context_->getSampleRate(),
-      buffer_->getLength(),
-      buffer_->getNumberOfChannels());
+  channelCount_ = buffer_->getNumberOfChannels();
 
+  alignedBus_ = std::make_shared<AudioBus>(
+      buffer_->getLength(), channelCount_, context_->getSampleRate());
   alignedBus_->zero();
   alignedBus_->sum(buffer_->bus_.get());
 
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+
   loopEnd_ = buffer_->getDuration();
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
   AudioScheduledSourceNode::start(when);
 
+  if (duration > 0) {
+    AudioScheduledSourceNode::stop(when + duration);
+  }
+
   if (!buffer_) {
     return;
   }
@@ -98,29 +107,30 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   }
 
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
-
-  if (duration > 0) {
-    AudioScheduledSourceNode::stop(when + duration);
-  }
 }
 
 void AudioBufferSourceNode::processNode(
     AudioBus *processingBus,
     int framesToProcess) {
+  // No audio data to fill, zero the output and return.
+  if (!buffer_) {
+    processingBus->zero();
+    return;
+  }
+
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
   float playbackRate = getPlaybackRateValue(startOffset);
 
-  // No audio data to fill, zero the output and return.
-  if (!isPlaying() || !alignedBus_ || alignedBus_->getSize() == 0 ||
-      playbackRate == 0.0f) {
+  assert(alignedBus_ != nullptr);
+  assert(alignedBus_->getSize() > 0);
+
+  if (playbackRate == 0.0f || !isPlaying()) {
     processingBus->zero();
     return;
-  }
-
-  if (std::fabs(playbackRate) == 1.0) {
+  } else if (std::fabs(playbackRate) == 1.0) {
     processWithoutInterpolation(
         processingBus, startOffset, offsetLength, playbackRate);
   } else {

package/common/cpp/core/AudioBus.cpp

@@ -18,7 +18,7 @@ namespace audioapi {
  * Public interfaces - memory management
  */
 
-AudioBus::AudioBus(float sampleRate, size_t size, int numberOfChannels)
+AudioBus::AudioBus(size_t size, int numberOfChannels, float sampleRate)
     : numberOfChannels_(numberOfChannels),
       sampleRate_(sampleRate),
       size_(size) {
@@ -161,19 +161,26 @@ float AudioBus::maxAbsValue() const {
   return maxAbsValue;
 }
 
-void AudioBus::sum(const AudioBus *source) {
-  sum(source, 0, 0, getSize());
+void AudioBus::sum(
+    const AudioBus *source,
+    ChannelInterpretation interpretation) {
+  sum(source, 0, 0, getSize(), interpretation);
 }
 
-void AudioBus::sum(const AudioBus *source, size_t start, size_t length) {
-  sum(source, start, start, length);
+void AudioBus::sum(
+    const AudioBus *source,
+    size_t start,
+    size_t length,
+    ChannelInterpretation interpretation) {
+  sum(source, start, start, length, interpretation);
 }
 
 void AudioBus::sum(
     const AudioBus *source,
     size_t sourceStart,
     size_t destinationStart,
-    size_t length) {
+    size_t length,
+    ChannelInterpretation interpretation) {
   if (source == this) {
     return;
   }
@@ -181,9 +188,12 @@ void AudioBus::sum(
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 
-  // TODO: consider adding ability to enforce discrete summing (if/when it will
-  // be useful). Source channel count is smaller than current bus, we need to
-  // up-mix.
+  if (interpretation == ChannelInterpretation::DISCRETE) {
+    discreteSum(source, sourceStart, destinationStart, length);
+    return;
+  }
+
+  // Source channel count is smaller than current bus, we need to up-mix.
   if (numberOfSourceChannels < numberOfChannels) {
     sumByUpMixing(source, sourceStart, destinationStart, length);
     return;
@@ -373,8 +383,9 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // Stereo 4 to mono: output += 0.25 * (input.left + input.right +
-  // input.surroundLeft + input.surroundRight)
+  // Stereo 4 to mono (4 -> 1):
+  // output += 0.25 * (input.left + input.right + input.surroundLeft +
+  // input.surroundRight)
   if (numberOfSourceChannels == 4 && numberOfChannels == 1) {
     float *sourceLeft = source->getChannelByType(ChannelLeft)->getData();
     float *sourceRight = source->getChannelByType(ChannelRight)->getData();
@@ -408,7 +419,88 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // 5.1 to stereo:
+  // 5.1 to mono (6 -> 1):
+  // output += sqrt(1/2) * (input.left + input.right) + input.center + 0.5 *
+  // (input.surroundLeft + input.surroundRight)
+  if (numberOfSourceChannels == 6 && numberOfChannels == 1) {
+    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 *destinationData = getChannelByType(ChannelMono)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceLeft + sourceStart,
+        SQRT_HALF,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceRight + sourceStart,
+        SQRT_HALF,
+        destinationData + destinationStart,
+        length);
+    VectorMath::add(
+        sourceCenter + sourceStart,
+        destinationData + destinationStart,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundLeft + sourceStart,
+        0.5f,
+        destinationData + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundRight + sourceStart,
+        0.5f,
+        destinationData + destinationStart,
+        length);
+
+    return;
+  }
+
+  // Stereo 4 to stereo 2 (4 -> 2):
+  // output.left += 0.5 * (input.left +  input.surroundLeft)
+  // output.right += 0.5 * (input.right + input.surroundRight)
+  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 *destinationLeft = getChannelByType(ChannelLeft)->getData();
+    float *destinationRight = getChannelByType(ChannelRight)->getData();
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceLeft + sourceStart,
+        0.5f,
+        destinationLeft + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundLeft + sourceStart,
+        0.5f,
+        destinationLeft + destinationStart,
+        length);
+
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceRight + sourceStart,
+        0.5f,
+        destinationRight + destinationStart,
+        length);
+    VectorMath::multiplyByScalarThenAddToOutput(
+        sourceSurroundRight + sourceStart,
+        0.5f,
+        destinationRight + destinationStart,
+        length);
+    return;
+  }
+
+  // 5.1 to stereo (6 -> 2):
   // output.left += input.left + sqrt(1/2) * (input.center + input.surroundLeft)
   // output.right += input.right + sqrt(1/2) * (input.center +
   // input.surroundRight)
@@ -458,7 +550,7 @@ void AudioBus::sumByDownMixing(
     return;
   }
 
-  // 5.1 to stereo 4:
+  // 5.1 to stereo 4 (6 -> 4):
   // output.left += input.left + sqrt(1/2) * input.center
   // output.right += input.right + sqrt(1/2) * input.center
   // output.surroundLeft += input.surroundLeft

package/common/cpp/core/AudioBus.h

@@ -5,6 +5,8 @@
 #include <vector>
 #include <cstddef>
 
+#include "ChannelInterpretation.h"
+
 namespace audioapi {
 
 class BaseAudioContext;
@@ -22,7 +24,7 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
-  explicit AudioBus(float sampleRate, size_t size, int numberOfChannels);
+  explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
 
   ~AudioBus();
 
@@ -39,13 +41,13 @@ class AudioBus {
   void zero();
   void zero(size_t start, size_t length);
 
-  void sum(const AudioBus *source);
-  void sum(const AudioBus *source, 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,
       size_t sourceStart,
       size_t destinationStart,
-      size_t length);
+      size_t length, ChannelInterpretation interpretation = ChannelInterpretation::SPEAKERS);
 
   void copy(const AudioBus *source);
   void copy(const AudioBus *source, size_t start, size_t length);

package/common/cpp/core/AudioContext.cpp

@@ -7,6 +7,7 @@
 #include "AudioContext.h"
 #include "AudioDecoder.h"
 #include "AudioDestinationNode.h"
+#include "AudioNodeManager.h"
 
 namespace audioapi {
 AudioContext::AudioContext() : BaseAudioContext() {
@@ -35,11 +36,11 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 }
 
 AudioContext::~AudioContext() {
-  if (isClosed()) {
-    return;
+  if (!isClosed()) {
+    close();
   }
 
-  close();
+  nodeManager_->cleanup();
 }
 
 void AudioContext::close() {

package/common/cpp/core/AudioContext.h

@@ -20,14 +20,14 @@ class AudioContext : public BaseAudioContext {
 
   void close();
 
-  std::function<void(AudioBus *, int)> renderAudio();
-
  private:
 #ifdef ANDROID
-    std::shared_ptr<AudioPlayer> audioPlayer_;
+  std::shared_ptr<AudioPlayer> audioPlayer_;
 #else
-    std::shared_ptr<IOSAudioPlayer> audioPlayer_;
+  std::shared_ptr<IOSAudioPlayer> audioPlayer_;
 #endif
+
+  std::function<void(AudioBus *, int)> renderAudio();
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -3,14 +3,13 @@
 #include "AudioNode.h"
 #include "AudioNodeManager.h"
 #include "BaseAudioContext.h"
-#include "VectorMath.h"
 
 namespace audioapi {
 
 AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
     : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
-  numberOfInputs_ = INT_MAX;
+  numberOfInputs_ = 1;
   channelCountMode_ = ChannelCountMode::EXPLICIT;
   isInitialized_ = true;
 }
@@ -26,7 +25,7 @@ double AudioDestinationNode::getCurrentTime() const {
 void AudioDestinationNode::renderAudio(
     AudioBus *destinationBus,
     int numFrames) {
-  if (!numFrames || !destinationBus || !isInitialized_) {
+  if (numFrames < 0 || !destinationBus || !isInitialized_) {
     return;
   }