react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

package/common/cpp/audioapi/core/effects/ConvolverNode.cpp

@@ -1,210 +0,0 @@
-#include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/effects/ConvolverNode.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/utils/Constants.h>
-#include <audioapi/dsp/AudioUtils.h>
-#include <audioapi/dsp/FFT.h>
-#include <audioapi/utils/AudioArray.h>
-#include <iostream>
-#include <thread>
-
-namespace audioapi {
-ConvolverNode::ConvolverNode(
-    BaseAudioContext *context,
-    std::shared_ptr<AudioBuffer> buffer,
-    bool disableNormalization)
-    : AudioNode(context),
-      buffer_(nullptr),
-      internalBuffer_(nullptr),
-      signalledToStop_(false),
-      remainingSegments_(0),
-      internalBufferIndex_(0),
-      scaleFactor_(1.0f),
-      intermediateBus_(nullptr) {
-  channelCount_ = 2;
-  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
-  normalize_ = !disableNormalization;
-  gainCalibrationSampleRate_ = context->getSampleRate();
-  setBuffer(buffer);
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
-  isInitialized_ = true;
-}
-
-bool ConvolverNode::getNormalize_() const {
-  return normalize_;
-}
-
-const std::shared_ptr<AudioBuffer> &ConvolverNode::getBuffer() const {
-  return buffer_;
-}
-
-void ConvolverNode::setNormalize(bool normalize) {
-  if (normalize_ != normalize) {
-    normalize_ = normalize;
-    if (normalize_ && buffer_)
-      calculateNormalizationScale();
-  }
-  if (!normalize_) {
-    scaleFactor_ = 1.0f;
-  }
-}
-
-void ConvolverNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer) {
-  if (buffer_ != buffer && buffer != nullptr) {
-    buffer_ = buffer;
-    if (normalize_)
-      calculateNormalizationScale();
-    threadPool_ = std::make_shared<ThreadPool>(4);
-    convolvers_.clear();
-    for (int i = 0; i < buffer->getNumberOfChannels(); ++i) {
-      convolvers_.emplace_back();
-      AudioArray channelData(buffer->getLength());
-      memcpy(
-          channelData.getData(),
-          buffer->getChannelData(i),
-          buffer->getLength() * sizeof(float));
-      convolvers_.back().init(
-          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
-    }
-    if (buffer->getNumberOfChannels() == 1) {
-      // add one more convolver, because right now input is always stereo
-      convolvers_.emplace_back();
-      AudioArray channelData(buffer->getLength());
-      memcpy(
-          channelData.getData(),
-          buffer->getChannelData(0),
-          buffer->getLength() * sizeof(float));
-      convolvers_.back().init(
-          RENDER_QUANTUM_SIZE, channelData, buffer->getLength());
-    }
-    internalBuffer_ = std::make_shared<AudioBus>(
-        RENDER_QUANTUM_SIZE * 2, channelCount_, buffer->getSampleRate());
-    intermediateBus_ = std::make_shared<AudioBus>(
-        RENDER_QUANTUM_SIZE, convolvers_.size(), buffer->getSampleRate());
-    internalBufferIndex_ = 0;
-  }
-}
-
-void ConvolverNode::onInputDisabled() {
-  numberOfEnabledInputNodes_ -= 1;
-  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
-    signalledToStop_ = true;
-    remainingSegments_ = convolvers_.at(0).getSegCount();
-  }
-}
-
-std::shared_ptr<AudioBus> ConvolverNode::processInputs(
-    const std::shared_ptr<AudioBus> &outputBus,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (internalBufferIndex_ < framesToProcess) {
-    return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
-  }
-  return AudioNode::processInputs(outputBus, 0, false);
-}
-
-// processing pipeline: processingBus -> intermediateBus_ -> audioBus_ (mixing
-// with intermediateBus_)
-std::shared_ptr<AudioBus> ConvolverNode::processNode(
-    const std::shared_ptr<AudioBus> &processingBus,
-    int framesToProcess) {
-  if (signalledToStop_) {
-    if (remainingSegments_ > 0) {
-      remainingSegments_--;
-    } else {
-      disable();
-      signalledToStop_ = false;
-      internalBufferIndex_ = 0;
-      return processingBus;
-    }
-  }
-  if (internalBufferIndex_ < framesToProcess) {
-    performConvolution(processingBus); // result returned to intermediateBus_
-    audioBus_->sum(intermediateBus_.get());
-
-    internalBuffer_->copy(
-        audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
-    internalBufferIndex_ += RENDER_QUANTUM_SIZE;
-  }
-  audioBus_->zero();
-  audioBus_->copy(internalBuffer_.get(), 0, 0, framesToProcess);
-  int remainingFrames = internalBufferIndex_ - framesToProcess;
-  if (remainingFrames > 0) {
-    for (int i = 0; i < internalBuffer_->getNumberOfChannels(); ++i) {
-      memmove(
-          internalBuffer_->getChannel(i)->getData(),
-          internalBuffer_->getChannel(i)->getData() + framesToProcess,
-          remainingFrames * sizeof(float));
-    }
-  }
-  internalBufferIndex_ -= framesToProcess;
-
-  for (int i = 0; i < audioBus_->getNumberOfChannels(); ++i) {
-    dsp::multiplyByScalar(
-        audioBus_->getChannel(i)->getData(),
-        scaleFactor_,
-        audioBus_->getChannel(i)->getData(),
-        framesToProcess);
-  }
-
-  return audioBus_;
-}
-
-void ConvolverNode::calculateNormalizationScale() {
-  int numberOfChannels = buffer_->getNumberOfChannels();
-  int length = buffer_->getLength();
-
-  float power = 0;
-
-  for (int channel = 0; channel < numberOfChannels; ++channel) {
-    float channelPower = 0;
-    auto channelData = buffer_->getChannelData(channel);
-    for (int i = 0; i < length; ++i) {
-      float sample = channelData[i];
-      channelPower += sample * sample;
-    }
-    power += channelPower;
-  }
-
-  power = std::sqrt(power / (numberOfChannels * length));
-  if (power < MIN_IR_POWER) {
-    power = MIN_IR_POWER;
-  }
-  scaleFactor_ = 1 / power;
-  scaleFactor_ *= std::pow(10, GAIN_CALIBRATION * 0.05f);
-  scaleFactor_ *= gainCalibrationSampleRate_ / buffer_->getSampleRate();
-}
-
-void ConvolverNode::performConvolution(
-    const std::shared_ptr<AudioBus> &processingBus) {
-  if (processingBus->getNumberOfChannels() == 1) {
-    for (int i = 0; i < convolvers_.size(); ++i) {
-      threadPool_->schedule([&, i] {
-        convolvers_[i].process(
-            processingBus->getChannel(0)->getData(),
-            intermediateBus_->getChannel(i)->getData());
-      });
-    }
-  } else if (processingBus->getNumberOfChannels() == 2) {
-    std::vector<int> inputChannelMap;
-    std::vector<int> outputChannelMap;
-    if (convolvers_.size() == 2) {
-      inputChannelMap = {0, 1};
-      outputChannelMap = {0, 1};
-    } else { // 4 channel IR
-      inputChannelMap = {0, 0, 1, 1};
-      outputChannelMap = {0, 3, 2, 1};
-    }
-    for (int i = 0; i < convolvers_.size(); ++i) {
-      threadPool_->schedule(
-          [this, i, inputChannelMap, outputChannelMap, &processingBus] {
-            convolvers_[i].process(
-                processingBus->getChannel(inputChannelMap[i])->getData(),
-                intermediateBus_->getChannel(outputChannelMap[i])->getData());
-          });
-    }
-  }
-  threadPool_->wait();
-}
-} // namespace audioapi

