react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.3

package/common/cpp/audioapi/utils/CircularOverflowableAudioArray.cpp

@@ -1,16 +1,14 @@
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <algorithm>
 #include <type_traits>
 
 namespace audioapi {
 
-CircularOverflowableAudioArray::CircularOverflowableAudioArray(
-    size_t
-        size) noexcept(std::is_nothrow_constructible<AudioArray, size_t>::value)
+CircularOverflowableAudioArray::CircularOverflowableAudioArray(size_t size) noexcept(
+    std::is_nothrow_constructible<AudioArray, size_t>::value)
     : AudioArray(size) {}
 
-void CircularOverflowableAudioArray::write(
-    const float *data,
-    const size_t size) {
+void CircularOverflowableAudioArray::write(const float *data, const size_t size) {
   size_t writeIndex = vWriteIndex_.load(std::memory_order_relaxed);
 
   if (size > size_) {
@@ -43,8 +41,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
   size_t partSize = size_ - vReadIndex_;
   if (readSize > partSize) {
     std::memcpy(output, data_ + vReadIndex_, partSize * sizeof(float));
-    std::memcpy(
-        output + partSize, data_, (readSize - partSize) * sizeof(float));
+    std::memcpy(output + partSize, data_, (readSize - partSize) * sizeof(float));
   } else {
     std::memcpy(output, data_ + vReadIndex_, readSize * sizeof(float));
   }
@@ -54,8 +51,7 @@ size_t CircularOverflowableAudioArray::read(float *output, size_t size) const {
 }
 
 size_t CircularOverflowableAudioArray::getAvailableSpace() const {
-  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) %
-      size_;
+  return (size_ + vWriteIndex_.load(std::memory_order_relaxed) - vReadIndex_) % size_;
 }
 
 } // namespace audioapi

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

@@ -2,9 +2,9 @@
 #pragma once
 
 #include <audioapi/utils/AudioArray.h>
-#include <stdexcept>
 #include <atomic>
 #include <mutex>
+#include <stdexcept>
 
 namespace audioapi {
 
@@ -32,7 +32,7 @@ class CircularOverflowableAudioArray : public AudioArray {
   size_t read(float *output, size_t size) const;
 
  private:
-  std::atomic<size_t> vWriteIndex_ = { 0 };
+  std::atomic<size_t> vWriteIndex_ = {0};
   mutable size_t vReadIndex_ = 0; // it is only used after acquiring readLock_
   mutable std::mutex readLock_;
 

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

@@ -0,0 +1,286 @@
+#pragma once
+
+#include <utility>
+#include <string>
+#include <stdexcept>
+#include <functional>
+#include <new>
+#include <type_traits>
+
+struct NoneType {};
+inline constexpr NoneType None{};
+
+/// @brief A Result type that can represent either a success (Ok) or an error (Err).
+/// @tparam T value type for success
+/// @tparam E error type for failure
+/// @note Specializations for void T and/or void E are not provided. Use NoneType instead.
+/// Design inspired by Rust's Result type.
+/// https://doc.rust-lang.org/std/result/
+///
+/// @example
+/// /// Creating an Ok Result and mapping its error:
+/// Result<int, std::string> res = Result<int, int>::Err(404)
+///   .map_err<std::string>([](auto code){
+///      return "Error code: " + std::to_string(code);
+///    });
+///
+template<typename T = NoneType, typename E = NoneType>
+class Result {
+  struct OkTag {};
+  struct ErrTag {};
+
+  explicit Result(OkTag, const T& value) : ok_value(value), is_ok_(true) {}
+  explicit Result(OkTag, T&& value) : ok_value(std::move(value)), is_ok_(true) {}
+  explicit Result(ErrTag, const E& error) : err_value(error), is_ok_(false) {}
+  explicit Result(ErrTag, E&& error) : err_value(std::move(error)), is_ok_(false) {}
+
+ public:
+  Result(const Result<T, E>& other) {
+    is_ok_ = other.is_ok_;
+    if (is_ok_) {
+      new (&ok_value) T(other.ok_value);
+    } else {
+      new (&err_value) E(other.err_value);
+    }
+  }
+
+  Result(Result<T, E>&& other) noexcept(std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_constructible_v<E>) {
+    is_ok_ = other.is_ok_;
+    if (is_ok_) {
+      new (&ok_value) T(std::move(other.ok_value));
+    } else {
+      new (&err_value) E(std::move(other.err_value));
+    }
+  }
+
+  Result& operator=(const Result& other) {
+    if (this == &other) return *this;
+    if (is_ok_ == other.is_ok_) {
+      if (is_ok_) ok_value = other.ok_value;
+      else err_value = other.err_value;
+    } else {
+      if (is_ok_) {
+        ok_value.~T();
+        new (&err_value) E(other.err_value);
+        is_ok_ = false;
+      } else {
+        err_value.~E();
+        new (&ok_value) T(other.ok_value);
+        is_ok_ = true;
+      }
+    }
+    return *this;
+  }
+
+  Result& operator=(Result&& other) noexcept(std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_assignable_v<E> && std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_constructible_v<E>) {
+    if (this == &other) return *this;
+    if (is_ok_ == other.is_ok_) {
+      if (is_ok_) ok_value = std::move(other.ok_value);
+      else err_value = std::move(other.err_value);
+    } else {
+      if (is_ok_) {
+        ok_value.~T();
+        new (&err_value) E(std::move(other.err_value));
+        is_ok_ = false;
+      } else {
+        err_value.~E();
+        new (&ok_value) T(std::move(other.ok_value));
+        is_ok_ = true;
+      }
+    }
+    return *this;
+  }
+
+  ~Result() {
+    if (is_ok_) {
+      ok_value.~T();
+    } else {
+      err_value.~E();
+    }
+  }
+
+  /// @brief Creates a success Result.
+  static Result<T, E> Ok(const T& value) {
+    return Result<T, E>(OkTag{}, value);
+  }
+
+  /// @brief Creates a success Result from an rvalue.
+  static Result<T, E> Ok(T&& value) {
+     return Result<T, E>(OkTag{}, std::move(value));
+  }
+
+  /// @brief Creates an error Result.
+  static Result<T, E> Err(const E& error) {
+    return Result<T, E>(ErrTag{}, error);
+  }
+
+  /// @brief Creates an error Result from an rvalue.
+  static Result<T, E> Err(E&& error) {
+    return Result<T, E>(ErrTag{}, std::move(error));
+  }
+
+  /// @brief Returns true if the result is Ok.
+  [[nodiscard]] bool is_ok() const {
+    return is_ok_;
+  }
+
+  /// @brief Returns true if the result is Err.
+  [[nodiscard]] bool is_err() const {
+    return !is_ok_;
+  }
+
+  /// @brief Returns the contained Ok value, consuming the Result.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] T expect(const std::string& msg) && {
+    if (!is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] const T& expect(const std::string& msg) const & {
+    if (!is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Ok value, consuming the Result.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] T unwrap() && {
+    if (!is_ok_) {
+      throw std::runtime_error("Called unwrap on an Err value");
+    }
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value.
+  /// @throws std::runtime_error if the value is an Err.
+  [[nodiscard]] const T& unwrap() const & {
+    if (!is_ok_) {
+      throw std::runtime_error("Called unwrap on an Err value");
+    }
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Ok value or a default. Consumes self.
+  [[nodiscard]] T unwrap_or(T&& default_value) && {
+    if (is_ok_) {
+      return std::move(ok_value);
+    }
+    return std::move(default_value);
+  }
+
+  /// @brief Returns the contained Ok value or computes it from a closure. Consumes self.
+  [[nodiscard]] T unwrap_or_else(const std::function<T(E&&)>& func) && {
+    if (is_ok_) {
+      return std::move(ok_value);
+    }
+    return func(std::move(err_value));
+  }
+
+  /// @brief Returns the contained Ok value without checking. UB if Err.
+  [[nodiscard]] T unwrap_unchecked() && noexcept {
+    return std::move(ok_value);
+  }
+
+  /// @brief Returns the contained Ok value without checking. UB if Err.
+  [[nodiscard]] const T& unwrap_unchecked() const & noexcept {
+    return ok_value;
+  }
+
+  /// @brief Returns the contained Err value, consuming the Result.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] E unwrap_err() && {
+    if (is_ok_) {
+      throw std::runtime_error("Called unwrap_err on an Ok value");
+    }
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] const E& unwrap_err() const & {
+    if (is_ok_) {
+      throw std::runtime_error("Called unwrap_err on an Ok value");
+    }
+    return err_value;
+  }
+
+  /// @brief Returns the contained Err value, consuming the Result.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] E expect_err(const std::string& msg) && {
+    if (is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value.
+  /// @throws std::runtime_error if the value is Ok.
+  [[nodiscard]] const E& expect_err(const std::string& msg) const & {
+    if (is_ok_) {
+      throw std::runtime_error(msg);
+    }
+    return err_value;
+  }
+
+  /// @brief Returns the contained Err value without checking. UB if Ok.
+  [[nodiscard]] E unwrap_err_unchecked() && noexcept {
+    return std::move(err_value);
+  }
+
+  /// @brief Returns the contained Err value without checking. UB if Ok.
+  [[nodiscard]] const E& unwrap_err_unchecked() const & noexcept {
+    return err_value;
+  }
+
+  /// @brief Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value.
+  template<typename TNew>
+  [[nodiscard]] std::enable_if_t<!std::is_void_v<T>, Result<TNew, E>> map(std::function<TNew(T&&)> ok_func) && {
+    if (is_ok_) {
+      return Result<TNew, E>::Ok(ok_func(std::move(ok_value)));
+    } else {
+      return Result<TNew, E>::Err(std::move(err_value));
+    }
+  }
+
+  /// @brief Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value.
+  template<typename ENew>
+  [[nodiscard]] std::enable_if_t<!std::is_void_v<ENew>, Result<T, ENew>> map_err(std::function<ENew(E&&)> err_func) && {
+    if (is_ok_) {
+      return Result<T, ENew>::Ok(std::move(ok_value));
+    } else {
+      return Result<T, ENew>::Err(err_func(std::move(err_value)));
+    }
+  }
+
+  /// @brief Returns the provided default (if Err), or applies a function to the contained value (if Ok).
+  template<typename TNew>
+  [[nodiscard]] std::enable_if_t<!std::is_void_v<TNew>, TNew> map_or(std::function<TNew(T&&)> ok_func, TNew&& default_value) && {
+    if (is_ok_) {
+      return ok_func(std::move(ok_value));
+    } else {
+      return std::move(default_value);
+    }
+  }
+
+  /// @brief Maps a Result<T, E> to U by applying fallback function default to a contained Err value, or function f to a contained Ok value.
+  template <typename TNew>
+  [[nodiscard]] std::enable_if_t<!std::is_void_v<TNew>, TNew> map_or_else(std::function<TNew(T&&)> ok_func, std::function<TNew(E&&)> err_func) && {
+    if (is_ok_) {
+      return ok_func(std::move(ok_value));
+    } else {
+      return err_func(std::move(err_value));
+    }
+  }
+
+ private:
+  union {
+    T ok_value;
+    E err_value;
+  };
+  bool is_ok_;
+};

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/audioapi/utils/UnitConversion.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace audioapi {
+
+static constexpr double KB_IN_BYTES = 1024.0;
+static constexpr double MB_IN_BYTES = KB_IN_BYTES * 1024.0;
+static constexpr double GB_IN_BYTES = MB_IN_BYTES * 1024.0;
+
+} // namespace audioapi

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
@@ -76,6 +81,7 @@ add_executable(
 add_compile_definitions(AUDIO_API_TEST_SUITE)
 add_compile_definitions(RN_AUDIO_API_ENABLE_WORKLETS=0)
 add_compile_definitions(RN_AUDIO_API_TEST=1)
+add_compile_definitions(RN_AUDIO_API_FFMPEG_DISABLED=1)
 
 target_link_libraries(tests
   rnaudioapi

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

@@ -3,12 +3,14 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+#include <vector>
 
 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;
 
@@ -119,8 +121,7 @@ TEST_F(AudioParamTest, SetTargetAtTime) {
 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});
+  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
 

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

@@ -0,0 +1,113 @@
+#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>
+#include <memory>
+
+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());
+}