react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-94b7f30-20251224

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -16,19 +16,21 @@
 
 namespace audioapi {
 
-AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
+AudioScheduledSourceNode::AudioScheduledSourceNode(std::shared_ptr<BaseAudioContext> context)
     : AudioNode(context),
       startTime_(-1.0),
       stopTime_(-1.0),
-      playbackState_(PlaybackState::UNSCHEDULED) {
+      playbackState_(PlaybackState::UNSCHEDULED),
+      audioEventHandlerRegistry_(context->audioEventHandlerRegistry_) {
   numberOfInputs_ = 0;
-  audioEventHandlerRegistry_ = context_->audioEventHandlerRegistry_;
 }
 
 void AudioScheduledSourceNode::start(double when) {
 #if !RN_AUDIO_API_TEST
-  if (auto context = dynamic_cast<AudioContext *>(context_)) {
-    context->start();
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    if (auto audioContext = dynamic_cast<AudioContext *>(context.get())) {
+      audioContext->start();
+    }
   }
 #endif // RN_AUDIO_API_TEST
 
@@ -72,18 +74,16 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess,
     size_t &startOffset,
-    size_t &nonSilentFramesToProcess) {
+    size_t &nonSilentFramesToProcess,
+    float sampleRate,
+    size_t currentSampleFrame) {
   if (!isInitialized_) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;
     return;
   }
 
-  assert(context_ != nullptr);
-
-  auto sampleRate = context_->getSampleRate();
-
-  size_t firstFrame = context_->getCurrentSampleFrame();
+  auto firstFrame = currentSampleFrame;
   size_t lastFrame = firstFrame + framesToProcess - 1;
 
   size_t startFrame = std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -26,7 +26,7 @@ class AudioScheduledSourceNode : public AudioNode {
   // STOP_SCHEDULED: The node is scheduled to stop at a specific time, but is still playing.
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
-  explicit AudioScheduledSourceNode(BaseAudioContext *context);
+  explicit AudioScheduledSourceNode(std::shared_ptr<BaseAudioContext> context);
 
   virtual void start(double when);
   virtual void stop(double when);
@@ -54,7 +54,9 @@ class AudioScheduledSourceNode : public AudioNode {
       const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess,
       size_t &startOffset,
-      size_t &nonSilentFramesToProcess);
+      size_t &nonSilentFramesToProcess,
+      float sampleRate,
+      size_t currentSampleFrame);
 
   void handleStopScheduled();
 };

package/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp

@@ -6,10 +6,14 @@
 #include <memory>
 
 namespace audioapi {
-ConstantSourceNode::ConstantSourceNode(BaseAudioContext *context)
-    : AudioScheduledSourceNode(context) {
-  offsetParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+ConstantSourceNode::ConstantSourceNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioScheduledSourceNode(context),
+      offsetParam_(
+          std::make_shared<AudioParam>(
+              1.0,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)) {
   isInitialized_ = true;
 }
 
@@ -23,15 +27,19 @@ std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
-
-  if (!isPlaying() && !isStopScheduled()) {
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
     processingBus->zero();
     return processingBus;
   }
 
-  auto offsetBus = offsetParam_->processARateParam(framesToProcess, context_->getCurrentTime());
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
 
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+  auto offsetBus = offsetParam_->processARateParam(framesToProcess, context->getCurrentTime());
   auto offsetChannelData = offsetBus->getChannel(0)->getData();
 
   for (int channel = 0; channel < processingBus->getNumberOfChannels(); ++channel) {

package/common/cpp/audioapi/core/sources/ConstantSourceNode.h

@@ -13,7 +13,7 @@ class AudioBus;
 
 class ConstantSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit ConstantSourceNode(BaseAudioContext *context);
+  explicit ConstantSourceNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
 

package/common/cpp/audioapi/core/sources/OscillatorNode.cpp

@@ -8,19 +8,23 @@
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {
-  frequencyParam_ = std::make_shared<AudioParam>(
-      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency(), context);
-  detuneParam_ = std::make_shared<AudioParam>(
-      0.0,
-      -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      context);
-  type_ = OscillatorType::SINE;
-  periodicWave_ = context_->getBasicWaveForm(type_);
-
-  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
-
+OscillatorNode::OscillatorNode(std::shared_ptr<BaseAudioContext> context)
+    : AudioScheduledSourceNode(context),
+      frequencyParam_(
+          std::make_shared<AudioParam>(
+              444.0,
+              -context->getNyquistFrequency(),
+              context->getNyquistFrequency(),
+              context)),
+      detuneParam_(
+          std::make_shared<AudioParam>(
+              0.0,
+              -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+              1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      type_(OscillatorType::SINE),
+      periodicWave_(context->getBasicWaveForm(type_)) {
+  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate());
   isInitialized_ = true;
 }
 
@@ -37,8 +41,10 @@ std::string OscillatorNode::getType() {
 }
 
 void OscillatorNode::setType(const std::string &type) {
-  type_ = OscillatorNode::fromString(type);
-  periodicWave_ = context_->getBasicWaveForm(type_);
+  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+    type_ = OscillatorNode::fromString(type);
+    periodicWave_ = context->getBasicWaveForm(type_);
+  }
 }
 
 void OscillatorNode::setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave) {
@@ -52,15 +58,21 @@ std::shared_ptr<AudioBus> OscillatorNode::processNode(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBus->zero();
+    return processingBus;
+  }
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
     return processingBus;
   }
 
-  auto time = context_->getCurrentTime() +
-      static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
+  auto time =
+      context->getCurrentTime() + static_cast<double>(startOffset) * 1.0 / context->getSampleRate();
   auto detuneParamValues = detuneParam_->processARateParam(framesToProcess, time);
   auto frequencyParamValues = frequencyParam_->processARateParam(framesToProcess, time);
 

package/common/cpp/audioapi/core/sources/OscillatorNode.h

@@ -16,7 +16,7 @@ class AudioBus;
 
 class OscillatorNode : public AudioScheduledSourceNode {
  public:
-  explicit OscillatorNode(BaseAudioContext *context);
+  explicit OscillatorNode(std::shared_ptr<BaseAudioContext> context);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp

@@ -9,8 +9,7 @@
 
 namespace audioapi {
 
-RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
-    std::is_nothrow_constructible<AudioNode, BaseAudioContext *>::value)
+RecorderAdapterNode::RecorderAdapterNode(std::shared_ptr<BaseAudioContext> context)
     : AudioNode(context) {
   // It should be marked as initialized only after it is connected to the
   // recorder. Internall buffer size is based on the recorder's buffer length.
@@ -18,7 +17,8 @@ RecorderAdapterNode::RecorderAdapterNode(BaseAudioContext *context) noexcept(
 }
 
 void RecorderAdapterNode::init(size_t bufferSize, int channelCount) {
-  if (isInitialized_) {
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (isInitialized_ || context == nullptr) {
     return;
   }
 
@@ -42,7 +42,7 @@ void RecorderAdapterNode::init(size_t bufferSize, int channelCount) {
   // context output and not enforcing anything on the system output/input configuration.
   // A lot of words for a couple of lines of implementation :shrug:
   adapterOutputBus_ =
-      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
   isInitialized_ = true;
 }
 

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.h

@@ -19,7 +19,7 @@ class AudioBus;
 /// @note it will push silence if it is not connected to any Recorder
 class RecorderAdapterNode : public AudioNode {
  public:
-  explicit RecorderAdapterNode(BaseAudioContext *context);
+  explicit RecorderAdapterNode(std::shared_ptr<BaseAudioContext> context);
 
   /// @brief Initialize the RecorderAdapterNode with a buffer size and channel count.
   /// @note This method should be called ONLY ONCE when the buffer size is known.

package/common/cpp/audioapi/core/sources/StreamerNode.cpp

@@ -22,7 +22,7 @@
 
 namespace audioapi {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-StreamerNode::StreamerNode(BaseAudioContext *context)
+StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context)
     : AudioScheduledSourceNode(context),
       fmtCtx_(nullptr),
       codecCtx_(nullptr),
@@ -37,7 +37,7 @@ StreamerNode::StreamerNode(BaseAudioContext *context)
       maxResampledSamples_(0),
       processedSamples_(0) {}
 #else
-StreamerNode::StreamerNode(BaseAudioContext *context) : AudioScheduledSourceNode(context) {}
+StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context) : AudioScheduledSourceNode(context) {}
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 StreamerNode::~StreamerNode() {
@@ -48,6 +48,11 @@ StreamerNode::~StreamerNode() {
 
 bool StreamerNode::initialize(const std::string &input_url) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    return false;
+  }
+
   if (isInitialized_) {
     cleanup();
   }
@@ -58,7 +63,7 @@ bool StreamerNode::initialize(const std::string &input_url) {
     return false;
   }
 
-  if (!findAudioStream() || !setupDecoder() || !setupResampler()) {
+  if (!findAudioStream() || !setupDecoder() || !setupResampler(context->getSampleRate())) {
     if (VERBOSE)
       printf("Failed to find/setup audio stream\n");
     cleanup();
@@ -77,7 +82,7 @@ bool StreamerNode::initialize(const std::string &input_url) {
 
   channelCount_ = codecpar_->ch_layout.nb_channels;
   audioBus_ =
-      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 
   auto [sender, receiver] = channels::spsc::channel<
       StreamingData,
@@ -100,7 +105,12 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
 #if !RN_AUDIO_API_FFMPEG_DISABLED
   size_t startOffset = 0;
   size_t offsetLength = 0;
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBus->zero();
+    return processingBus;
+  }
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
   isNodeFinished_.store(isFinished(), std::memory_order_release);
 
   if (!isPlaying() && !isStopScheduled()) {
@@ -146,7 +156,7 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
 }
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-bool StreamerNode::setupResampler() {
+bool StreamerNode::setupResampler(float outSampleRate) {
   // Allocate resampler context
   swrCtx_ = swr_alloc();
   if (swrCtx_ == nullptr) {
@@ -160,7 +170,7 @@ bool StreamerNode::setupResampler() {
 
   // Set output parameters (float)
   av_opt_set_chlayout(swrCtx_, "out_chlayout", &codecCtx_->ch_layout, 0);
-  av_opt_set_int(swrCtx_, "out_sample_rate", context_->getSampleRate(), 0);
+  av_opt_set_int(swrCtx_, "out_sample_rate", outSampleRate, 0);
   av_opt_set_sample_fmt(swrCtx_, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
 
   // Initialize the resampler
@@ -193,7 +203,11 @@ void StreamerNode::streamAudio() {
       if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
         return;
       }
-      if (!processFrameWithResampler(frame_)) {
+      std::shared_ptr<BaseAudioContext> context = context_.lock();
+      if (context == nullptr) {
+        return;
+      }
+      if (!processFrameWithResampler(frame_, context)) {
         return;
       }
     }
@@ -201,7 +215,7 @@ void StreamerNode::streamAudio() {
   }
 }
 
-bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
+bool StreamerNode::processFrameWithResampler(AVFrame *frame, std::shared_ptr<BaseAudioContext> context) {
   // Check if we need to reallocate the resampled buffer
   int out_samples = swr_get_out_samples(swrCtx_, frame->nb_samples);
   if (out_samples > maxResampledSamples_) {
@@ -241,7 +255,7 @@ bool StreamerNode::processFrameWithResampler(AVFrame *frame) {
   auto bus = AudioBus(
       static_cast<size_t>(converted_samples),
       codecCtx_->ch_layout.nb_channels,
-      context_->getSampleRate());
+      context->getSampleRate());
   for (int ch = 0; ch < codecCtx_->ch_layout.nb_channels; ch++) {
     auto *src = reinterpret_cast<float *>(resampledData_[ch]);
     float *dst = bus.getChannel(ch)->getData();

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -62,7 +62,7 @@ class AudioBus;
 
 class StreamerNode : public AudioScheduledSourceNode {
  public:
-  explicit StreamerNode(BaseAudioContext *context);
+  explicit StreamerNode(std::shared_ptr<BaseAudioContext> context);
   ~StreamerNode() override;
 
   /**
@@ -106,16 +106,17 @@ class StreamerNode : public AudioScheduledSourceNode {
 
   /**
    * @brief Setting up the resampler
+   * @param outSampleRate Sample rate for the output audio
    * @return true if successful, false otherwise
    */
-  bool setupResampler();
+  bool setupResampler(float outSampleRate);
 
   /**
    * @brief Resample the audio frame, change its sample format and channel layout
    * @param frame The AVFrame to resample
    * @return true if successful, false otherwise
    */
-  bool processFrameWithResampler(AVFrame *frame);
+  bool processFrameWithResampler(AVFrame *frame, std::shared_ptr<BaseAudioContext> context);
 
   /**
    * @brief Thread function to continuously read and process audio frames

package/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp

@@ -5,7 +5,9 @@
 
 namespace audioapi {
 
-WorkletSourceNode::WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+WorkletSourceNode::WorkletSourceNode(
+    std::shared_ptr<BaseAudioContext> context,
+    WorkletsRunner &&workletRunner)
     : AudioScheduledSourceNode(context), workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
@@ -29,7 +31,12 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
   size_t startOffset = 0;
   size_t nonSilentFramesToProcess = framesToProcess;
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBus->zero();
+    return processingBus;
+  }
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, nonSilentFramesToProcess, context->getSampleRate(), context->getCurrentSampleFrame());
 
   if (nonSilentFramesToProcess == 0) {
     processingBus->zero();
@@ -39,7 +46,7 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
   size_t outputChannelCount = processingBus->getNumberOfChannels();
 
   auto result = workletRunner_.executeOnRuntimeSync(
-      [this, nonSilentFramesToProcess, startOffset](jsi::Runtime &rt) {
+      [this, nonSilentFramesToProcess, startOffset, time = context->getCurrentTime()](jsi::Runtime &rt) {
         auto jsiArray = jsi::Array(rt, this->outputBuffsHandles_.size());
         for (size_t i = 0; i < this->outputBuffsHandles_.size(); ++i) {
           auto arrayBuffer = jsi::ArrayBuffer(rt, this->outputBuffsHandles_[i]);
@@ -52,7 +59,7 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
         return workletRunner_.callUnsafe(
             jsiArray,
             jsi::Value(rt, static_cast<int>(nonSilentFramesToProcess)),
-            jsi::Value(rt, this->context_->getCurrentTime()),
+            jsi::Value(rt, time),
             jsi::Value(rt, static_cast<int>(startOffset)));
       });
 

package/common/cpp/audioapi/core/sources/WorkletSourceNode.h

@@ -16,7 +16,9 @@ namespace audioapi {
 #if RN_AUDIO_API_TEST
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner)
+  explicit WorkletSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      WorkletsRunner &&workletRunner)
       : AudioScheduledSourceNode(context) {}
 
  protected:
@@ -30,7 +32,9 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
 
 class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
-  explicit WorkletSourceNode(BaseAudioContext *context, WorkletsRunner &&workletRunner);
+  explicit WorkletSourceNode(
+      std::shared_ptr<BaseAudioContext> context,
+      WorkletsRunner &&workletRunner);
 
  protected:
   std::shared_ptr<AudioBus> processNode(

package/common/cpp/audioapi/core/types/OverSampleType.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace audioapi {
+
+enum class OverSampleType { OVERSAMPLE_NONE, OVERSAMPLE_2X, OVERSAMPLE_4X };
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -54,6 +54,7 @@ void AudioRecorderCallback::emitAudioData(bool flush) {
   if (sizeLimit == 0) {
     return;
   }
+
   while (circularBus_[0]->getNumberOfAvailableFrames() >= sizeLimit) {
     auto bus = std::make_shared<AudioBus>(sizeLimit, channelCount_, sampleRate_);
 

package/common/cpp/audioapi/dsp/Resampler.cpp

@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <audioapi/dsp/Resampler.h>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <memory>
+#include <numbers>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#endif
+
+// based on WebKit UpSampler and DownSampler implementation
+
+namespace audioapi {
+
+Resampler::Resampler(int maxBlockSize, int kernelSize):
+    kernelSize_(kernelSize),
+    kernel_(std::make_shared<AudioArray>(kernelSize)),
+    stateBuffer_(std::make_shared<AudioArray>(2 * maxBlockSize)) {
+  stateBuffer_->zero();
+}
+
+// https://en.wikipedia.org/wiki/Window_function
+float Resampler::computeBlackmanWindow(double x) const {
+    double alpha = 0.16;
+    double a0 = 0.5 * (1.0 - alpha);
+    double a1 = 0.5;
+    double a2 = 0.5 * alpha;
+    double n = x / kernelSize_;
+    return static_cast<float>(a0 - a1 * std::cos(2.0 * PI * n) + a2 * std::cos(4.0 * PI * n));
+}
+
+float Resampler::computeConvolution(const float *stateStart, const float *kernelStart) const {
+  float sum = 0.0f;
+  int k = 0;
+
+#ifdef __ARM_NEON
+  float32x4_t vSum = vdupq_n_f32(0.0f);
+
+  // process 4 samples at a time
+  for (; k <= kernelSize_ - 4; k += 4) {
+    float32x4_t vState = vld1q_f32(stateStart + k);
+    float32x4_t vKernel = vld1q_f32(kernelStart + k);
+
+    // fused multiply-add: vSum += vState * vKernel
+    vSum = vmlaq_f32(vSum, vState, vKernel);
+  }
+
+  // horizontal reduction: Sum the 4 lanes of vSum into a single float
+  sum += vgetq_lane_f32(vSum, 0);
+  sum += vgetq_lane_f32(vSum, 1);
+  sum += vgetq_lane_f32(vSum, 2);
+  sum += vgetq_lane_f32(vSum, 3);
+#endif
+  for (; k < kernelSize_; ++k) {
+    sum += stateStart[k] * kernelStart[k];
+  }
+
+  return sum;
+}
+
+void Resampler::reset() {
+  if (stateBuffer_) {
+    stateBuffer_->zero();
+  }
+}
+
+UpSampler::UpSampler(int maxBlockSize, int kernelSize) : Resampler(maxBlockSize, kernelSize) {
+  initializeKernel();
+}
+
+void UpSampler::initializeKernel() {
+  auto kData = kernel_->getData();
+  int halfSize = kernelSize_ / 2;
+  double subSampleOffset = -0.5;
+
+  for (int i = 0; i < kernelSize_; ++i) {
+    // we want to sample the sinc function halfway between integer points
+    auto x = static_cast<double>(i - halfSize) - subSampleOffset;
+
+    // https://en.wikipedia.org/wiki/Sinc_filter
+    // sets cutoff frequency to nyquist
+    double sinc = (std::abs(x) < 1e-9) ? 1.0 : std::sin(x * PI) / (x * PI);
+
+    // apply window in order smooth out the edges, because sinc extends to infinity in both directions
+    kData[i] = static_cast<float>(sinc * computeBlackmanWindow(i - subSampleOffset));
+  }
+
+  // reverse kernel to match convolution implementation
+  std::reverse(kData, kData + kernelSize_);
+}
+
+int UpSampler::process(
+    const std::shared_ptr<AudioArray> &input,
+    const std::shared_ptr<AudioArray> &output,
+    int framesToProcess) {
+
+  const float *inputData = input->getData();
+  float *outputData = output->getData();
+  float *state = stateBuffer_->getData();
+  const float *kernel = kernel_->getData();
+
+  // copy new input [ HISTORY | NEW DATA ]
+  std::memcpy(state + kernelSize_, inputData, framesToProcess * sizeof(float));
+
+  int halfKernel = kernelSize_ / 2;
+
+  for (int i = 0; i < framesToProcess; ++i) {
+    // direct copy for even samples with half kernel latency compensation
+    outputData[2 * i] = state[kernelSize_ + i - halfKernel];
+
+    // convolution for odd samples
+    // symmetric Linear Phase filter has latency of half kernel size
+    outputData[2 * i + 1] = computeConvolution(&state[i + 1], kernel);
+  }
+
+  // move new data to history [ NEW DATA | EMPTY ]
+  std::memmove(state, state + framesToProcess, kernelSize_ * sizeof(float));
+
+  return framesToProcess * 2;
+}
+
+DownSampler::DownSampler(int maxBlockSize, int kernelSize) : Resampler(maxBlockSize, kernelSize) {
+    initializeKernel();
+}
+
+void DownSampler::initializeKernel() {
+  auto kData = kernel_->getData();
+  int halfSize = kernelSize_ / 2;
+
+  for (int i = 0; i < kernelSize_; ++i) {
+    // we want to sample the sinc function halfway between integer points
+    auto x = static_cast<double>(i - halfSize);
+
+    // https://en.wikipedia.org/wiki/Sinc_filter
+    // sets cutoff frequency to nyquist / 2
+    double sinc = (std::abs(x) < 1e-9) ? 1.0 : std::sin(x * PI * 0.5) / (x * PI * 0.5);
+    sinc *= 0.5;
+
+    // apply window in order smooth out the edges, because sinc extends to infinity in both directions
+    kData[i] = static_cast<float>(sinc * computeBlackmanWindow(i));
+  }
+
+  // reverse kernel to match convolution implementation
+  std::reverse(kData, kData + kernelSize_);
+}
+
+int DownSampler::process(
+    const std::shared_ptr<AudioArray> &input,
+    const std::shared_ptr<AudioArray> &output,
+    int framesToProcess) {
+  const float *inputData = input->getData();
+  float *outputData = output->getData();
+  float *state = stateBuffer_->getData();
+  const float *kernel = kernel_->getData();
+
+  // copy new input [ HISTORY | NEW DATA ]
+  std::memcpy(state + kernelSize_, inputData, framesToProcess * sizeof(float));
+
+  auto outputCount = framesToProcess / 2;
+
+  for (int i = 0; i < outputCount; ++i) {
+    // convolution for downsampled samples
+    outputData[i] = computeConvolution(&state[2 * i + 1], kernel);
+  }
+
+  // move new data to history [ NEW DATA | EMPTY ]
+  std::memmove(state, state + framesToProcess, kernelSize_ * sizeof(float));
+
+  return outputCount;
+}
+} // namespace audioapi