react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-bfab178-20251107

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/tdrdi.h

@@ -119,7 +119,7 @@ typedef struct AV3DReferenceDisplay {
     uint8_t mantissa_ref_display_width;
 
     /**
-     * Tthe exponent part of the reference viewing distance of the n-th reference display.
+     * The exponent part of the reference viewing distance of the n-th reference display.
      */
     uint8_t exponent_ref_viewing_distance;
 

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/tx.h

@@ -50,7 +50,7 @@ enum AVTXType {
 
     /**
      * Standard MDCT with a sample data type of float, double or int32_t,
-     * respecively. For the float and int32 variants, the scale type is
+     * respectively. For the float and int32 variants, the scale type is
      * 'float', while for the double variant, it's 'double'.
      * If scale is NULL, 1.0 will be used as a default.
      *

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/version.h

@@ -35,7 +35,7 @@
  * Useful to check and match library version in order to maintain
  * backward compatibility.
  *
- * The FFmpeg libraries follow a versioning sheme very similar to
+ * The FFmpeg libraries follow a versioning scheme very similar to
  * Semantic Versioning (http://semver.org/)
  * The difference is that the component called PATCH is called MICRO in FFmpeg
  * and its value is reset to 100 instead of 0 to keep it above or equal to 100.
@@ -72,14 +72,14 @@
 /**
  * @defgroup lavu_ver Version and Build diagnostics
  *
- * Macros and function useful to check at compiletime and at runtime
+ * Macros and function useful to check at compile time and at runtime
  * which version of libavutil is in use.
  *
  * @{
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  60
-#define LIBAVUTIL_VERSION_MINOR   6
+#define LIBAVUTIL_VERSION_MINOR   8
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

package/common/cpp/audioapi/external/ffmpeg_include/libavutil/video_hint.h

@@ -80,7 +80,7 @@ av_video_hint_get_rect(const AVVideoHint *hints, size_t idx) {
  * The side data contains a list of rectangles for the portions of the frame
  * which changed from the last encoded one (and the remainder are assumed to be
  * changed), or, alternately (depending on the type parameter) the unchanged
- * ones (and the remanining ones are those which changed).
+ * ones (and the remaining ones are those which changed).
  * Macroblocks will thus be hinted either to be P_SKIP-ped or go through the
  * regular encoding procedure.
  *

package/common/cpp/audioapi/external/ffmpeg_include/libswresample/swresample.h

@@ -337,7 +337,7 @@ int64_t swr_next_pts(struct SwrContext *s, int64_t pts);
  * @}
  *
  * @name Low-level option setting functions
- * These functons provide a means to set low-level options that is not possible
+ * These functions provide a means to set low-level options that is not possible
  * with the AVOption API.
  * @{
  */

package/common/cpp/audioapi/external/ffmpeg_include/libswresample/version.h

@@ -30,7 +30,7 @@
 
 #include "version_major.h"
 
-#define LIBSWRESAMPLE_VERSION_MINOR   0
+#define LIBSWRESAMPLE_VERSION_MINOR   1
 #define LIBSWRESAMPLE_VERSION_MICRO 100
 
 #define LIBSWRESAMPLE_VERSION_INT  AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \

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

@@ -277,8 +277,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
 
   constexpr size_t buffer_size = 4096;
-  auto io_buffer = std::unique_ptr<uint8_t, decltype(&av_free)>(
-      static_cast<uint8_t *>(av_malloc(buffer_size)), &av_free);
+  uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
   if (io_buffer == nullptr) {
     return nullptr;
   }
@@ -286,7 +285,7 @@ decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
   auto avio_ctx =
       std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
           avio_alloc_context(
-              io_buffer.get(),
+              io_buffer,
               buffer_size,
               0,
               &io_ctx,

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

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

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

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

@@ -34,6 +34,34 @@ AudioBus::AudioBus(const AudioBus &other) {
   }
 }
 
+AudioBus::AudioBus(AudioBus &&other) noexcept
+    : channels_(std::move(other.channels_)),
+      numberOfChannels_(other.numberOfChannels_),
+      sampleRate_(other.sampleRate_),
+      size_(other.size_) {
+  other.numberOfChannels_ = 0;
+  other.sampleRate_ = 0.0f;
+  other.size_ = 0;
+}
+
+AudioBus &AudioBus::operator=(const AudioBus &other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  numberOfChannels_ = other.numberOfChannels_;
+  sampleRate_ = other.sampleRate_;
+  size_ = other.size_;
+
+  createChannels();
+
+  for (int i = 0; i < numberOfChannels_; i += 1) {
+    channels_[i] = std::make_shared<AudioArray>(*other.channels_[i]);
+  }
+
+  return *this;
+}
+
 AudioBus::~AudioBus() {
   channels_.clear();
 }

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

@@ -24,8 +24,11 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
+  explicit AudioBus() = default;
   explicit AudioBus(size_t size, int numberOfChannels, float sampleRate);
   AudioBus(const AudioBus &other);
+  AudioBus(AudioBus &&other) noexcept;
+  AudioBus& operator=(const AudioBus& other);
 
   ~AudioBus();
 

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

@@ -20,6 +20,11 @@ class ThreadPool {
   struct TaskEvent { audioapi::move_only_function<void()> task; };
   using Event = std::variant<TaskEvent, StopEvent>;
 
+  struct Cntrl {
+    std::atomic<bool> waitingForTasks{false};
+    std::atomic<size_t> tasksScheduled{0};
+  };
+
   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:
@@ -38,8 +43,30 @@ public:
       workerSenders.emplace_back(std::move(workerSender));
     }
     loadBalancerThread = std::thread(&ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+    controlBlock_ = std::make_unique<Cntrl>();
+  }
+  ThreadPool(const ThreadPool&) = delete;
+  ThreadPool& operator=(const ThreadPool&) = delete;
+  ThreadPool(ThreadPool&& other):
+    loadBalancerThread(std::move(other.loadBalancerThread)),
+    workers(std::move(other.workers)),
+    loadBalancerSender(std::move(other.loadBalancerSender)),
+    controlBlock_(std::move(other.controlBlock_)) {}
+  ThreadPool& operator=(ThreadPool&& other) {
+    if (this != &other) {
+      loadBalancerThread = std::move(other.loadBalancerThread);
+      workers = std::move(other.workers);
+      loadBalancerSender = std::move(other.loadBalancerSender);
+      controlBlock_ = std::move(other.controlBlock_);
+      other.movedFrom_ = true;
+    }
+    return *this;
   }
+
   ~ThreadPool() {
+    if (movedFrom_) {
+      return;
+    }
     loadBalancerSender.send(StopEvent{});
     loadBalancerThread.join();
     for (auto& worker : workers) {
@@ -59,16 +86,47 @@ public:
   /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only.
   template<typename Func, typename ... Args, typename = std::enable_if_t<std::is_invocable_r_v<void, Func, Args...>>>
   void schedule(Func &&task, Args &&... args) noexcept {
-    auto boundTask = [f = std::forward<Func>(task), ...capturedArgs = std::forward<Args>(args)]() mutable {
+    controlBlock_->tasksScheduled.fetch_add(1, std::memory_order_release);
+
+    /// We know that lifetime of each worker thus spsc thus lambda is strongly bounded by ThreadPool lifetime
+    /// so we can safely capture control block pointer unsafely here
+    Cntrl *cntrl = controlBlock_.get();
+    auto boundTask = [cntrl, f= std::forward<Func>(task), ...capturedArgs = std::forward<Args>(args)]() mutable {
       f(std::forward<Args>(capturedArgs)...);
+      size_t left = cntrl->tasksScheduled.fetch_sub(1, std::memory_order_acq_rel) - 1;
+      if (left == 0) {
+        cntrl->waitingForTasks.store(false, std::memory_order_release);
+        cntrl->waitingForTasks.notify_one();
+      }
     };
     loadBalancerSender.send(TaskEvent{audioapi::move_only_function<void()>(std::move(boundTask))});
   }
 
+  /// @brief Waits for all scheduled tasks to complete
+  void wait() {
+    /// This logic might seem incorrect at first glance
+    /// Main principle for this is that there is only one thread scheduling tasks
+    /// If he is waiting for the tasks he CANNOT schedule new tasks so we can assume partial
+    /// synchronization here.
+    /// We first store true so if any task finishes at this moment he will flip it
+    /// Then we check if there are any tasks scheduled
+    /// If there are none we can return immediately
+    /// If there are some we wait until the last task flips the flag to false
+    controlBlock_->waitingForTasks.store(true, std::memory_order_release);
+    if (controlBlock_->tasksScheduled.load(std::memory_order_acquire) == 0) {
+      controlBlock_->waitingForTasks.store(false, std::memory_order_release);
+      return;
+    }
+    controlBlock_->waitingForTasks.wait(true, std::memory_order_acquire);
+    return;
+  }
+
 private:
   std::thread loadBalancerThread;
   std::vector<std::thread> workers;
   Sender loadBalancerSender;
+  std::unique_ptr<Cntrl> controlBlock_;
+  bool movedFrom_ = false;
 
   void workerThreadFunc(Receiver &&receiver) {
     Receiver localReceiver = std::move(receiver);

package/common/cpp/test/CMakeLists.txt

@@ -12,41 +12,44 @@ FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/3983f67e32fb3e9294487b9d4f9586efa6e5d088.zip
 )
+
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
 
 enable_testing()
 
+set(REACT_NATIVE_AUDIO_API_DIR "${ROOT}/node_modules/react-native-audio-api")
+
 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/utils/AudioDecoder.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/*.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp"
 )
 
 # 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"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/AudioContext.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/effects/WorkletNode.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/sources/StreamerNode.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/sources/StreamerNode.h"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h"
 )
 
 file(GLOB_RECURSE RNAUDIOAPI_LIBS
   CONFIGURE_DEPENDS
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.c"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.h"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/*.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/*.h"
 )
 
 list(REMOVE_ITEM RNAUDIOAPI_LIBS
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.c"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.c"
 )
 
 add_library(rnaudioapi STATIC ${RNAUDIOAPI_SRC})
@@ -57,6 +60,8 @@ target_include_directories(rnaudioapi PUBLIC
   ${JSI_DIR}
   "${REACT_NATIVE_DIR}/ReactCommon"
   "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  ${gtest_SOURCE_DIR}/include
+  ${gmock_SOURCE_DIR}/include
 )
 
 target_include_directories(rnaudioapi_libs PUBLIC

package/common/cpp/test/src/AudioParamTest.cpp

@@ -8,7 +8,7 @@ using namespace audioapi;
 
 class AudioParamTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/AudioScheduledSourceTest.cpp

@@ -0,0 +1,134 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+using namespace audioapi;
+static constexpr int SAMPLE_RATE = 44100;
+static constexpr int RENDER_QUANTUM = 128;
+static constexpr double RENDER_QUANTUM_TIME =
+    static_cast<double>(RENDER_QUANTUM) / SAMPLE_RATE;
+
+class AudioScheduledSourceTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * SAMPLE_RATE, SAMPLE_RATE, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit TestableAudioScheduledSourceNode(BaseAudioContext *context)
+      : AudioScheduledSourceNode(context) {
+    isInitialized_ = true;
+  }
+
+  void updatePlaybackInfo(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess,
+      size_t &startOffset,
+      size_t &nonSilentFramesToProcess) {
+    AudioScheduledSourceNode::updatePlaybackInfo(
+        processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  }
+
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int)
+      override {
+    return nullptr;
+  }
+
+  PlaybackState getPlaybackState() const {
+    return playbackState_;
+  }
+
+  void playFrames(int frames) {
+    size_t startOffset = 0;
+    size_t nonSilentFramesToProcess = 0;
+    auto processingBus =
+        std::make_shared<AudioBus>(128, 2, static_cast<float>(SAMPLE_RATE));
+    updatePlaybackInfo(
+        processingBus, frames, startOffset, nonSilentFramesToProcess);
+    context_->getDestination()->renderAudio(processingBus, frames);
+  }
+};
+
+TEST_F(AudioScheduledSourceTest, IsUnscheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsPlayingStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::PLAYING);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::PLAYING);
+}
+
+TEST_F(AudioScheduledSourceTest, IsStopScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsFinishedStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  sourceNode.playFrames(1);
+  EXPECT_TRUE(sourceNode.isFinished());
+}

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class ConstantSourceTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/GainTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class GainTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/MockAudioEventHandlerRegistry.h

@@ -17,8 +17,8 @@ class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
   MOCK_METHOD(void, unregisterHandler,
               (const std::string &eventName, uint64_t listenerId), (override));
 
-  MOCK_METHOD(void, invokeHandlerWithEventBody,
-              (const std::string &eventName, const EventMap &body), (override));
-  MOCK_METHOD(void, invokeHandlerWithEventBody,
-              (const std::string &eventName, uint64_t listenerId, const EventMap &body), (override));
+  MOCK_METHOD2(invokeHandlerWithEventBody, void
+              (const std::string &eventName, const EventMap &body));
+  MOCK_METHOD3(invokeHandlerWithEventBody, void
+              (const std::string &eventName, uint64_t listenerId, const EventMap &body));
 };

package/common/cpp/test/src/OscillatorTest.cpp

@@ -8,7 +8,7 @@ using namespace audioapi;
 
 class OscillatorTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/StereoPannerTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class StereoPannerTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;