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

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

@@ -5,12 +5,13 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 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;
 
@@ -23,8 +24,7 @@ class ConstantSourceTest : public ::testing::Test {
 
 class TestableConstantSourceNode : public ConstantSourceNode {
  public:
-  explicit TestableConstantSourceNode(BaseAudioContext *context)
-      : ConstantSourceNode(context) {}
+  explicit TestableConstantSourceNode(BaseAudioContext *context) : ConstantSourceNode(context) {}
 
   void setOffsetParam(float value) {
     getOffsetParam()->setValue(value);
@@ -45,10 +45,8 @@ TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
 TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
   static constexpr int FRAMES_TO_PROCESS = 4;
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
-  auto constantSource =
-      std::make_shared<TestableConstantSourceNode>(context.get());
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto constantSource = std::make_shared<TestableConstantSourceNode>(context.get());
   constantSource->start(context->getCurrentTime());
   auto resultBus = constantSource->processNode(bus, FRAMES_TO_PROCESS);
 

package/common/cpp/test/src/DelayTest.cpp

@@ -0,0 +1,108 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/DelayNode.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 DelayTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> 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 TestableDelayNode : public DelayNode {
+ public:
+  explicit TestableDelayNode(BaseAudioContext *context) : DelayNode(context, 1) {}
+
+  void setDelayTimeParam(float value) {
+    getDelayTimeParam()->setValue(value);
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return DelayNode::processNode(processingBus, framesToProcess);
+  }
+};
+
+TEST_F(DelayTest, DelayCanBeCreated) {
+  auto delay = context->createDelay(1.0f);
+  ASSERT_NE(delay, nullptr);
+}
+
+TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
+  static constexpr float DELAY_TIME = 0.0f;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  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] = i + 1;
+  }
+
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], static_cast<float>(i + 1));
+  }
+}
+
+TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
+  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
+  static constexpr int FRAMES_TO_PROCESS = 128;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  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] = i + 1;
+  }
+
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be zero due to delay
+      EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], 0.0f);
+    } else {
+      EXPECT_FLOAT_EQ(
+          (*resultBus->getChannel(0))[i],
+          static_cast<float>(
+              i + 1 - FRAMES_TO_PROCESS / 2)); // Last 64 samples should be 1st part of bus
+    }
+  }
+}
+
+TEST_F(DelayTest, DelayHandlesTailCorrectly) {
+  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
+  static constexpr int FRAMES_TO_PROCESS = 128;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  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] = i + 1;
+  }
+
+  delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be 2nd part of bus
+      EXPECT_FLOAT_EQ(
+          (*resultBus->getChannel(0))[i], static_cast<float>(i + 1 + FRAMES_TO_PROCESS / 2));
+    } else {
+      EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i],
+                      0.0f); // Last 64 samples should be zero
+    }
+  }
+}

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

@@ -5,12 +5,13 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 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;
 
@@ -47,8 +48,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  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] = i + 1;
   }
@@ -65,8 +65,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     bus->getChannel(0)->getData()[i] = i + 1;
     bus->getChannel(1)->getData()[i] = -i - 1;

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