package/common/cpp/audioapi/core/effects/ConvolverNode.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <audioapi/core/AudioNode.h>
-#include <audioapi/core/AudioParam.h>
-#include <audioapi/dsp/Convolver.h>
-
-#include <memory>
-#include <vector>
-
-#include <audioapi/utils/ThreadPool.hpp>
-
-static constexpr int GAIN_CALIBRATION = -58; // magic number so that processed signal and dry signal have roughly the same volume
-static constexpr double MIN_IR_POWER = 0.000125;
-
-namespace audioapi {
-
-class AudioBus;
-class AudioBuffer;
-
-class ConvolverNode : public AudioNode {
- public:
-    explicit ConvolverNode(BaseAudioContext *context, std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
-
-    [[nodiscard]] bool getNormalize_() const;
-    [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;
-    void setNormalize(bool normalize);
-    void setBuffer(const std::shared_ptr<AudioBuffer> &buffer);
-
- protected:
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
-
- private:
-  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
-  void onInputDisabled() override;
-  float gainCalibrationSampleRate_;
-  size_t remainingSegments_;
-  size_t internalBufferIndex_;
-  bool normalize_;
-  bool signalledToStop_;
-  float scaleFactor_;
-  std::shared_ptr<AudioBus>intermediateBus_;
-
-  // impulse response buffer
-  std::shared_ptr<AudioBuffer> buffer_;
-  // buffer to hold internal processed data
-  std::shared_ptr<AudioBus> internalBuffer_;
-  // vectors of convolvers, one per channel
-  std::vector<Convolver> convolvers_;
-  std::shared_ptr<ThreadPool> threadPool_;
-
-  void calculateNormalizationScale();
-  void performConvolution(const std::shared_ptr<AudioBus>& processingBus);
-};
-
-} // namespace audioapi

package/common/cpp/audioapi/dsp/Convolver.cpp

@@ -1,213 +0,0 @@
-// implementation of linear convolution algorithm described in this paper:
-// https://publications.rwth-aachen.de/record/466561/files/466561.pdf page 110
-
-#if defined(__ARM_NEON)
-#include <arm_neon.h>
-#endif
-
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/dsp/Convolver.h>
-#include <audioapi/dsp/VectorMath.h>
-#include <audioapi/utils/AudioArray.h>
-#include <chrono>
-#include <iostream>
-
-namespace audioapi {
-
-Convolver::Convolver()
-    : _blockSize(0),
-      _segSize(0),
-      _segCount(0),
-      _fftComplexSize(0),
-      _segments(),
-      _segmentsIR(),
-      _fftBuffer(0),
-      _fft(nullptr),
-      _preMultiplied(),
-      _current(0),
-      _inputBuffer(0) {}
-
-void Convolver::reset() {
-  _blockSize = 0;
-  _segSize = 0;
-  _segCount = 0;
-  _fftComplexSize = 0;
-  _current = 0;
-  _fft = nullptr;
-  _segments.clear();
-  _segmentsIR.clear();
-  _preMultiplied.clear();
-  _fftBuffer.zero();
-  _inputBuffer.zero();
-}
-
-bool Convolver::init(
-    size_t blockSize,
-    const audioapi::AudioArray &ir,
-    size_t irLen) {
-  reset();
-  // blockSize must be a power of two
-  if ((blockSize & (blockSize - 1))) {
-    return false;
-  }
-
-  // Ignore zeros at the end of the impulse response because they only waste
-  // computation time
-  _blockSize = blockSize;
-  _trueSegmentCount = (size_t)(std::ceil((float)irLen / (float)_blockSize));
-  while (irLen > 0 && ::fabs(ir[irLen - 1]) < 10e-3) {
-    --irLen;
-  }
-
-  if (irLen == 0) {
-    return true;
-  }
-
-  // The length-N is split into P = N/B length-B sub filters
-  _segCount = (size_t)(std::ceil((float)irLen / (float)_blockSize));
-  _segSize = 2 * _blockSize;
-  // size of the FFT is 2B, so the complex size is B+1, due to the
-  // complex-conjugate symmetricity
-  _fftComplexSize = _segSize / 2 + 1;
-  _fft = std::make_shared<dsp::FFT>((int)_segSize);
-  _fftBuffer.resize(_segSize);
-
-  // segments preparation
-  for (int i = 0; i < _segCount; ++i) {
-    aligned_vec_complex vec(_fftComplexSize, std::complex<float>(0.0f, 0.0f));
-    _segments.push_back(vec);
-  }
-
-  // ir preparation
-  for (int i = 0; i < _segCount; ++i) {
-    aligned_vec_complex segment(_fftComplexSize);
-    const size_t remainingSamples = irLen - (i * _blockSize);
-    const size_t samplesToCopy = std::min(_blockSize, remainingSamples);
-
-    if (samplesToCopy > 0) {
-      memcpy(
-          _fftBuffer.getData(),
-          ir.getData() + i * _blockSize,
-          samplesToCopy * sizeof(float));
-    }
-    // Each sub filter is zero-padded to length 2B and transformed using a
-    // 2B-point real-to-complex FFT.
-    memset(_fftBuffer.getData() + _blockSize, 0, _blockSize * sizeof(float));
-    _fft->doFFT(_fftBuffer.getData(), segment);
-    segment.at(0).imag(0.0f); // ensure DC component is real
-    _segmentsIR.push_back(segment);
-  }
-
-  _preMultiplied = aligned_vec_complex(_fftComplexSize);
-  _inputBuffer.resize(_segSize);
-  _current = 0;
-
-  return true;
-}
-
-/// @brief Fast pairwise complex multiplication using ARM NEON intrinsics
-/// @param ir Impulse response
-/// @param audio Input audio signal
-/// @param pre Output buffer for pre-multiplied results
-/// @note IMPORTANT: ir, audio, and pre must be the same size and should be
-/// aligned to 16 bytes for optimal performance
-void pairwise_complex_multiply_fast(
-    const Convolver::aligned_vec_complex &ir,
-    const Convolver::aligned_vec_complex &audio,
-    Convolver::aligned_vec_complex &pre) {
-  size_t n = ir.size();
-
-/// @note Using ARM NEON intrinsics for SIMD optimization
-/// This implementation is on average 2x faster than the scalar version on ARM
-/// architectures With 16-byte alignment it can be even faster up to 2.5x
-#ifdef __ARM_NEON
-  size_t j = 0;
-
-  // Main vector loop: process 4 complex samples (8 floats) per iteration using
-  // vld2q/vst2q deinterleave
-  for (; j <= n - 4; j += 4) {
-    // load de-interleaved real/imag for 4 complex values
-    float32x4x2_t ir_de = vld2q_f32(reinterpret_cast<const float *>(&ir[j]));
-    float32x4x2_t a_de = vld2q_f32(reinterpret_cast<const float *>(&audio[j]));
-    float32x4x2_t pre_de = vld2q_f32(reinterpret_cast<float *>(&pre[j]));
-
-    float32x4_t ir_re = ir_de.val[0];
-    float32x4_t ir_im = ir_de.val[1];
-    float32x4_t a_re = a_de.val[0];
-    float32x4_t a_im = a_de.val[1];
-
-    // real = ir_re * a_re - ir_im * a_im
-    float32x4_t real = vmulq_f32(ir_re, a_re);
-    real = vmlsq_f32(real, ir_im, a_im);
-    // imag = ir_re * a_im + ir_im * a_re
-    float32x4_t imag = vmulq_f32(ir_re, a_im);
-    imag = vmlaq_f32(imag, ir_im, a_re);
-
-    // accumulate into pre
-    float32x4_t new_re = vaddq_f32(pre_de.val[0], real);
-    float32x4_t new_im = vaddq_f32(pre_de.val[1], imag);
-
-    float32x4x2_t out_de;
-    out_de.val[0] = new_re;
-    out_de.val[1] = new_im;
-
-    vst2q_f32(reinterpret_cast<float *>(&pre[j]), out_de);
-  }
-
-  // Tail
-  for (; j < n; ++j) {
-    pre[j] += ir[j] * audio[j];
-  }
-
-#else
-  // Fallback scalar implementation
-  for (size_t i = 0; i < n; ++i) {
-    pre[i] += ir[i] * audio[i];
-  }
-#endif
-}
-
-void Convolver::process(float *data, float *outputData) {
-  // The input buffer acts as a 2B-point sliding window of the input signal.
-  // With each new input block, the right half of the input buffer is shifted
-  // to the left and the new block is stored in the right half.
-  memmove(
-      _inputBuffer.getData(),
-      _inputBuffer.getData() + _blockSize,
-      _blockSize * sizeof(float));
-  memcpy(_inputBuffer.getData() + _blockSize, data, _blockSize * sizeof(float));
-
-  // All contents (DFT spectra) in the FDL are shifted up by one slot.
-  _current = (_current > 0) ? _current - 1 : _segCount - 1;
-  // A 2B-point real-to-complex FFT is computed from the input buffer,
-  // resulting in B+1 complex-conjugate symmetric DFT coefficients. The
-  // result is stored in the first FDL slot.
-  // _current marks first FDL slot, which is the current input block.
-  _fft->doFFT(_inputBuffer.getData(), _segments[_current]);
-  _segments[_current][0].imag(0.0f); // ensure DC component is real
-
-  // The P sub filter spectra are pairwisely multiplied with the input spectra
-  // in the FDL. The results are accumulated in the frequency-domain.
-  memset(
-      _preMultiplied.data(),
-      0,
-      _preMultiplied.size() * sizeof(std::complex<float>));
-  // this is a bottleneck of the algorithm
-  for (int i = 0; i < _segCount; ++i) {
-    const int indexAudio = (_current + i) % _segCount;
-    const auto &impulseResponseSegment = _segmentsIR[i];
-    const auto &audioSegment = _segments[indexAudio];
-    pairwise_complex_multiply_fast(
-        impulseResponseSegment, audioSegment, _preMultiplied);
-  }
-  // Of the accumulated spectral convolutions, an 2B-point complex-to-real
-  // IFFT is computed. From the resulting 2B samples, the left half is
-  // discarded and the right half is returned as the next output block.
-  _fft->doInverseFFT(_preMultiplied, _fftBuffer.getData());
-
-  memcpy(
-      outputData,
-      _fftBuffer.getData() + _blockSize,
-      _blockSize * sizeof(float));
-}
-} // namespace audioapi

package/common/cpp/audioapi/dsp/Convolver.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/dsp/FFT.h>
-#include <vector>
-#include <cstring>
-#include <complex>
-#include <memory>
-#include <audioapi/utils/AlignedAllocator.hpp>
-
-namespace audioapi {
-
-class AudioBuffer;
-
-class Convolver {
-  using aligned_vec_complex =
-      std::vector<std::complex<float>, AlignedAllocator<std::complex<float>, 16>>;
-
- public:
-    Convolver();
-    bool init(size_t blockSize, const AudioArray &ir, size_t irLen);
-    void process(float* inputData, float* outputData);
-    void reset();
-    inline size_t getSegCount() const { return _trueSegmentCount; }
-
- private:
-    size_t _trueSegmentCount;
-    size_t _blockSize;
-    size_t _segSize;
-    size_t _segCount;
-    size_t _fftComplexSize;
-    std::vector<aligned_vec_complex> _segments;
-    std::vector<aligned_vec_complex> _segmentsIR;
-    AudioArray _fftBuffer;
-    std::shared_ptr<dsp::FFT> _fft;
-    aligned_vec_complex _preMultiplied;
-    size_t _current;
-    AudioArray _inputBuffer;
-
-  friend void pairwise_complex_multiply_fast(
-      const aligned_vec_complex& ir,
-      const aligned_vec_complex& audio,
-      aligned_vec_complex& pre);
-};
-} // namespace audioapi

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

@@ -1,24 +0,0 @@
-## 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

@@ -1,50 +0,0 @@
-#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;
-  }
-};