react-native-audio-api 0.8.3 → 0.9.0-nightly-96a5bcd-20251007

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h

@@ -1,11 +1,11 @@
 /*
- * This file dynamically links to the FFmpeg library, which is licensed under the
- * GNU Lesser General Public License (LGPL) version 2.1 or later.
+ * This file dynamically links to the FFmpeg library, which is licensed under
+ * the GNU Lesser General Public License (LGPL) version 2.1 or later.
  *
- * Our own code in this file is licensed under the MIT License and dynamic linking
- * allows you to use this code without your entire project being subject to the
- * terms of the LGPL. However, note that if you link statically to FFmpeg, you must
- * comply with the terms of the LGPL for FFmpeg itself.
+ * Our own code in this file is licensed under the MIT License and dynamic
+ * linking allows you to use this code without your entire project being subject
+ * to the terms of the LGPL. However, note that if you link statically to
+ * FFmpeg, you must comply with the terms of the LGPL for FFmpeg itself.
  */
 
 #include <audioapi/utils/AudioBus.h>
@@ -14,24 +14,62 @@
 #include <vector>
 
 extern "C" {
-    #include <libavcodec/avcodec.h>
-    #include <libavformat/avformat.h>
-    #include <libavutil/opt.h>
-    #include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/opt.h>
+#include <libswresample/swresample.h>
 }
+class AudioBuffer;
 
-namespace audioapi::ffmpegdecoding {
+namespace audioapi::ffmpegdecoder {
 // Custom IO context for reading from memory
 struct MemoryIOContext {
-    const uint8_t *data;
-    size_t size;
-    size_t pos;
-  };
+  const uint8_t *data;
+  size_t size;
+  size_t pos;
+};
+
+struct AudioStreamContext {
+  AVFormatContext *fmt_ctx = nullptr;
+  AVCodecContext *codec_ctx = nullptr;
+  int audio_stream_index = -1;
+};
 
 int read_packet(void *opaque, uint8_t *buf, int buf_size);
 int64_t seek_packet(void *opaque, int64_t offset, int whence);
-std::vector<int16_t> readAllPcmFrames(AVFormatContext *fmt_ctx, AVCodecContext *codec_ctx, int out_sample_rate, int audio_stream_index, int channels, size_t &framesRead);
-std::vector<int16_t> decodeWithMemoryBlock(const void *data, size_t size, const int channel_count, int sample_rate);
-std::vector<int16_t> decodeWithFilePath(const std::string &path, const int channel_count, int sample_rate);
+inline int findAudioStreamIndex(AVFormatContext *fmt_ctx);
+std::vector<float> readAllPcmFrames(
+    AVFormatContext *fmt_ctx,
+    AVCodecContext *codec_ctx,
+    int out_sample_rate,
+    int output_channel_count,
+    int audio_stream_index,
+    size_t &framesRead);
+
+void convertFrameToBuffer(
+    SwrContext *swr,
+    AVFrame *frame,
+    int output_channel_count,
+    std::vector<float> &buffer,
+    size_t &framesRead,
+    uint8_t **&resampled_data,
+    int &max_resampled_samples);
+bool setupDecoderContext(
+    AVFormatContext *fmt_ctx,
+    int &audio_stream_index,
+    std::unique_ptr<AVCodecContext, decltype(&avcodec_free_context)>
+        &codec_ctx);
+std::shared_ptr<AudioBuffer> decodeAudioFrames(
+    AVFormatContext *fmt_ctx,
+    AVCodecContext *codec_ctx,
+    int audio_stream_index,
+    int sample_rate);
+
+std::shared_ptr<AudioBuffer>
+decodeWithMemoryBlock(const void *data, size_t size, int sample_rate);
+
+std::shared_ptr<AudioBuffer> decodeWithFilePath(
+    const std::string &path,
+    int sample_rate);
 
-} // namespace audioapi::ffmpegdecoder
+} // namespace audioapi::ffmpegdecoder

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>

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

