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

package/common/cpp/test/src/IIRFilterTest.cpp

@@ -14,14 +14,14 @@ using namespace audioapi;
 class IIRFilterTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<OfflineAudioContext> context;
+  std::shared_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
   static constexpr float nyquistFrequency = sampleRate / 2.0f;
   static constexpr float tolerance = 0.0001f;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(
+    context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 
@@ -99,7 +99,7 @@ TEST_F(IIRFilterTest, GetFrequencyResponse) {
   const std::vector<float> feedforward = {0.0050662636, 0.0101325272, 0.0050662636};
   const std::vector<float> feedback = {1.0632762845, -1.9797349456, 0.9367237155};
 
-  auto node = std::make_shared<IIRFilterNode>(context.get(), feedforward, feedback);
+  auto node = IIRFilterNode(context, feedforward, feedback);
 
   float frequency = 1000.0f;
   float normalizedFrequency = frequency / nyquistFrequency;
@@ -120,7 +120,7 @@ TEST_F(IIRFilterTest, GetFrequencyResponse) {
   std::vector<float> magResponseExpected(TestFrequencies.size());
   std::vector<float> phaseResponseExpected(TestFrequencies.size());
 
-  node->getFrequencyResponse(
+  node.getFrequencyResponse(
       TestFrequencies.data(),
       magResponseNode.data(),
       phaseResponseNode.data(),

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

@@ -10,12 +10,12 @@ using namespace audioapi;
 class OscillatorTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<OfflineAudioContext> context;
+  std::shared_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(
+    context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 };

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

@@ -12,19 +12,21 @@ using namespace audioapi;
 class StereoPannerTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<OfflineAudioContext> context;
+  std::shared_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(
+    context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+    context->initialize();
   }
 };
 
 class TestableStereoPannerNode : public StereoPannerNode {
  public:
-  explicit TestableStereoPannerNode(BaseAudioContext *context) : StereoPannerNode(context) {}
+  explicit TestableStereoPannerNode(std::shared_ptr<BaseAudioContext> context)
+      : StereoPannerNode(context) {}
 
   void setPanParam(float value) {
     getPanParam()->setValue(value);
@@ -45,15 +47,15 @@ TEST_F(StereoPannerTest, StereoPannerCanBeCreated) {
 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 panNode = TestableStereoPannerNode(context);
+  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);
+  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
@@ -72,8 +74,8 @@ TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
 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 panNode = TestableStereoPannerNode(context);
+  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) {
@@ -81,7 +83,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
     (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;
   }
 
-  auto resultBus = panNode->processNode(bus, FRAMES_TO_PROCESS);
+  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
@@ -100,8 +102,8 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
 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 panNode = TestableStereoPannerNode(context);
+  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) {
@@ -109,7 +111,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
     (*bus->getChannelByType(AudioBus::ChannelRight))[i] = i + 1;
   }
 
-  auto resultBus = panNode->processNode(bus, FRAMES_TO_PROCESS);
+  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

package/common/cpp/test/src/biquad/BiquadFilterTest.cpp

@@ -6,76 +6,76 @@
 namespace audioapi {
 
 void BiquadFilterTest::expectCoefficientsNear(
-    const std::shared_ptr<BiquadFilterNode> &biquadNode,
+    const BiquadFilterNode &biquadNode,
     const BiquadCoefficients &expected) {
-  EXPECT_NEAR(biquadNode->b0_, expected.b0, tolerance);
-  EXPECT_NEAR(biquadNode->b1_, expected.b1, tolerance);
-  EXPECT_NEAR(biquadNode->b2_, expected.b2, tolerance);
-  EXPECT_NEAR(biquadNode->a1_, expected.a1, tolerance);
-  EXPECT_NEAR(biquadNode->a2_, expected.a2, tolerance);
+  EXPECT_NEAR(biquadNode.b0_, expected.b0, tolerance);
+  EXPECT_NEAR(biquadNode.b1_, expected.b1, tolerance);
+  EXPECT_NEAR(biquadNode.b2_, expected.b2, tolerance);
+  EXPECT_NEAR(biquadNode.a1_, expected.a1, tolerance);
+  EXPECT_NEAR(biquadNode.a2_, expected.a2, tolerance);
 }
 
 void BiquadFilterTest::testLowpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setLowpassCoefficients(normalizedFrequency, Q);
+  node.setLowpassCoefficients(normalizedFrequency, Q);
   expectCoefficientsNear(node, calculateLowpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testHighpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setHighpassCoefficients(normalizedFrequency, Q);
+  node.setHighpassCoefficients(normalizedFrequency, Q);
   expectCoefficientsNear(node, calculateHighpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testBandpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setBandpassCoefficients(normalizedFrequency, Q);
+  node.setBandpassCoefficients(normalizedFrequency, Q);
   expectCoefficientsNear(node, calculateBandpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testNotch(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setNotchCoefficients(normalizedFrequency, Q);
+  node.setNotchCoefficients(normalizedFrequency, Q);
   expectCoefficientsNear(node, calculateNotchCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testAllpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setAllpassCoefficients(normalizedFrequency, Q);
+  node.setAllpassCoefficients(normalizedFrequency, Q);
   expectCoefficientsNear(node, calculateAllpassCoefficients(normalizedFrequency, Q));
 }
 
 void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setPeakingCoefficients(normalizedFrequency, Q, gain);
+  node.setPeakingCoefficients(normalizedFrequency, Q, gain);
   expectCoefficientsNear(node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
 }
 
 void BiquadFilterTest::testLowshelf(float frequency, float gain) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setLowshelfCoefficients(normalizedFrequency, gain);
+  node.setLowshelfCoefficients(normalizedFrequency, gain);
   expectCoefficientsNear(node, calculateLowshelfCoefficients(normalizedFrequency, gain));
 }
 
 void BiquadFilterTest::testHighshelf(float frequency, float gain) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setHighshelfCoefficients(normalizedFrequency, gain);
+  node.setHighshelfCoefficients(normalizedFrequency, gain);
   expectCoefficientsNear(node, calculateHighshelfCoefficients(normalizedFrequency, gain));
 }
 
@@ -218,13 +218,13 @@ TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
 }
 
 TEST_F(BiquadFilterTest, GetFrequencyResponse) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  auto node = BiquadFilterNode(context);
 
   float frequency = 1000.0f;
   float Q = 1.0f;
   float normalizedFrequency = frequency / nyquistFrequency;
 
-  node->setLowpassCoefficients(normalizedFrequency, Q);
+  node.setLowpassCoefficients(normalizedFrequency, Q);
   auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
 
   std::vector<float> TestFrequencies = {
@@ -243,7 +243,7 @@ TEST_F(BiquadFilterTest, GetFrequencyResponse) {
   std::vector<float> magResponseExpected(TestFrequencies.size());
   std::vector<float> phaseResponseExpected(TestFrequencies.size());
 
-  node->getFrequencyResponse(
+  node.getFrequencyResponse(
       TestFrequencies.data(),
       magResponseNode.data(),
       phaseResponseNode.data(),

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -15,17 +15,15 @@ namespace audioapi {
 class BiquadFilterTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<OfflineAudioContext> context;
+  std::shared_ptr<OfflineAudioContext> context;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(
+    context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 
-  void expectCoefficientsNear(
-      const std::shared_ptr<BiquadFilterNode> &node,
-      const BiquadCoefficients &expected);
+  void expectCoefficientsNear(const BiquadFilterNode &node, const BiquadCoefficients &expected);
   void testLowpass(float frequency, float Q);
   void testHighpass(float frequency, float Q);
   void testBandpass(float frequency, float Q);

package/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp

@@ -0,0 +1,76 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+using namespace audioapi;
+
+class WaveShaperNodeTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_shared<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableWaveShaperNode : public WaveShaperNode {
+ public:
+  explicit TestableWaveShaperNode(std::shared_ptr<BaseAudioContext> context)
+      : WaveShaperNode(context) {
+    testCurve_ = std::make_shared<AudioArray>(3);
+    auto data = testCurve_->getData();
+    data[0] = -2.0f;
+    data[1] = 0.0f;
+    data[2] = 2.0f;
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return WaveShaperNode::processNode(processingBus, framesToProcess);
+  }
+
+  std::shared_ptr<AudioArray> testCurve_;
+};
+
+TEST_F(WaveShaperNodeTest, WaveShaperNodeCanBeCreated) {
+  auto waveShaper = context->createWaveShaper();
+  ASSERT_NE(waveShaper, nullptr);
+}
+
+TEST_F(WaveShaperNodeTest, NullCanBeAsignedToCurve) {
+  auto waveShaper = context->createWaveShaper();
+  ASSERT_NO_THROW(waveShaper->setCurve(nullptr));
+  ASSERT_EQ(waveShaper->getCurve(), nullptr);
+}
+
+TEST_F(WaveShaperNodeTest, NoneOverSamplingProcessesCorrectly) {
+  static constexpr int FRAMES_TO_PROCESS = 5;
+  auto waveShaper = std::make_shared<TestableWaveShaperNode>(context);
+  waveShaper->setOversample("none");
+  waveShaper->setCurve(waveShaper->testCurve_);
+
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = -1.0f + i * 0.5f;
+  }
+
+  auto resultBus = waveShaper->processNode(bus, FRAMES_TO_PROCESS);
+  auto curveData = waveShaper->testCurve_->getData();
+  auto resultData = resultBus->getChannel(0)->getData();
+
+  EXPECT_FLOAT_EQ(resultData[0], curveData[0]);
+  EXPECT_FLOAT_EQ(resultData[1], -1.0f);
+  EXPECT_FLOAT_EQ(resultData[2], 0.0f);
+  EXPECT_FLOAT_EQ(resultData[3], 1.0f);
+  EXPECT_FLOAT_EQ(resultData[4], curveData[2]);
+}

package/common/cpp/test/src/dsp/ResamplerTest.cpp

@@ -0,0 +1,117 @@
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/dsp/Resampler.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/core/utils/Constants.h>
+#include <gtest/gtest.h>
+#include <memory>
+
+using namespace audioapi;
+
+class ResamplerTest : public ::testing::Test {
+  protected:
+    static constexpr int KERNEL_SIZE = RENDER_QUANTUM_SIZE;
+};
+
+class TestableUpSampler : public UpSampler {
+ public:
+  explicit TestableUpSampler(int maxBlockSize, int kernelSize)
+      : UpSampler(maxBlockSize, kernelSize) {}
+
+  std::shared_ptr<AudioArray> getKernel() {
+    return kernel_;
+  }
+};
+
+class TestableDownSampler : public DownSampler {
+ public:
+  explicit TestableDownSampler(int maxBlockSize, int kernelSize)
+      : DownSampler(maxBlockSize, kernelSize) {}
+
+  std::shared_ptr<AudioArray> getKernel() {
+    return kernel_;
+  }
+};
+
+TEST_F(ResamplerTest, UpSamplerCanBeCreated) {
+  auto upSampler = std::make_unique<UpSampler>(RENDER_QUANTUM_SIZE, RENDER_QUANTUM_SIZE);
+  ASSERT_NE(upSampler, nullptr);
+}
+
+TEST_F(ResamplerTest, DownSamplerCanBeCreated) {
+  auto downSampler = std::make_unique<DownSampler>(RENDER_QUANTUM_SIZE * 2, RENDER_QUANTUM_SIZE * 2);
+  ASSERT_NE(downSampler, nullptr);
+}
+
+TEST_F(ResamplerTest, UpSamplerKernelSymmetry) {
+  auto upSampler = std::make_unique<TestableUpSampler>(RENDER_QUANTUM_SIZE, RENDER_QUANTUM_SIZE);
+  auto kernel = upSampler->getKernel();
+
+  // check for symmetry around the center point
+  for (size_t i = 0; i < kernel->getSize() / 2; ++i) {
+    EXPECT_NEAR((*kernel)[i], (*kernel)[kernel->getSize() - 1 - i], 1e-6);
+  }
+}
+
+TEST_F(ResamplerTest, DownSamplerKernelSymmetry) {
+  auto downSampler =
+      std::make_unique<TestableDownSampler>(RENDER_QUANTUM_SIZE * 2, RENDER_QUANTUM_SIZE * 2);
+  auto kernel = downSampler->getKernel();
+
+  // check for symmetry around the center point
+  // as the kernel size is even, we compare pairs around the center -> kernel[size/2 - 1]
+  // last value is skipped
+  for (size_t i = 0; i < kernel->getSize() / 2; ++i) {
+    EXPECT_NEAR((*kernel)[i], (*kernel)[kernel->getSize() - 2 - i], 1e-6);
+  }
+
+  EXPECT_FLOAT_EQ((*kernel)[kernel->getSize() / 2 - 1], 0.5f);
+}
+
+TEST_F(ResamplerTest, UpSamplerKernelSum) {
+  auto upSampler = std::make_unique<TestableUpSampler>(RENDER_QUANTUM_SIZE, RENDER_QUANTUM_SIZE);
+  auto kernel = upSampler->getKernel();
+
+  float sum = 0.0f;
+  for (size_t i = 0; i < kernel->getSize(); ++i) {
+    sum += (*kernel)[i];
+  }
+
+  EXPECT_NEAR(sum, 1.0f, 1e-6);
+}
+
+TEST_F(ResamplerTest, DownSamplerKernelSum) {
+  auto downSampler =
+      std::make_unique<TestableDownSampler>(RENDER_QUANTUM_SIZE * 2, RENDER_QUANTUM_SIZE * 2);
+  auto kernel = downSampler->getKernel();
+
+  float sum = 0.0f;
+  for (size_t i = 0; i < kernel->getSize(); ++i) {
+    sum += (*kernel)[i];
+  }
+
+  EXPECT_NEAR(sum, 1.0f, 1e-6);
+}
+
+TEST_F(ResamplerTest, UpDownSamplingProcess) {
+  auto upSampler = std::make_unique<TestableUpSampler>(RENDER_QUANTUM_SIZE, RENDER_QUANTUM_SIZE);
+  auto downSampler =
+      std::make_unique<TestableDownSampler>(RENDER_QUANTUM_SIZE * 2, RENDER_QUANTUM_SIZE * 2);
+
+  auto inputArray = std::make_shared<AudioArray>(4);
+  (*inputArray)[0] = 1.0f;
+  (*inputArray)[1] = 0.0f;
+  (*inputArray)[2] = -1.0f;
+  (*inputArray)[3] = 1.0f;
+
+  auto outputArray = std::make_shared<AudioArray>(8);
+
+  int upSamplerOutputFrames;
+  int downSamplerOutputFrames;
+
+  EXPECT_NO_THROW(upSamplerOutputFrames = upSampler->process(inputArray, outputArray, 4));
+  EXPECT_NO_THROW(downSamplerOutputFrames = downSampler->process(outputArray, inputArray, 8));
+
+  EXPECT_EQ(upSamplerOutputFrames, 8);
+  EXPECT_EQ(downSamplerOutputFrames, 4);
+}

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -181,8 +181,8 @@ RCT_EXPORT_METHOD(
 {
   // iOS doesn't require explicit notification permissions for media controls
   // MPNowPlayingInfoCenter and MPRemoteCommandCenter work without permissions
-  // Return 'granted' to match the spec interface
-  resolve(@"granted");
+  // Return 'Granted' to match the spec interface
+  resolve(@"Granted");
 }
 
 RCT_EXPORT_METHOD(
@@ -190,8 +190,8 @@ RCT_EXPORT_METHOD(
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
   // iOS doesn't require explicit notification permissions for media controls
-  // Return 'granted' to match the spec interface
-  resolve(@"granted");
+  // Return 'Granted' to match the spec interface
+  resolve(@"Granted");
 }
 
 RCT_EXPORT_METHOD(

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

@@ -73,7 +73,7 @@ IOSAudioRecorder::~IOSAudioRecorder()
 /// @returns Result containing the file path if recording started successfully, or an error message.
 Result<std::string, std::string> IOSAudioRecorder::start()
 {
-  if (isRecording()) {
+  if (!isIdle()) {
     return Result<std::string, std::string>::Err("Recorder is already recording");
   }
 

package/ios/audioapi/ios/core/utils/IOSRecorderCallback.mm

@@ -97,7 +97,9 @@ Result<NoneType, std::string> IOSRecorderCallback::prepare(
 void IOSRecorderCallback::cleanup()
 {
   @autoreleasepool {
-    emitAudioData(true);
+    if (circularBus_[0]->getNumberOfAvailableFrames() > 0) {
+      emitAudioData(true);
+    }
 
     converter_ = nil;
     bufferFormat_ = nil;
@@ -133,7 +135,9 @@ void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, i
         circularBus_[i]->push_back(inputChannel, numFrames);
       }
 
-      emitAudioData();
+      if (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+        emitAudioData();
+      }
       return;
     }
 
@@ -178,7 +182,9 @@ void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, i
       circularBus_[i]->push_back(inputChannel, outputFrameCount);
     }
 
-    emitAudioData();
+    if (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+      emitAudioData();
+    }
   }
 }
 

package/lib/commonjs/AudioAPIModule/AudioAPIModule.js

@@ -5,9 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _specs = require("../specs");
-// Hint: Copied from react-native-worklets
-// Doesn't really matter what is inside, just need a unique type
-
 class AudioAPIModule {
   #workletsModule_ = null;
   #canUseWorklets_ = false;

package/lib/commonjs/AudioAPIModule/AudioAPIModule.js.map

@@ -1 +1 @@
-{"version":3,"names":["_specs","require","AudioAPIModule","workletsModule_","canUseWorklets_","workletsVersion","workletsAvailable_","supportedWorkletsVersion","constructor","verifyWorklets","verifyInstallation","NativeAudioAPIModule","Error","install","#verifyWorklets","workletsPackage","workletsPackageJson","version","includes","#verifyInstallation","global","createAudioContext","createOfflineAudioContext","createAudioRecorder","createAudioDecoder","createAudioStretcher","AudioEventEmitter","workletsModule","canUseWorklets","areWorkletsAvailable","isWorkletsVersionSupported","createAudioRuntime","createWorkletRuntime","_default","exports","default"],"sourceRoot":"../../../src","sources":["AudioAPIModule/AudioAPIModule.ts"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAEA;AACA;;AAcA,MAAMC,cAAc,CAAC;EACnB,CAACC,eAAe,GAA2B,IAAI;EAC/C,CAACC,eAAe,GAAG,KAAK;EACxB,CAACC,eAAe,GAAG,SAAS;EAC5B,CAACC,kBAAkB,GAAG,KAAK;EAEpBC,wBAAwB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC;EAEpDC,WAAWA,CAAA,EAAG;IACZ;IACA;IACA;IACA,IAAI,CAAC,CAACC,cAAc,CAAC,CAAC;IAEtB,IAAI,IAAI,CAAC,CAACC,kBAAkB,CAAC,CAAC,EAAE;MAC9B;IACF;IAEA,IAAI,CAACC,2BAAoB,EAAE;MACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;IACH;IAEAD,2BAAoB,CAACE,OAAO,CAAC,CAAC;EAChC;EAEA,CAACJ,cAAcK,CAAA,EAAY;IACzB,IAAI;MACF,MAAMC,eAAe,GAAGd,OAAO,CAAC,uBAAuB,CAAC;MACxD,MAAMe,mBAAmB,GAAGf,OAAO,CAAC,oCAAoC,CAAC;MACzE,IAAI,CAAC,CAACI,eAAe,GAAGW,mBAAmB,CAACC,OAAO;MACnD,IAAI,CAAC,CAACX,kBAAkB,GAAG,IAAI;MAE/B,IAAI,CAAC,CAACF,eAAe,GAAG,IAAI,CAACG,wBAAwB,CAACW,QAAQ,CAC5DF,mBAAmB,CAACC,OACtB,CAAC;MAED,IAAI,IAAI,CAAC,CAACb,eAAe,EAAE;QACzB,IAAI,CAAC,CAACD,eAAe,GAAGY,eAAe;MACzC;MAEA,OAAO,IAAI,CAAC,CAACX,eAAe;IAC9B,CAAC,CAAC,MAAM;MACN,IAAI,CAAC,CAACA,eAAe,GAAG,KAAK;MAC7B,OAAO,KAAK;IACd;EACF;EAEA,CAACM,kBAAkBS,CAAA,EAAY;IAC7B,OACEC,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,IACxCF,MAAM,CAACG,mBAAmB,IAAI,IAAI,IAClCH,MAAM,CAACI,kBAAkB,IAAI,IAAI,IACjCJ,MAAM,CAACK,oBAAoB,IAAI,IAAI,IACnCL,MAAM,CAACM,iBAAiB,IAAI,IAAI;EAEpC;EAEA,IAAIC,cAAcA,CAAA,EAA2B;IAC3C,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIyB,cAAcA,CAAA,EAAY;IAC5B,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;EACA,IAAIC,eAAeA,CAAA,EAAW;IAC5B,OAAO,IAAI,CAAC,CAACA,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,oBAAoBA,CAAA,EAAY;IAClC,OAAO,IAAI,CAAC,CAACvB,kBAAkB;EACjC;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,0BAA0BA,CAAA,EAAY;IACxC;IACA,OAAO,IAAI,CAAC,CAAC1B,eAAe;EAC9B;EAEO2B,kBAAkBA,CAAA,EAA0B;IACjD,IAAI,CAAC,IAAI,CAAC,CAAC3B,eAAe,EAAE;MAC1B,OAAO,IAAI;IACb;IAEA,OAAO,IAAI,CAAC,CAACD,eAAe,CAAE6B,oBAAoB,CAAC,qBAAqB,CAAC;EAC3E;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEc,IAAIjC,cAAc,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["_specs","require","AudioAPIModule","workletsModule_","canUseWorklets_","workletsVersion","workletsAvailable_","supportedWorkletsVersion","constructor","verifyWorklets","verifyInstallation","NativeAudioAPIModule","Error","install","#verifyWorklets","workletsPackage","workletsPackageJson","version","includes","#verifyInstallation","global","createAudioContext","createOfflineAudioContext","createAudioRecorder","createAudioDecoder","createAudioStretcher","AudioEventEmitter","workletsModule","canUseWorklets","areWorkletsAvailable","isWorkletsVersionSupported","createAudioRuntime","createWorkletRuntime","_default","exports","default"],"sourceRoot":"../../../src","sources":["AudioAPIModule/AudioAPIModule.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOA,MAAMC,cAAc,CAA4B;EAC9C,CAACC,eAAe,GAA2B,IAAI;EAC/C,CAACC,eAAe,GAAG,KAAK;EACxB,CAACC,eAAe,GAAG,SAAS;EAC5B,CAACC,kBAAkB,GAAG,KAAK;EAEpBC,wBAAwB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC;EAEpDC,WAAWA,CAAA,EAAG;IACZ;IACA;IACA;IACA,IAAI,CAAC,CAACC,cAAc,CAAC,CAAC;IAEtB,IAAI,IAAI,CAAC,CAACC,kBAAkB,CAAC,CAAC,EAAE;MAC9B;IACF;IAEA,IAAI,CAACC,2BAAoB,EAAE;MACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;IACH;IAEAD,2BAAoB,CAACE,OAAO,CAAC,CAAC;EAChC;EAEA,CAACJ,cAAcK,CAAA,EAAY;IACzB,IAAI;MACF,MAAMC,eAAe,GAAGd,OAAO,CAAC,uBAAuB,CAAC;MACxD,MAAMe,mBAAmB,GAAGf,OAAO,CAAC,oCAAoC,CAAC;MACzE,IAAI,CAAC,CAACI,eAAe,GAAGW,mBAAmB,CAACC,OAAO;MACnD,IAAI,CAAC,CAACX,kBAAkB,GAAG,IAAI;MAE/B,IAAI,CAAC,CAACF,eAAe,GAAG,IAAI,CAACG,wBAAwB,CAACW,QAAQ,CAC5DF,mBAAmB,CAACC,OACtB,CAAC;MAED,IAAI,IAAI,CAAC,CAACb,eAAe,EAAE;QACzB,IAAI,CAAC,CAACD,eAAe,GAAGY,eAAe;MACzC;MAEA,OAAO,IAAI,CAAC,CAACX,eAAe;IAC9B,CAAC,CAAC,MAAM;MACN,IAAI,CAAC,CAACA,eAAe,GAAG,KAAK;MAC7B,OAAO,KAAK;IACd;EACF;EAEA,CAACM,kBAAkBS,CAAA,EAAY;IAC7B,OACEC,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,IACxCF,MAAM,CAACG,mBAAmB,IAAI,IAAI,IAClCH,MAAM,CAACI,kBAAkB,IAAI,IAAI,IACjCJ,MAAM,CAACK,oBAAoB,IAAI,IAAI,IACnCL,MAAM,CAACM,iBAAiB,IAAI,IAAI;EAEpC;EAEA,IAAIC,cAAcA,CAAA,EAA2B;IAC3C,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIyB,cAAcA,CAAA,EAAY;IAC5B,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;EACA,IAAIC,eAAeA,CAAA,EAAW;IAC5B,OAAO,IAAI,CAAC,CAACA,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,oBAAoBA,CAAA,EAAY;IAClC,OAAO,IAAI,CAAC,CAACvB,kBAAkB;EACjC;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,0BAA0BA,CAAA,EAAY;IACxC;IACA,OAAO,IAAI,CAAC,CAAC1B,eAAe;EAC9B;EAEO2B,kBAAkBA,CAAA,EAA0B;IACjD,IAAI,CAAC,IAAI,CAAC,CAAC3B,eAAe,EAAE;MAC1B,OAAO,IAAI;IACb;IAEA,OAAO,IAAI,CAAC,CAACD,eAAe,CAAE6B,oBAAoB,CAAC,qBAAqB,CAAC;EAC3E;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEc,IAAIjC,cAAc,CAAC,CAAC","ignoreList":[]}

package/lib/commonjs/AudioAPIModule/AudioAPIModule.web.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const mockGetter = value => value;
+class AudioAPIModule {
+  supportedWorkletsVersion = [];
+  workletsModule = mockGetter(null);
+  canUseWorklets = mockGetter(false);
+  workletsVersion = mockGetter('unknown');
+  areWorkletsAvailable = mockGetter(false);
+  isWorkletsVersionSupported = mockGetter(false);
+  createAudioRuntime() {
+    return null;
+  }
+}
+var _default = exports.default = new AudioAPIModule();
+//# sourceMappingURL=AudioAPIModule.web.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["mockGetter","value","AudioAPIModule","supportedWorkletsVersion","workletsModule","canUseWorklets","workletsVersion","areWorkletsAvailable","isWorkletsVersionSupported","createAudioRuntime","_default","exports","default"],"sourceRoot":"../../../src","sources":["AudioAPIModule/AudioAPIModule.web.ts"],"mappings":";;;;;;AAEA,MAAMA,UAAU,GAAOC,KAAQ,IAAKA,KAAK;AAEzC,MAAMC,cAAc,CAA4B;EACvCC,wBAAwB,GAAG,EAAE;EACpCC,cAAc,GAAGJ,UAAU,CAAC,IAA8B,CAAC;EAC3DK,cAAc,GAAGL,UAAU,CAAC,KAAK,CAAC;EAClCM,eAAe,GAAGN,UAAU,CAAC,SAAS,CAAC;EACvCO,oBAAoB,GAAGP,UAAU,CAAC,KAAK,CAAC;EACxCQ,0BAA0B,GAAGR,UAAU,CAAC,KAAK,CAAC;EAE9CS,kBAAkBA,CAAA,EAAG;IACnB,OAAO,IAAI;EACb;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEc,IAAIV,cAAc,CAAC,CAAC","ignoreList":[]}

package/lib/commonjs/AudioAPIModule/ModuleInterfaces.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=ModuleInterfaces.js.map

package/lib/commonjs/AudioAPIModule/ModuleInterfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["AudioAPIModule/ModuleInterfaces.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/api.js

@@ -21,12 +21,14 @@ var _exportNames = {
   BiquadFilterNode: true,
   ConstantSourceNode: true,
   ConvolverNode: true,
+  DelayNode: true,
   GainNode: true,
   OfflineAudioContext: true,
   OscillatorNode: true,
   RecorderAdapterNode: true,
   StereoPannerNode: true,
   StreamerNode: true,
+  WaveShaperNode: true,
   WorkletNode: true,
   WorkletProcessingNode: true,
   WorkletSourceNode: true,
@@ -134,6 +136,12 @@ Object.defineProperty(exports, "ConvolverNode", {
     return _ConvolverNode.default;
   }
 });
+Object.defineProperty(exports, "DelayNode", {
+  enumerable: true,
+  get: function () {
+    return _DelayNode.default;
+  }
+});
 Object.defineProperty(exports, "FilePreset", {
   enumerable: true,
   get: function () {
@@ -236,6 +244,12 @@ Object.defineProperty(exports, "StreamerNode", {
     return _StreamerNode.default;
   }
 });
+Object.defineProperty(exports, "WaveShaperNode", {
+  enumerable: true,
+  get: function () {
+    return _WaveShaperNode.default;
+  }
+});
 Object.defineProperty(exports, "WorkletNode", {
   enumerable: true,
   get: function () {
@@ -295,12 +309,14 @@ var _BaseAudioContext = _interopRequireDefault(require("./core/BaseAudioContext"
 var _BiquadFilterNode = _interopRequireDefault(require("./core/BiquadFilterNode"));
 var _ConstantSourceNode = _interopRequireDefault(require("./core/ConstantSourceNode"));
 var _ConvolverNode = _interopRequireDefault(require("./core/ConvolverNode"));
+var _DelayNode = _interopRequireDefault(require("./core/DelayNode"));
 var _GainNode = _interopRequireDefault(require("./core/GainNode"));
 var _OfflineAudioContext = _interopRequireDefault(require("./core/OfflineAudioContext"));
 var _OscillatorNode = _interopRequireDefault(require("./core/OscillatorNode"));
 var _RecorderAdapterNode = _interopRequireDefault(require("./core/RecorderAdapterNode"));
 var _StereoPannerNode = _interopRequireDefault(require("./core/StereoPannerNode"));
 var _StreamerNode = _interopRequireDefault(require("./core/StreamerNode"));
+var _WaveShaperNode = _interopRequireDefault(require("./core/WaveShaperNode"));
 var _WorkletNode = _interopRequireDefault(require("./core/WorkletNode"));
 var _WorkletProcessingNode = _interopRequireDefault(require("./core/WorkletProcessingNode"));
 var _WorkletSourceNode = _interopRequireDefault(require("./core/WorkletSourceNode"));