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

package/common/cpp/core/AudioNode.cpp

@@ -1,3 +1,4 @@
+#include <cassert>
 #include <memory>
 
 #include "AudioBus.h"
@@ -9,11 +10,11 @@ namespace audioapi {
 
 AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
   audioBus_ = std::make_shared<AudioBus>(
-      context->getSampleRate(), RENDER_QUANTUM_SIZE, channelCount_);
+      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }
 
 AudioNode::~AudioNode() {
-  cleanup();
+  isInitialized_ = false;
 }
 
 int AudioNode::getNumberOfInputs() const {
@@ -101,87 +102,91 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
     return outputBus;
   }
 
+  if (isAlreadyProcessed()) {
+    return audioBus_.get();
+  }
+
+  // Process inputs and return the bus with the most channels.
+  AudioBus *processingBus = processInputs(outputBus, framesToProcess);
+
+  // Apply channel count mode.
+  processingBus = applyChannelCountMode(processingBus);
+
+  // Mix all input buses into the processing bus.
+  mixInputsBuses(processingBus);
+
+  assert(processingBus != nullptr);
+  // Finally, process the node itself.
+  processNode(processingBus, framesToProcess);
+
+  return processingBus;
+}
+
+bool AudioNode::isAlreadyProcessed() {
+  assert(context_ != nullptr);
+
   std::size_t currentSampleFrame = context_->getCurrentSampleFrame();
 
   // check if the node has already been processed for this rendering quantum
-  bool isAlreadyProcessed = currentSampleFrame == lastRenderedFrame_;
-
-  // Node can't use output bus if:
-  // - outputBus is not provided, which means that next node is doing a
-  // multi-node summing.
-  // - it has more than one input, which means that it has to sum all inputs
-  // using internal bus.
-  // - it has more than one output, so each output node can get the processed
-  // data without re-calculating the node.
-  bool canUseOutputBus =
-      outputBus != nullptr && inputNodes_.size() < 2 && outputNodes_.size() < 2;
-
-  if (isAlreadyProcessed) {
-    // If it was already processed in the rendering quantum, return it.
-    return audioBus_.get();
+  if (currentSampleFrame == lastRenderedFrame_) {
+    return true;
   }
 
   // Update the last rendered frame before processing node and its inputs.
   lastRenderedFrame_ = currentSampleFrame;
 
-  AudioBus *processingBus = canUseOutputBus ? outputBus : audioBus_.get();
+  return false;
+}
 
-  if (!canUseOutputBus) {
-    // Clear the bus before summing all connected nodes.
-    processingBus->zero();
-  }
+AudioBus *AudioNode::processInputs(AudioBus *outputBus, int framesToProcess) {
+  AudioBus *processingBus = audioBus_.get();
+  processingBus->zero();
 
-  if (inputNodes_.empty()) {
-    // If there are no connected inputs, if processing node is the source node,
-    // it will fill processing bus with the audio data, otherwise it will return
-    // silence.
-    processNode(processingBus, framesToProcess);
-    return processingBus;
-  }
+  int maxNumberOfChannels = 0;
+  for (auto inputNode : inputNodes_) {
+    assert(inputNode != nullptr);
 
-  for (auto it = inputNodes_.begin(); it != inputNodes_.end(); ++it) {
-    if (!(*it)->isEnabled()) {
+    if (!inputNode->isEnabled()) {
       continue;
     }
 
-    // Process first connected node, it can be directly connected to the
-    // processingBus, resulting in one less summing operation.
-    if (it == inputNodes_.begin()) {
-      AudioBus *inputBus = (*it)->processAudio(processingBus, framesToProcess);
-
-      if (inputBus != processingBus) {
-        // add assert
-        processingBus->sum(inputBus);
-      }
-    } else {
-      // Enforce the summing to be done using the internal bus.
-      AudioBus *inputBus = (*it)->processAudio(nullptr, framesToProcess);
-      if (inputBus) {
-        // add assert
-        processingBus->sum(inputBus);
-      }
+    auto inputBus = inputNode->processAudio(outputBus, framesToProcess);
+    inputBuses_.push_back(inputBus);
+
+    if (maxNumberOfChannels < inputBus->getNumberOfChannels()) {
+      maxNumberOfChannels = inputBus->getNumberOfChannels();
+      processingBus = inputBus;
     }
   }
 
-  // Finally, process the node itself.
-  processNode(processingBus, framesToProcess);
-
   return processingBus;
 }
 
-void AudioNode::cleanup() {
-  isInitialized_ = false;
+AudioBus *AudioNode::applyChannelCountMode(AudioBus *processingBus) {
+  // If the channelCountMode is EXPLICIT, the node should output the number of
+  // channels specified by the channelCount.
+  if (channelCountMode_ == ChannelCountMode::EXPLICIT) {
+    return audioBus_.get();
+  }
 
-  for (const auto &outputNode : outputNodes_) {
-    outputNode->onInputDisconnected(this);
+  // If the channelCountMode is CLAMPED_MAX, the node should output the maximum
+  // number of channels clamped to channelCount.
+  if (channelCountMode_ == ChannelCountMode::CLAMPED_MAX &&
+      processingBus->getNumberOfChannels() >= channelCount_) {
+    return audioBus_.get();
   }
 
-  for (const auto &inputNode : inputNodes_) {
-    inputNode->disconnectNode(shared_from_this());
+  return processingBus;
+}
+
+void AudioNode::mixInputsBuses(AudioBus *processingBus) {
+  assert(processingBus != nullptr);
+
+  for (auto inputBus : inputBuses_) {
+    processingBus->sum(inputBus, channelInterpretation_);
   }
 
-  outputNodes_.clear();
-  inputNodes_.clear();
+  inputBuses_.clear();
 }
 
 void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
@@ -234,4 +239,19 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
   }
 }
 
+void AudioNode::cleanup() {
+  isInitialized_ = false;
+
+  for (const auto &outputNode : outputNodes_) {
+    outputNode->onInputDisconnected(this);
+  }
+
+  for (const auto &inputNode : inputNodes_) {
+    inputNode->disconnectNode(shared_from_this());
+  }
+
+  outputNodes_.clear();
+  inputNodes_.clear();
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioNode.h

@@ -4,6 +4,7 @@
 #include <string>
 #include <unordered_set>
 #include <cstddef>
+#include <vector>
 
 #include "ChannelCountMode.h"
 #include "ChannelInterpretation.h"
@@ -56,13 +57,19 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
  private:
+  std::vector<AudioBus*> inputBuses_;
+
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
 
-  void cleanup();
   AudioBus *processAudio(AudioBus *outputBus, int framesToProcess);
   virtual void processNode(AudioBus *processingBus, int framesToProcess) = 0;
 
+  bool isAlreadyProcessed();
+  AudioBus *processInputs(AudioBus *outputBus, int framesToProcess);
+  AudioBus *applyChannelCountMode(AudioBus *processingBus);
+  void mixInputsBuses(AudioBus *processingBus);
+
   void connectNode(const std::shared_ptr<AudioNode> &node);
   void disconnectNode(const std::shared_ptr<AudioNode> &node);
 
@@ -70,6 +77,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   void onInputDisabled();
   void onInputConnected(AudioNode *node);
   void onInputDisconnected(AudioNode *node);
+
+  void cleanup();
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioNodeManager.cpp

@@ -43,7 +43,9 @@ void AudioNodeManager::settlePendingConnections() {
     std::shared_ptr<AudioNode> to = std::get<1>(connection);
     ConnectionType type = std::get<2>(connection);
 
-    // add assert to check if from and to are neither null nor uninitialized
+    if (!to || !from) {
+      continue;
+    }
 
     if (type == ConnectionType::CONNECT) {
       from->connectNode(to);
@@ -66,4 +68,14 @@ void AudioNodeManager::prepareNodesForDestruction() {
   }
 }
 
+void AudioNodeManager::cleanup() {
+  Locker lock(getGraphLock());
+
+  for (auto &node : nodes_) {
+    node->cleanup();
+  }
+
+  nodes_.clear();
+}
+
 } // namespace audioapi

package/common/cpp/core/AudioNodeManager.h

@@ -27,6 +27,8 @@ class AudioNodeManager {
 
   void addNode(const std::shared_ptr<AudioNode> &node);
 
+  void cleanup();
+
  private:
   std::mutex graphLock_;
 

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -1,7 +1,9 @@
-#include "AudioScheduledSourceNode.h"
+#include <cassert>
+
 #include "AudioArray.h"
 #include "AudioBus.h"
 #include "AudioNodeManager.h"
+#include "AudioScheduledSourceNode.h"
 #include "AudioUtils.h"
 #include "BaseAudioContext.h"
 
@@ -51,6 +53,8 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     return;
   }
 
+  assert(context_ != nullptr);
+
   auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,4 +1,4 @@
-#include "BaseAudioContext.h"
+#include <cassert>
 
 #include "AnalyserNode.h"
 #include "AudioArray.h"
@@ -8,6 +8,7 @@
 #include "AudioDecoder.h"
 #include "AudioDestinationNode.h"
 #include "AudioNodeManager.h"
+#include "BaseAudioContext.h"
 #include "BiquadFilterNode.h"
 #include "ContextState.h"
 #include "GainNode.h"
@@ -30,10 +31,12 @@ float BaseAudioContext::getSampleRate() const {
 }
 
 std::size_t BaseAudioContext::getCurrentSampleFrame() const {
+  assert(destination_ != nullptr);
   return destination_->getCurrentSampleFrame();
 }
 
 double BaseAudioContext::getCurrentTime() const {
+  assert(destination_ != nullptr);
   return destination_->getCurrentTime();
 }
 

package/common/cpp/core/BaseAudioContext.h

@@ -49,20 +49,22 @@ class BaseAudioContext {
       bool disableNormalization,
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
+
   std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
+  [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
+
   [[nodiscard]] bool isRunning() const;
   [[nodiscard]] bool isClosed() const;
-  [[nodiscard]] float getNyquistFrequency() const;
 
  protected:
   static std::string toString(ContextState state);
+
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
   std::shared_ptr<AudioDecoder> audioDecoder_ {};
-
   // init in AudioContext or OfflineContext constructor
   float sampleRate_ {};
   ContextState state_ = ContextState::RUNNING;

package/common/cpp/core/PeriodicWave.cpp

@@ -199,8 +199,8 @@ void PeriodicWave::createBandLimitedTables(
   for (int rangeIndex = 0; rangeIndex < numberOfRanges_; rangeIndex++) {
     FFTFrame fftFrame(fftSize);
 
-    auto *realFFTFrameData = fftFrame.getRealData();
-    auto *imaginaryFFTFrameData = fftFrame.getImaginaryData();
+    auto *realFFTFrameData = new float[fftSize];
+    auto *imaginaryFFTFrameData = new float[fftSize];
 
     // copy real and imaginary data to the FFT frame and scale it
     VectorMath::multiplyByScalar(
@@ -235,7 +235,10 @@ void PeriodicWave::createBandLimitedTables(
 
     // Perform the inverse FFT to get the time domain representation of the
     // band-limited waveform.
-    fftFrame.doInverseFFT(bandLimitedTables_[rangeIndex]);
+    fftFrame.doInverseFFT(
+        bandLimitedTables_[rangeIndex],
+        realFFTFrameData,
+        imaginaryFFTFrameData);
 
     if (!disableNormalization_ && rangeIndex == 0) {
       float maxValue =
@@ -245,6 +248,9 @@ void PeriodicWave::createBandLimitedTables(
       }
     }
 
+    delete[] realFFTFrameData;
+    delete[] imaginaryFFTFrameData;
+
     VectorMath::multiplyByScalar(
         bandLimitedTables_[rangeIndex],
         normalizationFactor,

package/common/cpp/core/StereoPannerNode.cpp

@@ -1,8 +1,10 @@
-#include "StereoPannerNode.h"
+#include <cassert>
+
 #include "AudioArray.h"
 #include "AudioBus.h"
 #include "BaseAudioContext.h"
 #include "Constants.h"
+#include "StereoPannerNode.h"
 
 // https://webaudio.github.io/web-audio-api/#stereopanner-algorithm
 
@@ -10,7 +12,7 @@ namespace audioapi {
 
 StereoPannerNode::StereoPannerNode(BaseAudioContext *context)
     : AudioNode(context) {
-  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
   panParam_ = std::make_shared<AudioParam>(0.0, MIN_PAN, MAX_PAN);
   isInitialized_ = true;
 }
@@ -22,12 +24,6 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
 void StereoPannerNode::processNode(
     AudioBus *processingBus,
     int framesToProcess) {
-  // TODO: Currently assumed channelCount is 2
-  // it should:
-  //  - support mono-channel buses
-  //  - throw errors when trying to setup stereo panner with more than 2
-  //  channels
-
   double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
 
@@ -35,11 +31,12 @@ void StereoPannerNode::processNode(
   AudioArray *right = processingBus->getChannelByType(AudioBus::ChannelRight);
 
   for (int i = 0; i < framesToProcess; i += 1) {
-    float pan = panParam_->getValueAtTime(time);
-    float x = (pan <= 0 ? pan + 1 : pan) * PI / 2;
+    auto pan = panParam_->getValueAtTime(time);
+
+    auto x = (pan <= 0 ? pan + 1 : pan);
 
-    auto gainL = static_cast<float>(cos(x));
-    auto gainR = static_cast<float>(sin(x));
+    auto gainL = static_cast<float>(cos(x * PI / 2));
+    auto gainR = static_cast<float>(sin(x * PI / 2));
 
     float inputL = (*left)[i];
     float inputR = (*right)[i];

package/common/cpp/utils/FFTFrame.cpp

@@ -5,7 +5,8 @@
 #endif
 
 #if defined(ANDROID)
-#include <fftw3.h>
+#include <pffft.h>
+#include <complex>
 #endif
 
 namespace audioapi {
@@ -13,19 +14,11 @@ namespace audioapi {
 static std::unordered_map<size_t, FFTSetup> fftSetups_;
 
 FFTFrame::FFTFrame(int size)
-    : size_(size),
-      log2Size_(static_cast<int>(log2(size))),
-      realData_(new float[size]),
-      imaginaryData_(new float[size]) {
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
   fftSetup_ = getFFTSetupForSize(log2Size_);
-  frame_.realp = realData_;
-  frame_.imagp = imaginaryData_;
 }
 
-FFTFrame::~FFTFrame() {
-  delete[] realData_;
-  delete[] imaginaryData_;
-}
+FFTFrame::~FFTFrame() {}
 
 FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
   if (!fftSetups_.contains(log2FFTSize)) {
@@ -36,15 +29,22 @@ FFTSetup FFTFrame::getFFTSetupForSize(size_t log2FFTSize) {
   return fftSetups_.at(log2FFTSize);
 }
 
-void FFTFrame::doFFT(float *data) {
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
   vDSP_ctoz(reinterpret_cast<DSPComplex *>(data), 2, &frame_, 1, size_ / 2);
   vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_FORWARD);
 
-  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
-  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
 }
 
-void FFTFrame::doInverseFFT(float *data) {
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  frame_.realp = realData;
+  frame_.imagp = imaginaryData;
   vDSP_fft_zrip(fftSetup_, &frame_, 1, log2Size_, FFT_INVERSE);
   vDSP_ztoc(&frame_, 1, reinterpret_cast<DSPComplex *>(data), 2, size_ / 2);
 
@@ -57,42 +57,49 @@ void FFTFrame::doInverseFFT(float *data) {
 #elif defined(ANDROID)
 
 FFTFrame::FFTFrame(int size)
-    : size_(size),
-      log2Size_(static_cast<int>(log2(size))),
-      realData_(new float[size]),
-      imaginaryData_(new float[size]) {
-  frame_ = fftwf_alloc_complex(size / 2);
+    : size_(size), log2Size_(static_cast<int>(log2(size))) {
+  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
+  work_ = (float *)pffft_aligned_malloc(size_ * sizeof(float));
 }
 
 FFTFrame::~FFTFrame() {
-  delete[] realData_;
-  delete[] imaginaryData_;
-  fftwf_free(frame_);
+  pffft_destroy_setup(pffftSetup_);
+  pffft_aligned_free(work_);
 }
 
-void FFTFrame::doFFT(float *data) {
-  auto plan = fftwf_plan_dft_r2c_1d(size_, data, frame_, FFTW_ESTIMATE);
-  fftwf_execute(plan);
-  fftwf_destroy_plan(plan);
+void FFTFrame::doFFT(float *data, float *realData, float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_);
+  pffft_transform_ordered(
+      pffftSetup_,
+      data,
+      reinterpret_cast<float *>(&out[0]),
+      work_,
+      PFFFT_FORWARD);
 
   for (int i = 0; i < size_ / 2; ++i) {
-    realData_[i] = frame_[i][0];
-    imaginaryData_[i] = frame_[i][1];
+    realData[i] = out[i].real();
+    imaginaryData[i] = out[i].imag();
   }
 
-  VectorMath::multiplyByScalar(realData_, 0.5f, realData_, size_ / 2);
-  VectorMath::multiplyByScalar(imaginaryData_, 0.5f, imaginaryData_, size_ / 2);
+  VectorMath::multiplyByScalar(realData, 0.5f, realData, size_ / 2);
+  VectorMath::multiplyByScalar(imaginaryData, 0.5f, imaginaryData, size_ / 2);
 }
 
-void FFTFrame::doInverseFFT(float *data) {
+void FFTFrame::doInverseFFT(
+    float *data,
+    float *realData,
+    float *imaginaryData) {
+  std::vector<std::complex<float>> out(size_ / 2);
   for (int i = 0; i < size_ / 2; i++) {
-    frame_[i][0] = realData_[i];
-    frame_[i][1] = imaginaryData_[i];
+    out[i] = {realData[i], imaginaryData[i]};
   }
 
-  auto plan = fftwf_plan_dft_c2r_1d(size_, frame_, data, FFTW_ESTIMATE);
-  fftwf_execute(plan);
-  fftwf_destroy_plan(plan);
+  pffft_transform_ordered(
+      pffftSetup_,
+      reinterpret_cast<float *>(&out[0]),
+      data,
+      work_,
+      PFFFT_BACKWARD);
 
   VectorMath::multiplyByScalar(
       data, 1.0f / static_cast<float>(size_), data, size_);

package/common/cpp/utils/FFTFrame.h

@@ -40,7 +40,7 @@
 #endif
 
 #if defined(ANDROID)
-#include <fftw3.h>
+#include <pffft.h>
 #endif
 
 namespace audioapi {
@@ -50,22 +50,12 @@ class FFTFrame {
   explicit FFTFrame(int size);
   ~FFTFrame();
 
-  [[nodiscard]] float *getRealData() const {
-    return realData_;
-  }
-  [[nodiscard]] float *getImaginaryData() const {
-    return imaginaryData_;
-  }
-
-  void doFFT(float *data);
-
-  void doInverseFFT(float *data);
+  void doFFT(float *data, float *realData, float *imaginaryData);
+  void doInverseFFT(float *data, float *realData, float *imaginaryData);
 
  private:
   int size_;
   int log2Size_;
-  float *realData_;
-  float *imaginaryData_;
 
 #if defined(HAVE_ACCELERATE)
     FFTSetup fftSetup_;
@@ -75,7 +65,8 @@ class FFTFrame {
 #endif
 
 #if defined(ANDROID)
-    fftwf_complex *frame_;
+    PFFFT_Setup *pffftSetup_;
+    float *work_;
 #endif
 };
 

package/ios/core/AudioDecoder.mm

@@ -14,19 +14,28 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const
   ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
   if (result != MA_SUCCESS) {
     NSLog(@"Failed to initialize decoder for file: %s", path.c_str());
+
+    ma_decoder_uninit(&decoder);
+
     return nullptr;
   }
 
   ma_uint64 totalFrameCount;
   ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
 
-  auto *audioBus = new AudioBus(sampleRate_, static_cast<int>(totalFrameCount), 2);
+  auto *audioBus = new AudioBus(static_cast<int>(totalFrameCount), 2, sampleRate_);
   auto *buffer = new float[totalFrameCount * 2];
 
   ma_uint64 framesDecoded;
   ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
   if (framesDecoded == 0) {
     NSLog(@"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) {