@@ -0,0 +1,104 @@
+#pragma once
+#include <thread>
+#include <vector>
+#include <functional>
+#include <variant>
+#include <audioapi/utils/SpscChannel.hpp>
+
+namespace audioapi {
+
+/// @brief A simple thread pool implementation using lock-free SPSC channels for task scheduling and execution.
+/// @note The thread pool consists of a load balancer thread and multiple worker threads.
+/// @note The load balancer receives tasks and distributes them to worker threads in a round-robin fashion.
+/// @note Each worker thread has its own SPSC channel to receive tasks from the load balancer.
+/// @note The thread pool can be shut down gracefully by sending a stop event to the load balancer, which then propagates the stop event to all worker threads.
+/// @note IMPORTANT: ThreadPool is not thread-safe and events should be scheduled from a single thread only.
+class ThreadPool {
+  struct StopEvent {};
+  struct TaskEvent { std::function<void()> task; };
+  using Event = std::variant<TaskEvent, StopEvent>;
+
+  using Sender = channels::spsc::Sender<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+  using Receiver = channels::spsc::Receiver<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+public:
+  /// @brief Construct a new ThreadPool
+  /// @param numThreads The number of worker threads to create
+  /// @param loadBalancerQueueSize The size of the load balancer's queue
+  /// @param workerQueueSize The size of each worker thread's queue
+  ThreadPool(size_t numThreads, size_t loadBalancerQueueSize = 32, size_t workerQueueSize = 32) {
+    auto [sender, receiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(loadBalancerQueueSize);
+    loadBalancerSender = std::move(sender);
+    std::vector<Sender> workerSenders;
+    workerSenders.reserve(numThreads);
+    for (size_t i = 0; i < numThreads; ++i) {
+      auto [workerSender, workerReceiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(workerQueueSize);
+      workers.emplace_back(&ThreadPool::workerThreadFunc, this, std::move(workerReceiver));
+      workerSenders.emplace_back(std::move(workerSender));
+    }
+    loadBalancerThread = std::thread(&ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+  }
+  ~ThreadPool() {
+    loadBalancerSender.send(StopEvent{});
+    loadBalancerThread.join();
+    for (auto& worker : workers) {
+      worker.join();
+    }
+  }
+
+  /// @brief Schedule a task to be executed by the thread pool
+  /// @param task The task to be executed
+  /// @note This function is lock-free and most of the time wait-free, but may block if the load balancer queue is full.
+  /// @note Please remember that the task will be executed in a different thread, so make sure to capture any required variables by value.
+  /// @note The task should not throw exceptions, as they will not be caught.
+  /// @note The task should end at some point, otherwise the thread pool will never be able to shut down.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only.
+  void schedule(std::function<void()> &&task) noexcept {
+    loadBalancerSender.send(TaskEvent{std::move(task)});
+  }
+
+private:
+  std::thread loadBalancerThread;
+  std::vector<std::thread> workers;
+  Sender loadBalancerSender;
+
+  void workerThreadFunc(Receiver &&receiver) {
+    Receiver localReceiver = std::move(receiver);
+    while (true) {
+      auto event = localReceiver.receive();
+      /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
+      /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
+      /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
+      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+        break;
+      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+        std::get<TaskEvent>(event).task();
+      }
+    }
+  }
+
+  void loadBalancerThreadFunc(Receiver &&receiver, std::vector<Sender> &&workerSenders) {
+    Receiver localReceiver = std::move(receiver);
+    std::vector<Sender> localWorkerSenders = std::move(workerSenders);
+    size_t nextWorker = 0;
+    while (true) {
+      auto event = localReceiver.receive();
+      /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
+      /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
+      /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
+      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+        // Propagate stop event to all workers
+        for (size_t i = 0; i < localWorkerSenders.size(); ++i) {
+          localWorkerSenders[i].send(StopEvent{});
+        }
+        break;
+      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+        // Dispatch task to the next worker in round-robin fashion
+        auto& taskEvent = std::get<TaskEvent>(event);
+        localWorkerSenders[nextWorker].send(std::move(taskEvent));
+        nextWorker = (nextWorker + 1) % localWorkerSenders.size();
+      }
+    }
+  }
+};
+
+}; // namespace audioapi

package/common/cpp/test/AudioParamTest.cpp

@@ -0,0 +1,204 @@
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include "MockAudioEventHandlerRegistry.h"
+
+using namespace audioapi;
+
+class AudioParamTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+TEST_F(AudioParamTest, ValueSetters) {
+  AudioParam param = AudioParam(0.5, 0.0, 1.0, context.get());
+  param.setValue(0.8);
+  EXPECT_FLOAT_EQ(param.getValue(), 0.8);
+  param.setValue(-0.5);
+  EXPECT_FLOAT_EQ(param.getValue(), 0.0);
+  param.setValue(1.5);
+  EXPECT_FLOAT_EQ(param.getValue(), 1.0);
+}
+
+TEST_F(AudioParamTest, SetValueAtTime) {
+  AudioParam param = AudioParam(0.5, 0.0, 1.0, context.get());
+  param.setValueAtTime(0.8, 0.1);
+  param.setValueAtTime(0.3, 0.2);
+
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.5);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_FLOAT_EQ(value, 0.3);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_FLOAT_EQ(value, 0.3);
+}
+
+TEST_F(AudioParamTest, LinearRampToValueAtTime) {
+  AudioParam param = AudioParam(0, 0, 1.0, context.get());
+  param.linearRampToValueAtTime(1.0, 0.2);
+
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.25);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.5);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_FLOAT_EQ(value, 0.75);
+
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_FLOAT_EQ(value, 1.0);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_FLOAT_EQ(value, 1.0);
+}
+
+TEST_F(AudioParamTest, ExponentialRampToValueAtTime) {
+  AudioParam param = AudioParam(0.1, 0.0, 1.0, context.get());
+  param.exponentialRampToValueAtTime(1.0, 0.2);
+  // value(time) = startValue * (endValue/startValue)^((time -
+  // startTime)/(endTime - startTime)) value(time) = 0.1 * (1.0/0.1)^((time -
+  // 0.0)/(0.2 - 0.0))
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_NEAR(value, 0.17783, 1e-5);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_NEAR(value, 0.316228, 1e-5);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_NEAR(value, 0.562341, 1e-5);
+
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_FLOAT_EQ(value, 1.0);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_FLOAT_EQ(value, 1.0);
+}
+
+TEST_F(AudioParamTest, SetTargetAtTime) {
+  AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
+  param.setTargetAtTime(1.0, 0.1, 0.1);
+  // value(time) = target + (startValue - target) * exp(-(time -
+  // startTime)/timeConstant) value(time) = 1.0 + (0.0 - 1.0) * exp(-time/0.1)
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.0);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.0);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_NEAR(value, 0.393469, 1e-5);
+
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_NEAR(value, 0.632120, 1e-5);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_NEAR(value, 0.776869, 1e-5);
+
+  value = param.processKRateParam(1, 0.5);
+  EXPECT_NEAR(value, 0.981684, 1e-5);
+}
+
+TEST_F(AudioParamTest, SetValueCurveAtTime) {
+  AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
+  param.setValue(0.5);
+  auto curve = std::make_shared<std::vector<float>>(
+      std::vector<float>{0.1, 0.4, 0.2, 0.8, 0.5});
+  param.setValueCurveAtTime(curve, curve->size(), 0.1, 0.2);
+  // 5 elements over 0.2s => each element is 0.04s apart
+
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.0);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.1);
+
+  // k = 4/0.2 * (0.14 - 0.1) = 0.8 -> floor is 0
+  // linear interpolation between 0 and 1 -> 0.1 + (0.4 - 0.1) * 0.8 = 0.34
+  value = param.processKRateParam(1, 0.14);
+  EXPECT_FLOAT_EQ(value, 0.34);
+
+  // k = 4/0.2 * (0.18 - 0.1) = 1.6 -> floor is 1
+  // linear interpolation between 1 and 2 -> 0.4 + (0.2 - 0.4) * 0.6 = 0.28
+  value = param.processKRateParam(1, 0.18);
+  EXPECT_FLOAT_EQ(value, 0.28);
+
+  // k = 4/0.2 * (0.22 - 0.1) = 2.4 -> floor is 2
+  // linear interpolation between 2 and 3 -> 0.2 + (0.8 - 0.2) * 0.4 = 0.44
+  value = param.processKRateParam(1, 0.22);
+  EXPECT_FLOAT_EQ(value, 0.44);
+
+  // k = 4/0.2 * (0.26 - 0.1) = 3.2 -> floor is 3
+  // linear interpolation between 3 and 4 -> 0.8 + (0.5 - 0.8) * 0.2 = 0.74
+  value = param.processKRateParam(1, 0.26);
+  EXPECT_FLOAT_EQ(value, 0.74);
+
+  // k = 4/0.2 * (0.3 - 0.1) = 4.0 -> floor is 4
+  // at or after end of curve -> last value
+  value = param.processKRateParam(1, 0.35);
+  EXPECT_FLOAT_EQ(value, 0.5);
+}
+
+TEST_F(AudioParamTest, CancelScheduledValues) {
+  AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
+  param.setValueAtTime(0.8, 0.1);
+  param.setValueAtTime(0.3, 0.2);
+  param.linearRampToValueAtTime(1.0, 0.4);
+  param.cancelScheduledValues(0.15);
+
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.0);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  // Events after cancel time are removed -> stays at last value
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_FLOAT_EQ(value, 0.8);
+}
+
+TEST_F(AudioParamTest, CancelAndHoldAtTime) {
+  AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
+  param.setValueAtTime(0.8, 0.1);
+  param.linearRampToValueAtTime(1.0, 0.2);
+  param.cancelAndHoldAtTime(0.15);
+
+  float value = param.processKRateParam(1, 0.05);
+  EXPECT_FLOAT_EQ(value, 0.0);
+
+  value = param.processKRateParam(1, 0.1);
+  EXPECT_FLOAT_EQ(value, 0.8);
+
+  value = param.processKRateParam(1, 0.15);
+  EXPECT_FLOAT_EQ(value, 0.9);
+
+  // Events after cancel time are removed -> stays at last value
+  value = param.processKRateParam(1, 0.2);
+  EXPECT_FLOAT_EQ(value, 0.9);
+
+  value = param.processKRateParam(1, 0.25);
+  EXPECT_FLOAT_EQ(value, 0.9);
+}

