react-native-audio-api 0.8.3 → 0.9.0

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

@@ -24,8 +24,14 @@ file(GLOB_RECURSE RNAUDIOAPI_SRC
   "${ROOT}/node_modules/react-native-audio-api/android/src/main/cpp/audioapi/android/core/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);
+  }
+}

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -1,9 +1,13 @@
 #import <React/RCTBridge+Private.h>
 #import <audioapi/ios/AudioAPIModule.h>
+
+#import <audioapi/core/utils/worklets/SafeIncludes.h>
+#if RN_AUDIO_API_ENABLE_WORKLETS
+#import <worklets/apple/WorkletsModule.h>
+#endif
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvoker.h>
 #endif // RCT_NEW_ARCH_ENABLED
-
 #import <audioapi/AudioAPIModuleInstaller.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
@@ -14,6 +18,7 @@
 
 using namespace audioapi;
 using namespace facebook::react;
+using namespace worklets;
 
 @interface RCTBridge (JSIRuntime)
 - (void *)runtime;
@@ -30,10 +35,12 @@ using namespace facebook::react;
 
 @implementation AudioAPIModule {
   std::shared_ptr<AudioEventHandlerRegistry> _eventHandler;
+  std::weak_ptr<WorkletsModuleProxy> weakWorkletsModuleProxy_;
 }
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 @synthesize callInvoker = _callInvoker;
+@synthesize moduleRegistry = _moduleRegistry;
 #endif // defined(RCT_NEW_ARCH_ENABLED)
 
 RCT_EXPORT_MODULE(AudioAPIModule);
@@ -69,12 +76,32 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 
   _eventHandler = std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
 
-  self.audioSessionManager = [[AudioSessionManager alloc] init];
-  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
-  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
-  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  WorkletsModule *workletsModule = [_moduleRegistry moduleForName:"WorkletsModule"];
+
+  if (!workletsModule) {
+    NSLog(@"WorkletsModule not found in module registry");
+  }
+
+  auto workletsModuleProxy = [workletsModule getWorkletsModuleProxy];
+
+  if (!workletsModuleProxy) {
+    NSLog(@"WorkletsModuleProxy not available");
+  }
+
+  weakWorkletsModuleProxy_ = workletsModuleProxy;
+
+  auto uiWorkletRuntime = workletsModuleProxy->getUIWorkletRuntime();
+
+  if (!uiWorkletRuntime) {
+    NSLog(@"UI Worklet Runtime not available");
+  }
 
+  // Get the actual JSI Runtime reference
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
+#else
   audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
+#endif
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
   return @true;

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -1,6 +1,6 @@
 #import <AVFoundation/AVFoundation.h>
 
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/ios/core/IOSAudioPlayer.h>
 #include <audioapi/ios/system/AudioEngine.h>

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -1,6 +1,6 @@
 #import <AVFoundation/AVFoundation.h>
 
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>

package/lib/commonjs/api.js

@@ -69,6 +69,12 @@ Object.defineProperty(exports, "AudioScheduledSourceNode", {
     return _AudioScheduledSourceNode.default;
   }
 });
