react-native-audio-api 0.10.0-nightly-c815c40-20251026 → 0.11.0-alpha.0

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

@@ -1,284 +0,0 @@
-#include <test/src/biquad/BiquadFilterChromium.h>
-#include <test/src/biquad/BiquadFilterTest.h>
-
-namespace audioapi {
-
-void BiquadFilterTest::expectCoefficientsNear(
-    const std::shared_ptr<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);
-}
-
-void BiquadFilterTest::testLowpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setLowpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateLowpassCoefficients(normalizedFrequency, Q));
-}
-
-void BiquadFilterTest::testHighpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setHighpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateHighpassCoefficients(normalizedFrequency, Q));
-}
-
-void BiquadFilterTest::testBandpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setBandpassCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateBandpassCoefficients(normalizedFrequency, Q));
-}
-
-void BiquadFilterTest::testNotch(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setNotchCoefficients(normalizedFrequency, Q);
-  expectCoefficientsNear(
-      node, calculateNotchCoefficients(normalizedFrequency, Q));
-}
-
-void BiquadFilterTest::testAllpass(float frequency, float Q) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  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());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  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());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setLowshelfCoefficients(normalizedFrequency, gain);
-  expectCoefficientsNear(
-      node, calculateLowshelfCoefficients(normalizedFrequency, gain));
-}
-
-void BiquadFilterTest::testHighshelf(float frequency, float gain) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setHighshelfCoefficients(normalizedFrequency, gain);
-  expectCoefficientsNear(
-      node, calculateHighshelfCoefficients(normalizedFrequency, gain));
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    Frequencies,
-    BiquadFilterFrequencyTest,
-    ::testing::Values(
-        0.0f, // 0 Hz - the filter should block all input signal
-        10.0f, // very low frequency
-        350.0f, // default
-        nyquistFrequency - 0.0001f, // frequency near Nyquist
-        nyquistFrequency)); // maximal frequency
-
-INSTANTIATE_TEST_SUITE_P(
-    QEdgeCases,
-    BiquadFilterQTestLowpassHighpass,
-    ::testing::Values(
-        -770.63678f, // min value for lowpass and highpass
-        0.0f, // default
-        770.63678f)); // max value for lowpass and highpass
-
-INSTANTIATE_TEST_SUITE_P(
-    QEdgeCases,
-    BiquadFilterQTestRestTypes, // bandpass, notch, allpass, peaking
-    ::testing::Values(
-        0.0f, // default and min value
-        MOST_POSITIVE_SINGLE_FLOAT));
-
-INSTANTIATE_TEST_SUITE_P(
-    GainEdgeCases,
-    BiquadFilterGainTest,
-    ::testing::Values(
-        -40.0f,
-        0.0f, // default
-        40.0f));
-
-TEST_P(BiquadFilterFrequencyTest, SetLowpassCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  testLowpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetHighpassCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  testHighpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetBandpassCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  testBandpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetNotchCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  testNotch(frequency, Q);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetAllpassCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  testAllpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetPeakingCoefficients) {
-  float frequency = GetParam();
-  float Q = 1.0f;
-  float gain = 2.0f;
-  testPeaking(frequency, Q, gain);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetLowshelfCoefficients) {
-  float frequency = GetParam();
-  float gain = 2.0f;
-  testLowshelf(frequency, gain);
-}
-
-TEST_P(BiquadFilterFrequencyTest, SetHighshelfCoefficients) {
-  float frequency = GetParam();
-  float gain = 2.0f;
-  testHighshelf(frequency, gain);
-}
-
-TEST_P(BiquadFilterQTestLowpassHighpass, SetLowpassCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  testLowpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterQTestLowpassHighpass, SetHighpassCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  testHighpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterQTestRestTypes, SetBandpassCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  testBandpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterQTestRestTypes, SetNotchCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  testNotch(frequency, Q);
-}
-
-TEST_P(BiquadFilterQTestRestTypes, SetAllpassCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  testAllpass(frequency, Q);
-}
-
-TEST_P(BiquadFilterQTestRestTypes, SetPeakingCoefficients) {
-  float frequency = 1000.0f;
-  float Q = GetParam();
-  float gain = 2.0f;
-  testPeaking(frequency, Q, gain);
-}
-
-TEST_P(BiquadFilterGainTest, SetPeakingCoefficients) {
-  float frequency = 1000.0f;
-  float Q = 1.0f;
-  float gain = GetParam();
-  testPeaking(frequency, Q, gain);
-}
-
-TEST_P(BiquadFilterGainTest, SetLowshelfCoefficients) {
-  float frequency = 1000.0f;
-  float gain = GetParam();
-  testLowshelf(frequency, gain);
-}
-
-TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
-  float frequency = 1000.0f;
-  float gain = GetParam();
-  testHighshelf(frequency, gain);
-}
-
-TEST_F(BiquadFilterTest, GetFrequencyResponse) {
-  auto node = std::make_shared<BiquadFilterNode>(context.get());
-
-  float frequency = 1000.0f;
-  float Q = 1.0f;
-  float normalizedFrequency = frequency / nyquistFrequency;
-
-  node->setLowpassCoefficients(normalizedFrequency, Q);
-  auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
-
-  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());
-  getFrequencyResponse(
-      coeffs,
-      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";
-    }
-  }
-}
-
-} // namespace audioapi

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

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <audioapi/core/OfflineAudioContext.h>
-#include <audioapi/core/effects/BiquadFilterNode.h>
-#include <audioapi/core/utils/worklets/SafeIncludes.h>
-#include <gtest/gtest.h>
-#include <test/src/MockAudioEventHandlerRegistry.h>
-#include <memory>
-
-static constexpr int sampleRate = 44100;
-static constexpr float nyquistFrequency = sampleRate / 2.0f;
-static constexpr float tolerance = 0.0001f;
-
-namespace audioapi {
-class BiquadFilterTest : public ::testing::Test {
- protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<OfflineAudioContext> context;
-
-  void SetUp() override {
-    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<OfflineAudioContext>(2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
-  }
-
-  void expectCoefficientsNear(const std::shared_ptr<BiquadFilterNode> &node, const BiquadCoefficients &expected);
-  void testLowpass(float frequency, float Q);
-  void testHighpass(float frequency, float Q);
-  void testBandpass(float frequency, float Q);
-  void testNotch(float frequency, float Q);
-  void testAllpass(float frequency, float Q);
-  void testPeaking(float frequency, float Q, float gain);
-  void testLowshelf(float frequency, float gain);
-  void testHighshelf(float frequency, float gain);
-};
-
-class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterQTestRestTypes : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterFrequencyTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-class BiquadFilterGainTest : public BiquadFilterTest, public ::testing::WithParamInterface<float> {};
-} // namespace audioapi

package/scripts/download-prebuilt-binaries.sh

@@ -1,52 +0,0 @@
-#!/bin/bash
-# Script to download and unzip prebuilt native binaries for React Native.
-
-MAIN_DOWNLOAD_URL="https://github.com/software-mansion-labs/rn-audio-libs/releases/download"
-TAG="v1.0.0"
-DOWNLOAD_NAMES=(
-    "armeabi-v7a.zip" "arm64-v8a.zip" "x86.zip" "x86_64.zip"
-    "ffmpeg_ios.zip" "iphoneos.zip" "iphonesimulator.zip" "jniLibs.zip"
-)
-
-# Use a temporary directory for downloads, ensuring it exists
-TEMP_DOWNLOAD_DIR="$(pwd)/audioapi-binaries-temp"
-mkdir -p "$TEMP_DOWNLOAD_DIR"
-if [ $1 == "android" ]
-then
-    PROJECT_ROOT="$(pwd)/.."
-else
-    PROJECT_ROOT="$(pwd)"
-fi
-
-for name in "${DOWNLOAD_NAMES[@]}"; do
-    ARCH_URL="${MAIN_DOWNLOAD_URL}/${TAG}/${name}"
-    ZIP_FILE_PATH="${TEMP_DOWNLOAD_DIR}/${name}"
-
-    if [[ "$name" == "jniLibs.zip" ]]; then
-        OUTPUT_DIR="${PROJECT_ROOT}/android/src/main"
-    else
-        OUTPUT_DIR="${PROJECT_ROOT}/common/cpp/audioapi/external"
-    fi
-
-    mkdir -p "$OUTPUT_DIR"
-
-    if [ -f "$ZIP_FILE_PATH" ]; then
-        echo "Zip file already exists locally. Skipping download."
-        continue
-    fi
-    echo "Downloading from: $ARCH_URL"
-    curl -fsSL "$ARCH_URL" -o "$ZIP_FILE_PATH"
-
-    if [ $? -ne 0 ]; then
-        rm -f "$ZIP_FILE_PATH"
-        continue
-    fi
-
-    unzip -o "$ZIP_FILE_PATH" -d "$OUTPUT_DIR"
-
-    # Clean up any __MACOSX directories that may have been created
-    rm -rf "${OUTPUT_DIR}/__MACOSX"
-
-done
-
-rm -rf "$TEMP_DOWNLOAD_DIR"

package/scripts/rnaa_utils.rb

@@ -1,8 +0,0 @@
-def check_if_worklets_enabled()
-  validate_worklets_script = File.expand_path(File.join(__dir__, 'validate-worklets-version.js'))
-  unless system("node \"#{validate_worklets_script}\"")
-    # If the validation script fails, we assume worklets are not present or have an incompatible version
-    return false
-  end
-  true
-end

package/scripts/validate-worklets-version.js

@@ -1,28 +0,0 @@
-'use strict';
-const semverPrerelease = require('semver/functions/prerelease');
-const validWorkletsVersions = [
-  '0.6.0',
-  '0.6.1',
-];
-
-function validateVersion() {
-  let workletsVersion;
-  try {
-    const { version } = require('react-native-worklets/package.json');
-    workletsVersion = version;
-  } catch (e) {
-    return false;
-  }
-  if (semverPrerelease(workletsVersion)) {
-    return true;
-  }
-
-  return validWorkletsVersions.includes(workletsVersion);
-}
-
-if (!validateVersion()) {
-  console.error(
-    'Incompatible version of react-native-audio-worklets detected. Please install a compatible version.',
-  );
-  process.exit(1);
-}