package/common/cpp/test/CMakeLists.txt

@@ -21,11 +21,17 @@ enable_testing()
 file(GLOB_RECURSE RNAUDIOAPI_SRC
   CONFIGURE_DEPENDS
   "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/*.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioDecoder.cpp"
+  "${ROOT}/node_modules/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp"
 )
 
-list(REMOVE_ITEM RNAUDIOAPI_SRC 
+# exclude HostObjects from tests
+list(FILTER RNAUDIOAPI_SRC EXCLUDE REGEX ".*/audioapi/HostObjects/.*\\.cpp$")
+
+list(REMOVE_ITEM RNAUDIOAPI_SRC
   "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp"
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp"
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp"
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp"
   "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp"
   "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h"
   "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp"
@@ -56,14 +62,17 @@ target_include_directories(rnaudioapi PUBLIC
 target_include_directories(rnaudioapi_libs PUBLIC
   ${ROOT}/packages/react-native-audio-api/common/cpp
 )
-
 add_executable(
   tests
   OscillatorTest.cpp
   GainTest.cpp
+  AudioParamTest.cpp
+  StereoPannerTest.cpp
 )
 
 add_compile_definitions(AUDIO_API_TEST_SUITE)
+add_compile_definitions(RN_AUDIO_API_ENABLE_WORKLETS=0)
+add_compile_definitions(RN_AUDIO_API_TEST=1)
 
 target_link_libraries(tests
   rnaudioapi
@@ -73,4 +82,4 @@ target_link_libraries(tests
 )
 
 include(GoogleTest)
-gtest_discover_tests(tests)
+gtest_discover_tests(tests)

package/common/cpp/test/GainTest.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
@@ -14,7 +15,7 @@ class GainTest : public ::testing::Test {
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_unique<audioapi::OfflineAudioContext>(
-        2, 5 * sampleRate, sampleRate, eventRegistry);
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 };
 
@@ -27,10 +28,10 @@ class TestableGainNode : public audioapi::GainNode {
     getGainParam()->setValue(value);
   }
 
-  void processNode(
+  std::shared_ptr<audioapi::AudioBus> processNode(
       const std::shared_ptr<audioapi::AudioBus> &processingBus,
       int framesToProcess) override {
-    audioapi::GainNode::processNode(processingBus, framesToProcess);
+    return audioapi::GainNode::processNode(processingBus, framesToProcess);
   }
 };
 
@@ -51,9 +52,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
     bus->getChannel(0)->getData()[i] = i + 1;
   }
 
-  gainNode->processNode(bus, FRAMES_TO_PROCESS);
-  for (size_t i = 0; i < bus->getSize(); ++i) {
-    EXPECT_FLOAT_EQ((*bus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
+  auto resultBus = gainNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
   }
 }
 
@@ -70,9 +71,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
     bus->getChannel(1)->getData()[i] = -i - 1;
   }
 
-  gainNode->processNode(bus, FRAMES_TO_PROCESS);
-  for (size_t i = 0; i < bus->getSize(); ++i) {
-    EXPECT_FLOAT_EQ((*bus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
-    EXPECT_FLOAT_EQ((*bus->getChannel(1))[i], (-i - 1) * GAIN_VALUE);
+  auto resultBus = gainNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(1))[i], (-i - 1) * GAIN_VALUE);
   }
 }

package/common/cpp/test/OscillatorTest.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/sources/OscillatorNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include "MockAudioEventHandlerRegistry.h"
 
@@ -12,7 +13,7 @@ class OscillatorTest : public ::testing::Test {
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_unique<audioapi::OfflineAudioContext>(
-        2, 5 * sampleRate, sampleRate, eventRegistry);
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 };
 

package/common/cpp/test/StereoPannerTest.cpp

@@ -0,0 +1,129 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include "MockAudioEventHandlerRegistry.h"
+
+using namespace audioapi;
+
+class StereoPannerTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableStereoPannerNode : public StereoPannerNode {
+ public:
+  explicit TestableStereoPannerNode(BaseAudioContext *context)
+      : StereoPannerNode(context) {}
+
+  void setPanParam(float value) {
+    getPanParam()->setValue(value);
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return StereoPannerNode::processNode(processingBus, framesToProcess);
+  }
+};
+
+TEST_F(StereoPannerTest, StereoPannerCanBeCreated) {
+  auto panner = context->createStereoPanner();
+  ASSERT_NE(panner, nullptr);
+}
+
+TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
+  static constexpr float PAN_VALUE = 0.5;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
+  panNode->setPanParam(PAN_VALUE);
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
+  }
+
+  auto resultBus = panNode->processNode(bus, FRAMES_TO_PROCESS);
+  // x = (0.5 + 1) / 2 = 0.75
+  // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
+  // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelLeft))[i],
+        (i + 1) * 0.38268343236508984,
+        1e-4);
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelRight))[i],
+        (i + 1) * 0.9238795325112867,
+        1e-4);
+  }
+}
+
+TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
+  static constexpr float PAN_VALUE = -0.5;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
+  panNode->setPanParam(PAN_VALUE);
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
+    (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;
+  }
+
+  auto resultBus = panNode->processNode(bus, FRAMES_TO_PROCESS);
+  // x = -0.5 + 1 = 0.5
+  // gainL = cos(x * (π / 2)) = cos(0.5 * (π / 2)) = 0.7071067811865476
+  // gainR = sin(x * (π / 2)) = sin(0.5 * (π / 2)) = 0.7071067811865476
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelLeft))[i],
+        (i + 1) + (i + 1) * 0.7071067811865476,
+        1e-4);
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelRight))[i],
+        (i + 1) * 0.7071067811865476,
+        1e-4);
+  }
+}
+
+TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
+  static constexpr float PAN_VALUE = 0.75;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
+  panNode->setPanParam(PAN_VALUE);
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    (*bus->getChannelByType(AudioBus::ChannelLeft))[i] = i + 1;
+    (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;
+  }
+
+  auto resultBus = panNode->processNode(bus, FRAMES_TO_PROCESS);
+  // x = 0.75
+  // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
+  // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelLeft))[i],
+        (i + 1) * 0.38268343236508984,
+        1e-4);
+    EXPECT_NEAR(
+        (*resultBus->getChannelByType(AudioBus::ChannelRight))[i],
+        (i + 1) + (i + 1) * 0.9238795325112867,
+        1e-4);
+  }
+}