+Object.defineProperty(exports, "AudioWorkletRuntime", {
+  enumerable: true,
+  get: function () {
+    return _types.AudioWorkletRuntime;
+  }
+});
 Object.defineProperty(exports, "BaseAudioContext", {
   enumerable: true,
   get: function () {
@@ -99,6 +105,12 @@ Object.defineProperty(exports, "ChannelInterpretation", {
     return _types.ChannelInterpretation;
   }
 });
+Object.defineProperty(exports, "ConstantSourceNode", {
+  enumerable: true,
+  get: function () {
+    return _ConstantSourceNode.default;
+  }
+});
 Object.defineProperty(exports, "ContextState", {
   enumerable: true,
   get: function () {
@@ -189,13 +201,34 @@ Object.defineProperty(exports, "WindowType", {
     return _types.WindowType;
   }
 });
+Object.defineProperty(exports, "WorkletNode", {
+  enumerable: true,
+  get: function () {
+    return _WorkletNode.default;
+  }
+});
+Object.defineProperty(exports, "WorkletProcessingNode", {
+  enumerable: true,
+  get: function () {
+    return _WorkletProcessingNode.default;
+  }
+});
+Object.defineProperty(exports, "WorkletSourceNode", {
+  enumerable: true,
+  get: function () {
+    return _WorkletSourceNode.default;
+  }
+});
 Object.defineProperty(exports, "useSystemVolume", {
   enumerable: true,
   get: function () {
-    return _useSytemVolume.default;
+    return _useSystemVolume.default;
   }
 });
 var _specs = require("./specs");
+var _WorkletNode = _interopRequireDefault(require("./core/WorkletNode"));
+var _WorkletSourceNode = _interopRequireDefault(require("./core/WorkletSourceNode"));
+var _WorkletProcessingNode = _interopRequireDefault(require("./core/WorkletProcessingNode"));
 var _RecorderAdapterNode = _interopRequireDefault(require("./core/RecorderAdapterNode"));
 var _AudioBuffer = _interopRequireDefault(require("./core/AudioBuffer"));
 var _AudioBufferSourceNode = _interopRequireDefault(require("./core/AudioBufferSourceNode"));
@@ -214,8 +247,9 @@ var _OscillatorNode = _interopRequireDefault(require("./core/OscillatorNode"));
 var _StereoPannerNode = _interopRequireDefault(require("./core/StereoPannerNode"));
 var _AudioRecorder = _interopRequireDefault(require("./core/AudioRecorder"));
 var _StreamerNode = _interopRequireDefault(require("./core/StreamerNode"));
+var _ConstantSourceNode = _interopRequireDefault(require("./core/ConstantSourceNode"));
 var _system = _interopRequireDefault(require("./system"));
-var _useSytemVolume = _interopRequireDefault(require("./hooks/useSytemVolume"));
+var _useSystemVolume = _interopRequireDefault(require("./hooks/useSystemVolume"));
 var _types = require("./types");
 var _errors = require("./errors");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/commonjs/api.js.map

@@ -1 +1 @@
-{"version":3,"names":["_specs","require","_RecorderAdapterNode","_interopRequireDefault","_AudioBuffer","_AudioBufferSourceNode","_AudioBufferQueueSourceNode","_AudioContext","_OfflineAudioContext","_AudioDestinationNode","_AudioNode","_AnalyserNode","_AudioParam","_AudioScheduledSourceNode","_BaseAudioContext","_BiquadFilterNode","_GainNode","_OscillatorNode","_StereoPannerNode","_AudioRecorder","_StreamerNode","_system","_useSytemVolume","_types","_errors","e","__esModule","default","global","createAudioContext","createOfflineAudioContext","createAudioRecorder","AudioEventEmitter","NativeAudioAPIModule","Error","install"],"sourceRoot":"../../src","sources":["api.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AA0CA,IAAAC,oBAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,YAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,sBAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,2BAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,aAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,oBAAA,GAAAL,sBAAA,CAAAF,OAAA;AACA,IAAAQ,qBAAA,GAAAN,sBAAA,CAAAF,OAAA;AACA,IAAAS,UAAA,GAAAP,sBAAA,CAAAF,OAAA;AACA,IAAAU,aAAA,GAAAR,sBAAA,CAAAF,OAAA;AACA,IAAAW,WAAA,GAAAT,sBAAA,CAAAF,OAAA;AACA,IAAAY,yBAAA,GAAAV,sBAAA,CAAAF,OAAA;AACA,IAAAa,iBAAA,GAAAX,sBAAA,CAAAF,OAAA;AACA,IAAAc,iBAAA,GAAAZ,sBAAA,CAAAF,OAAA;AACA,IAAAe,SAAA,GAAAb,sBAAA,CAAAF,OAAA;AACA,IAAAgB,eAAA,GAAAd,sBAAA,CAAAF,OAAA;AACA,IAAAiB,iBAAA,GAAAf,sBAAA,CAAAF,OAAA;AACA,IAAAkB,cAAA,GAAAhB,sBAAA,CAAAF,OAAA;AACA,IAAAmB,aAAA,GAAAjB,sBAAA,CAAAF,OAAA;AACA,IAAAoB,OAAA,GAAAlB,sBAAA,CAAAF,OAAA;AACA,IAAAqB,eAAA,GAAAnB,sBAAA,CAAAF,OAAA;AAEA,IAAAsB,MAAA,GAAAtB,OAAA;AAUA,IAAAuB,OAAA,GAAAvB,OAAA;AAMkB,SAAAE,uBAAAsB,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAtElB;;AAgBA;;AAEA,IACEG,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,IACxCF,MAAM,CAACG,mBAAmB,IAAI,IAAI,IAClCH,MAAM,CAACI,iBAAiB,IAAI,IAAI,EAChC;EACA,IAAI,CAACC,2BAAoB,EAAE;IACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;EACH;EAEAD,2BAAoB,CAACE,OAAO,CAAC,CAAC;AAChC","ignoreList":[]}
+{"version":3,"names":["_specs","require","_WorkletNode","_interopRequireDefault","_WorkletSourceNode","_WorkletProcessingNode","_RecorderAdapterNode","_AudioBuffer","_AudioBufferSourceNode","_AudioBufferQueueSourceNode","_AudioContext","_OfflineAudioContext","_AudioDestinationNode","_AudioNode","_AnalyserNode","_AudioParam","_AudioScheduledSourceNode","_BaseAudioContext","_BiquadFilterNode","_GainNode","_OscillatorNode","_StereoPannerNode","_AudioRecorder","_StreamerNode","_ConstantSourceNode","_system","_useSystemVolume","_types","_errors","e","__esModule","default","global","createAudioContext","createOfflineAudioContext","createAudioRecorder","AudioEventEmitter","NativeAudioAPIModule","Error","install"],"sourceRoot":"../../src","sources":["api.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AA8CA,IAAAC,YAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,kBAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,sBAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,oBAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,YAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,sBAAA,GAAAL,sBAAA,CAAAF,OAAA;AACA,IAAAQ,2BAAA,GAAAN,sBAAA,CAAAF,OAAA;AACA,IAAAS,aAAA,GAAAP,sBAAA,CAAAF,OAAA;AACA,IAAAU,oBAAA,GAAAR,sBAAA,CAAAF,OAAA;AACA,IAAAW,qBAAA,GAAAT,sBAAA,CAAAF,OAAA;AACA,IAAAY,UAAA,GAAAV,sBAAA,CAAAF,OAAA;AACA,IAAAa,aAAA,GAAAX,sBAAA,CAAAF,OAAA;AACA,IAAAc,WAAA,GAAAZ,sBAAA,CAAAF,OAAA;AACA,IAAAe,yBAAA,GAAAb,sBAAA,CAAAF,OAAA;AACA,IAAAgB,iBAAA,GAAAd,sBAAA,CAAAF,OAAA;AACA,IAAAiB,iBAAA,GAAAf,sBAAA,CAAAF,OAAA;AACA,IAAAkB,SAAA,GAAAhB,sBAAA,CAAAF,OAAA;AACA,IAAAmB,eAAA,GAAAjB,sBAAA,CAAAF,OAAA;AACA,IAAAoB,iBAAA,GAAAlB,sBAAA,CAAAF,OAAA;AACA,IAAAqB,cAAA,GAAAnB,sBAAA,CAAAF,OAAA;AACA,IAAAsB,aAAA,GAAApB,sBAAA,CAAAF,OAAA;AACA,IAAAuB,mBAAA,GAAArB,sBAAA,CAAAF,OAAA;AACA,IAAAwB,OAAA,GAAAtB,sBAAA,CAAAF,OAAA;AACA,IAAAyB,gBAAA,GAAAvB,sBAAA,CAAAF,OAAA;AAEA,IAAA0B,MAAA,GAAA1B,OAAA;AAWA,IAAA2B,OAAA,GAAA3B,OAAA;AAMkB,SAAAE,uBAAA0B,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AA/ElB;;AAoBA;;AAEA,IACEG,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,IACxCF,MAAM,CAACG,mBAAmB,IAAI,IAAI,IAClCH,MAAM,CAACI,iBAAiB,IAAI,IAAI,EAChC;EACA,IAAI,CAACC,2BAAoB,EAAE;IACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;EACH;EAEAD,2BAAoB,CAACE,OAAO,CAAC,CAAC;AAChC","ignoreList":[]}

package/lib/commonjs/api.web.js

@@ -18,6 +18,7 @@ var _exportNames = {
   GainNode: true,
   OscillatorNode: true,
   StereoPannerNode: true,
+  ConstantSourceNode: true,
   OscillatorType: true,
   BiquadFilterType: true,
   ChannelCountMode: true,
@@ -109,6 +110,12 @@ Object.defineProperty(exports, "ChannelInterpretation", {
     return _types.ChannelInterpretation;
   }
 });
+Object.defineProperty(exports, "ConstantSourceNode", {
+  enumerable: true,
+  get: function () {
+    return _ConstantSourceNode.default;
+  }
+});
 Object.defineProperty(exports, "ContextState", {
   enumerable: true,
   get: function () {
@@ -201,6 +208,7 @@ var _BiquadFilterNode = _interopRequireDefault(require("./web-core/BiquadFilterN
 var _GainNode = _interopRequireDefault(require("./web-core/GainNode"));
 var _OscillatorNode = _interopRequireDefault(require("./web-core/OscillatorNode"));
 var _StereoPannerNode = _interopRequireDefault(require("./web-core/StereoPannerNode"));
+var _ConstantSourceNode = _interopRequireDefault(require("./web-core/ConstantSourceNode"));
 var _custom = require("./web-core/custom");
 Object.keys(_custom).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/commonjs/api.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["_AudioBuffer","_interopRequireDefault","require","_AudioBufferSourceNode","_AudioContext","_OfflineAudioContext","_AudioDestinationNode","_AudioNode","_AnalyserNode","_AudioParam","_AudioScheduledSourceNode","_BaseAudioContext","_BiquadFilterNode","_GainNode","_OscillatorNode","_StereoPannerNode","_custom","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_types","_errors","e","__esModule","default"],"sourceRoot":"../../src","sources":["api.web.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,aAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,oBAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,qBAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,UAAA,GAAAN,sBAAA,CAAAC,OAAA;AACA,IAAAM,aAAA,GAAAP,sBAAA,CAAAC,OAAA;AACA,IAAAO,WAAA,GAAAR,sBAAA,CAAAC,OAAA;AACA,IAAAQ,yBAAA,GAAAT,sBAAA,CAAAC,OAAA;AACA,IAAAS,iBAAA,GAAAV,sBAAA,CAAAC,OAAA;AACA,IAAAU,iBAAA,GAAAX,sBAAA,CAAAC,OAAA;AACA,IAAAW,SAAA,GAAAZ,sBAAA,CAAAC,OAAA;AACA,IAAAY,eAAA,GAAAb,sBAAA,CAAAC,OAAA;AACA,IAAAa,iBAAA,GAAAd,sBAAA,CAAAC,OAAA;AAEA,IAAAc,OAAA,GAAAd,OAAA;AAAAe,MAAA,CAAAC,IAAA,CAAAF,OAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,OAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,OAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,MAAA,GAAA3B,OAAA;AAUA,IAAA4B,OAAA,GAAA5B,OAAA;AAMkB,SAAAD,uBAAA8B,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}
+{"version":3,"names":["_AudioBuffer","_interopRequireDefault","require","_AudioBufferSourceNode","_AudioContext","_OfflineAudioContext","_AudioDestinationNode","_AudioNode","_AnalyserNode","_AudioParam","_AudioScheduledSourceNode","_BaseAudioContext","_BiquadFilterNode","_GainNode","_OscillatorNode","_StereoPannerNode","_ConstantSourceNode","_custom","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_types","_errors","e","__esModule","default"],"sourceRoot":"../../src","sources":["api.web.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,aAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,oBAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,qBAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,UAAA,GAAAN,sBAAA,CAAAC,OAAA;AACA,IAAAM,aAAA,GAAAP,sBAAA,CAAAC,OAAA;AACA,IAAAO,WAAA,GAAAR,sBAAA,CAAAC,OAAA;AACA,IAAAQ,yBAAA,GAAAT,sBAAA,CAAAC,OAAA;AACA,IAAAS,iBAAA,GAAAV,sBAAA,CAAAC,OAAA;AACA,IAAAU,iBAAA,GAAAX,sBAAA,CAAAC,OAAA;AACA,IAAAW,SAAA,GAAAZ,sBAAA,CAAAC,OAAA;AACA,IAAAY,eAAA,GAAAb,sBAAA,CAAAC,OAAA;AACA,IAAAa,iBAAA,GAAAd,sBAAA,CAAAC,OAAA;AACA,IAAAc,mBAAA,GAAAf,sBAAA,CAAAC,OAAA;AAEA,IAAAe,OAAA,GAAAf,OAAA;AAAAgB,MAAA,CAAAC,IAAA,CAAAF,OAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,OAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,OAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,MAAA,GAAA5B,OAAA;AAUA,IAAA6B,OAAA,GAAA7B,OAAA;AAMkB,SAAAD,uBAAA+B,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}