@@ -0,0 +1,153 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/IIRFilterNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <algorithm>
+#include <complex>
+#include <memory>
+#include <numbers>
+#include <vector>
+
+using namespace audioapi;
+
+class IIRFilterTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_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>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+
+  static std::complex<double>
+  evaluatePolynomial(std::span<const double> coefficients, std::complex<double> z, int order) {
+    // Use Horner's method to evaluate the polynomial P(z) = sum(coef[k]*z^k, k, 0, order);
+    std::complex<double> result = 0;
+    for (int k = order; k >= 0; --k)
+      result = result * z + std::complex<double>(coefficients[k]);
+    return result;
+  }
+
+  static void getFrequencyResponseChromium(
+      std::vector<float> feedforward,
+      std::vector<float> feedback,
+      unsigned length,
+      std::span<const float> frequency,
+      std::span<float> magResponse,
+      std::span<float> phaseResponse,
+      float nyquistFrequency) {
+    assert(!frequency.empty());
+    assert(!magResponse.empty());
+    assert(!phaseResponse.empty());
+
+    std::vector<double> m_feedforward(feedforward.begin(), feedforward.end());
+    std::vector<double> m_feedback(feedback.begin(), feedback.end());
+
+    std::vector<float> normalizedFreq(frequency.size());
+    for (size_t i = 0; i < frequency.size(); ++i) {
+      normalizedFreq[i] = frequency[i] / nyquistFrequency;
+    }
+
+    // Evaluate the z-transform of the filter at the given normalized frequencies
+    // from 0 to 1. (One corresponds to the Nyquist frequency.)
+    //
+    // The z-tranform of the filter is
+    //
+    // H(z) = sum(b[k]*z^(-k), k, 0, M) / sum(a[k]*z^(-k), k, 0, N);
+    //
+    // The desired frequency response is H(exp(j*omega)), where omega is in [0,
+    // 1).
+    //
+    // Let P(x) = sum(c[k]*x^k, k, 0, P) be a polynomial of order P. Then each of
+    // the sums in H(z) is equivalent to evaluating a polynomial at the point
+    // 1/z.
+
+    for (unsigned k = 0; k < length; ++k) {
+      if (normalizedFreq[k] < 0 || normalizedFreq[k] > 1) {
+        // Out-of-bounds frequencies should return NaN.
+        magResponse[k] = std::nanf("");
+        phaseResponse[k] = std::nanf("");
+      } else {
+        // zRecip = 1/z = exp(-j*frequency)
+        double omega = -std::numbers::pi * normalizedFreq[k];
+        auto zRecip = std::complex<double>(cos(omega), sin(omega));
+
+        auto numerator = evaluatePolynomial(m_feedforward, zRecip, m_feedforward.size() - 1);
+        auto denominator = evaluatePolynomial(m_feedback, zRecip, m_feedback.size() - 1);
+        auto response = numerator / denominator;
+        magResponse[k] = static_cast<float>(std::abs(response));
+        phaseResponse[k] = static_cast<float>(atan2(imag(response), real(response)));
+      }
+    }
+  }
+};
+
+TEST_F(IIRFilterTest, IIRFilterCanBeCreated) {
+  const std::vector<float> feedforward = {1.0};
+  const std::vector<float> feedback = {1.0};
+  auto node = context->createIIRFilter(feedforward, feedback);
+  ASSERT_NE(node, nullptr);
+}
+
+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);
+
+  float frequency = 1000.0f;
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  std::vector<float> TestFrequencies = {
+      -0.0001f,
+      0.0f,
+      0.0001f,
+      0.25f * nyquistFrequency,
+      0.5f * nyquistFrequency,
+      0.75f * nyquistFrequency,
+      nyquistFrequency - 0.0001f,
+      nyquistFrequency,
+      nyquistFrequency + 0.0001f};
+
+  std::vector<float> magResponseNode(TestFrequencies.size());
+  std::vector<float> phaseResponseNode(TestFrequencies.size());
+  std::vector<float> magResponseExpected(TestFrequencies.size());
+  std::vector<float> phaseResponseExpected(TestFrequencies.size());
+
+  node->getFrequencyResponse(
+      TestFrequencies.data(),
+      magResponseNode.data(),
+      phaseResponseNode.data(),
+      TestFrequencies.size());
+  getFrequencyResponseChromium(
+      feedforward,
+      feedback,
+      TestFrequencies.size(),
+      TestFrequencies,
+      magResponseExpected,
+      phaseResponseExpected,
+      nyquistFrequency);
+
+  for (size_t i = 0; i < TestFrequencies.size(); ++i) {
+    float f = TestFrequencies[i];
+    if (std::isnan(magResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(magResponseNode[i])) << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
+          << "Magnitude mismatch at " << f << " Hz";
+    }
+
+    if (std::isnan(phaseResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i])) << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
+          << "Phase mismatch at " << f << " Hz";
+    }
+  }
+}

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

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <gmock/gmock.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
-#include <unordered_map>
-#include <string>
+#include <gmock/gmock.h>
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 using namespace audioapi;
 
@@ -12,13 +12,21 @@ using EventMap = std::unordered_map<std::string, EventValue>;
 
 class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
-  MOCK_METHOD(uint64_t, registerHandler,
-              (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler), (override));
-  MOCK_METHOD(void, unregisterHandler,
-              (const std::string &eventName, uint64_t listenerId), (override));
+  MOCK_METHOD(
+      uint64_t,
+      registerHandler,
+      (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler),
+      (override));
+  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

@@ -3,12 +3,13 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 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

@@ -5,12 +5,13 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 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;
 
@@ -23,8 +24,7 @@ class StereoPannerTest : public ::testing::Test {
 
 class TestableStereoPannerNode : public StereoPannerNode {
  public:
-  explicit TestableStereoPannerNode(BaseAudioContext *context)
-      : StereoPannerNode(context) {}
+  explicit TestableStereoPannerNode(BaseAudioContext *context) : StereoPannerNode(context) {}
 
   void setPanParam(float value) {
     getPanParam()->setValue(value);
@@ -48,8 +48,7 @@ TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  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;
   }
@@ -76,8 +75,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  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;
@@ -105,8 +103,7 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
   auto panNode = std::make_shared<TestableStereoPannerNode>(context.get());
   panNode->setPanParam(PAN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  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;