remove shadowed variables in common_audio
BUG=webrtc:42223409
Change-Id: I17cdfc659cfec9647a92fc33814cab43c2ace3d0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/383560
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Per Åhgren <peah@webrtc.org>
Commit-Queue: Philipp Hancke <phancke@meta.com>
Cr-Commit-Position: refs/heads/main@{#44383}
diff --git a/common_audio/BUILD.gn b/common_audio/BUILD.gn
index 4845bc7..bdb6c02 100644
--- a/common_audio/BUILD.gn
+++ b/common_audio/BUILD.gn
@@ -369,6 +369,7 @@
deps = [
":common_audio",
":common_audio_c",
+ ":common_audio_cc",
":fir_filter",
":fir_filter_factory",
":sinc_resampler",
diff --git a/common_audio/fir_filter_unittest.cc b/common_audio/fir_filter_unittest.cc
index 5c5880b..9b97388 100644
--- a/common_audio/fir_filter_unittest.cc
+++ b/common_audio/fir_filter_unittest.cc
@@ -12,6 +12,7 @@
#include <string.h>
+#include <array>
#include <memory>
#include "common_audio/fir_filter_factory.h"
@@ -20,84 +21,81 @@
namespace webrtc {
namespace {
-static const float kCoefficients[] = {0.2f, 0.3f, 0.5f, 0.7f, 0.11f};
-static const size_t kCoefficientsLength =
- sizeof(kCoefficients) / sizeof(kCoefficients[0]);
+static constexpr size_t kCoefficientsSize = 5;
+static const std::array<float, kCoefficientsSize> kCoefficients = {
+ 0.2f, 0.3f, 0.5f, 0.7f, 0.11f};
-static const float kInput[] = {1.f, 2.f, 3.f, 4.f, 5.f,
- 6.f, 7.f, 8.f, 9.f, 10.f};
-static const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
-
-void VerifyOutput(const float* expected_output,
- const float* output,
- size_t length) {
- EXPECT_EQ(
- 0, memcmp(expected_output, output, length * sizeof(expected_output[0])));
-}
+static constexpr size_t kInputSize = 10;
+static const std::array<float, kInputSize> kInput = {1.f, 2.f, 3.f, 4.f, 5.f,
+ 6.f, 7.f, 8.f, 9.f, 10.f};
} // namespace
TEST(FIRFilterTest, FilterAsIdentity) {
- const float kCoefficients[] = {1.f, 0.f, 0.f, 0.f, 0.f};
- float output[kInputLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kInputLength));
- filter->Filter(kInput, kInputLength, output);
-
- VerifyOutput(kInput, output, kInputLength);
+ const std::array<float, kCoefficientsSize> kCoefficientsTested = {
+ 1.f, 0.f, 0.f, 0.f, 0.f};
+ std::array<float, kInputSize> output;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficientsTested.data(), kCoefficientsTested.size(), kInput.size()));
+ filter->Filter(kInput.data(), kInput.size(), output.data());
+ for (size_t i = 0; i < kInput.size(); i++) {
+ EXPECT_EQ(kInput[i], output[i]);
+ }
}
TEST(FIRFilterTest, FilterUsedAsScalarMultiplication) {
- const float kCoefficients[] = {5.f, 0.f, 0.f, 0.f, 0.f};
- float output[kInputLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kInputLength));
- filter->Filter(kInput, kInputLength, output);
+ const std::array<float, kCoefficientsSize> kCoefficientsTested = {
+ 5.f, 0.f, 0.f, 0.f, 0.f};
+ std::array<float, kInputSize> output;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficientsTested.data(), kCoefficientsTested.size(), kInput.size()));
+ filter->Filter(kInput.data(), kInput.size(), output.data());
EXPECT_FLOAT_EQ(5.f, output[0]);
EXPECT_FLOAT_EQ(20.f, output[3]);
EXPECT_FLOAT_EQ(25.f, output[4]);
- EXPECT_FLOAT_EQ(50.f, output[kInputLength - 1]);
+ EXPECT_FLOAT_EQ(50.f, output[kInput.size() - 1]);
}
TEST(FIRFilterTest, FilterUsedAsInputShifting) {
- const float kCoefficients[] = {0.f, 0.f, 0.f, 0.f, 1.f};
- float output[kInputLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kInputLength));
- filter->Filter(kInput, kInputLength, output);
+ const std::array<float, kCoefficientsSize> kCoefficientsTested = {
+ 0.f, 0.f, 0.f, 0.f, 1.f};
+ std::array<float, kInputSize> output;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficientsTested.data(), kCoefficientsTested.size(), kInput.size()));
+ filter->Filter(kInput.data(), kInput.size(), output.data());
EXPECT_FLOAT_EQ(0.f, output[0]);
EXPECT_FLOAT_EQ(0.f, output[3]);
EXPECT_FLOAT_EQ(1.f, output[4]);
EXPECT_FLOAT_EQ(2.f, output[5]);
- EXPECT_FLOAT_EQ(6.f, output[kInputLength - 1]);
+ EXPECT_FLOAT_EQ(6.f, output[kInput.size() - 1]);
}
TEST(FIRFilterTest, FilterUsedAsArbitraryWeighting) {
- float output[kInputLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kInputLength));
- filter->Filter(kInput, kInputLength, output);
+ std::array<float, kInputSize> output;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficients.data(), kCoefficients.size(), kInput.size()));
+ filter->Filter(kInput.data(), kInput.size(), output.data());
EXPECT_FLOAT_EQ(0.2f, output[0]);
EXPECT_FLOAT_EQ(3.4f, output[3]);
EXPECT_FLOAT_EQ(5.21f, output[4]);
EXPECT_FLOAT_EQ(7.02f, output[5]);
- EXPECT_FLOAT_EQ(14.26f, output[kInputLength - 1]);
+ EXPECT_FLOAT_EQ(14.26f, output[kInput.size() - 1]);
}
TEST(FIRFilterTest, FilterInLengthLesserOrEqualToCoefficientsLength) {
- float output[kInputLength];
+ std::array<float, kInputSize> output;
std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, 2));
- filter->Filter(kInput, 2, output);
+ CreateFirFilter(kCoefficients.data(), kCoefficients.size(), 2));
+ filter->Filter(kInput.data(), 2, output.data());
EXPECT_FLOAT_EQ(0.2f, output[0]);
EXPECT_FLOAT_EQ(0.7f, output[1]);
- filter.reset(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kCoefficientsLength));
- filter->Filter(kInput, kCoefficientsLength, output);
+ filter.reset(CreateFirFilter(kCoefficients.data(), kCoefficients.size(),
+ kCoefficients.size()));
+ filter->Filter(kInput.data(), kCoefficients.size(), output.data());
EXPECT_FLOAT_EQ(0.2f, output[0]);
EXPECT_FLOAT_EQ(3.4f, output[3]);
@@ -105,103 +103,101 @@
}
TEST(FIRFilterTest, MultipleFilterCalls) {
- float output[kInputLength];
+ std::array<float, kInputSize> output;
std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, 3));
- filter->Filter(kInput, 2, output);
+ CreateFirFilter(kCoefficients.data(), kCoefficients.size(), 3));
+ filter->Filter(kInput.data(), 2, output.data());
EXPECT_FLOAT_EQ(0.2f, output[0]);
EXPECT_FLOAT_EQ(0.7f, output[1]);
- filter->Filter(kInput, 2, output);
+ filter->Filter(kInput.data(), 2, output.data());
EXPECT_FLOAT_EQ(1.3f, output[0]);
EXPECT_FLOAT_EQ(2.4f, output[1]);
- filter->Filter(kInput, 2, output);
+ filter->Filter(kInput.data(), 2, output.data());
EXPECT_FLOAT_EQ(2.81f, output[0]);
EXPECT_FLOAT_EQ(2.62f, output[1]);
- filter->Filter(kInput, 2, output);
+ filter->Filter(kInput.data(), 2, output.data());
EXPECT_FLOAT_EQ(2.81f, output[0]);
EXPECT_FLOAT_EQ(2.62f, output[1]);
- filter->Filter(&kInput[3], 3, output);
+ filter->Filter(&kInput[3], 3, output.data());
EXPECT_FLOAT_EQ(3.41f, output[0]);
EXPECT_FLOAT_EQ(4.12f, output[1]);
EXPECT_FLOAT_EQ(6.21f, output[2]);
- filter->Filter(&kInput[3], 3, output);
+ filter->Filter(&kInput[3], 3, output.data());
EXPECT_FLOAT_EQ(8.12f, output[0]);
EXPECT_FLOAT_EQ(9.14f, output[1]);
EXPECT_FLOAT_EQ(9.45f, output[2]);
}
TEST(FIRFilterTest, VerifySampleBasedVsBlockBasedFiltering) {
- float output_block_based[kInputLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kInputLength));
- filter->Filter(kInput, kInputLength, output_block_based);
+ float output_block_based[kInput.size()];
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficients.data(), kCoefficients.size(), kInput.size()));
+ filter->Filter(kInput.data(), kInput.size(), output_block_based);
- float output_sample_based[kInputLength];
- filter.reset(CreateFirFilter(kCoefficients, kCoefficientsLength, 1));
- for (size_t i = 0; i < kInputLength; ++i) {
+ float output_sample_based[kInput.size()];
+ filter.reset(CreateFirFilter(kCoefficients.data(), kCoefficients.size(), 1));
+ for (size_t i = 0; i < kInput.size(); ++i) {
filter->Filter(&kInput[i], 1, &output_sample_based[i]);
}
- EXPECT_EQ(0, memcmp(output_sample_based, output_block_based, kInputLength));
+ EXPECT_EQ(0, memcmp(output_sample_based, output_block_based, kInput.size()));
}
TEST(FIRFilterTest, SimplestHighPassFilter) {
- const float kCoefficients[] = {1.f, -1.f};
- const size_t kCoefficientsLength =
- sizeof(kCoefficients) / sizeof(kCoefficients[0]);
+ const std::array<float, 2> kCoefficientsTested = {1.f, -1.f};
- float kConstantInput[] = {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
- const size_t kConstantInputLength =
- sizeof(kConstantInput) / sizeof(kConstantInput[0]);
-
- float output[kConstantInputLength];
- std::unique_ptr<FIRFilter> filter(CreateFirFilter(
- kCoefficients, kCoefficientsLength, kConstantInputLength));
- filter->Filter(kConstantInput, kConstantInputLength, output);
+ std::array<float, 8> kConstantInput = {1.f, 1.f, 1.f, 1.f,
+ 1.f, 1.f, 1.f, 1.f};
+ std::array<float, 8> output;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(kCoefficientsTested.data(),
+ kCoefficientsTested.size(),
+ kConstantInput.size()));
+ filter->Filter(kConstantInput.data(), kConstantInput.size(), output.data());
EXPECT_FLOAT_EQ(1.f, output[0]);
- for (size_t i = kCoefficientsLength - 1; i < kConstantInputLength; ++i) {
+ for (size_t i = kCoefficientsTested.size() - 1; i < kConstantInput.size();
+ ++i) {
EXPECT_FLOAT_EQ(0.f, output[i]);
}
}
TEST(FIRFilterTest, SimplestLowPassFilter) {
- const float kCoefficients[] = {1.f, 1.f};
- const size_t kCoefficientsLength =
- sizeof(kCoefficients) / sizeof(kCoefficients[0]);
+ const std::array<float, 2> kCoefficientsTested = {1.f, 1.f};
- float kHighFrequencyInput[] = {-1.f, 1.f, -1.f, 1.f, -1.f, 1.f, -1.f, 1.f};
- const size_t kHighFrequencyInputLength =
- sizeof(kHighFrequencyInput) / sizeof(kHighFrequencyInput[0]);
-
- float output[kHighFrequencyInputLength];
- std::unique_ptr<FIRFilter> filter(CreateFirFilter(
- kCoefficients, kCoefficientsLength, kHighFrequencyInputLength));
- filter->Filter(kHighFrequencyInput, kHighFrequencyInputLength, output);
+ const std::array<float, 8> kHighFrequencyInput = {-1.f, 1.f, -1.f, 1.f,
+ -1.f, 1.f, -1.f, 1.f};
+ std::array<float, 8> output;
+ std::unique_ptr<FIRFilter> filter(
+ CreateFirFilter(kCoefficientsTested.data(), kCoefficientsTested.size(),
+ kHighFrequencyInput.size()));
+ filter->Filter(kHighFrequencyInput.data(), kHighFrequencyInput.size(),
+ output.data());
EXPECT_FLOAT_EQ(-1.f, output[0]);
- for (size_t i = kCoefficientsLength - 1; i < kHighFrequencyInputLength; ++i) {
+ for (size_t i = kCoefficientsTested.size() - 1;
+ i < kHighFrequencyInput.size(); ++i) {
EXPECT_FLOAT_EQ(0.f, output[i]);
}
}
TEST(FIRFilterTest, SameOutputWhenSwapedCoefficientsAndInput) {
- float output[kCoefficientsLength];
- float output_swaped[kCoefficientsLength];
- std::unique_ptr<FIRFilter> filter(
- CreateFirFilter(kCoefficients, kCoefficientsLength, kCoefficientsLength));
- // Use kCoefficientsLength for in_length to get same-length outputs.
- filter->Filter(kInput, kCoefficientsLength, output);
+ std::array<float, kCoefficientsSize> output;
+ std::array<float, kCoefficientsSize> output_swapped;
+ std::unique_ptr<FIRFilter> filter(CreateFirFilter(
+ kCoefficients.data(), kCoefficients.size(), kCoefficients.size()));
+ // Use kCoefficients.size() for in_length to get same-length outputs.
+ filter->Filter(kInput.data(), kCoefficients.size(), output.data());
- filter.reset(
- CreateFirFilter(kInput, kCoefficientsLength, kCoefficientsLength));
- filter->Filter(kCoefficients, kCoefficientsLength, output_swaped);
+ filter.reset(CreateFirFilter(kInput.data(), kCoefficients.size(),
+ kCoefficients.size()));
+ filter->Filter(kCoefficients.data(), kCoefficients.size(),
+ output_swapped.data());
- for (size_t i = 0; i < kCoefficientsLength; ++i) {
- EXPECT_FLOAT_EQ(output[i], output_swaped[i]);
+ for (size_t i = 0; i < kCoefficients.size(); ++i) {
+ EXPECT_FLOAT_EQ(output[i], output_swapped[i]);
}
}
diff --git a/common_audio/signal_processing/signal_processing_unittest.cc b/common_audio/signal_processing/signal_processing_unittest.cc
index d667d2d..7495702 100644
--- a/common_audio/signal_processing/signal_processing_unittest.cc
+++ b/common_audio/signal_processing/signal_processing_unittest.cc
@@ -9,21 +9,26 @@
*/
#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include "common_audio/signal_processing/dot_product_with_scale.h"
#include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "common_audio/signal_processing/include/spl_inl.h"
#include "rtc_base/strings/string_builder.h"
#include "test/gtest.h"
-static const size_t kVector16Size = 9;
-static const int16_t vector16[kVector16Size] = {1,
- -15511,
- 4323,
- 1963,
- WEBRTC_SPL_WORD16_MAX,
- 0,
- WEBRTC_SPL_WORD16_MIN + 5,
- -3333,
- 345};
+static const int16_t vector16[] = {1,
+ -15511,
+ 4323,
+ 1963,
+ WEBRTC_SPL_WORD16_MAX,
+ 0,
+ WEBRTC_SPL_WORD16_MIN + 5,
+ -3333,
+ 345};
+static const size_t kVector16Size = std::size(vector16);
TEST(SplTest, MacroTest) {
// Macros with inputs.
@@ -253,104 +258,105 @@
// Vectors to test the cases where minimum values have to be caught
// outside of the unrolled loops in ARM-Neon.
- int16_t vector16[kVectorSize] = {-1,
- 7485,
- 0,
- 3333,
- -18283,
- 0,
- 12334,
- -29871,
- 988,
- -3333,
- 345,
- -456,
- 222,
- 999,
- 888,
- 8774,
- WEBRTC_SPL_WORD16_MIN};
- int32_t vector32[kVectorSize] = {-1,
- 0,
- 283211,
- 3333,
- 8712345,
- 0,
- -3333,
- 89345,
- -374585456,
- 222,
- 999,
- 122345334,
- -12389756,
- -987329871,
- 888,
- -2,
- WEBRTC_SPL_WORD32_MIN};
+ int16_t vector16_arm[kVectorSize] = {-1,
+ 7485,
+ 0,
+ 3333,
+ -18283,
+ 0,
+ 12334,
+ -29871,
+ 988,
+ -3333,
+ 345,
+ -456,
+ 222,
+ 999,
+ 888,
+ 8774,
+ WEBRTC_SPL_WORD16_MIN};
+ int32_t vector32_arm[kVectorSize] = {-1,
+ 0,
+ 283211,
+ 3333,
+ 8712345,
+ 0,
+ -3333,
+ 89345,
+ -374585456,
+ 222,
+ 999,
+ 122345334,
+ -12389756,
+ -987329871,
+ 888,
+ -2,
+ WEBRTC_SPL_WORD32_MIN};
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
- WebRtcSpl_MinValueW16(vector16, kVectorSize));
+ WebRtcSpl_MinValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MIN,
- WebRtcSpl_MinValueW32(vector32, kVectorSize));
- EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW16(vector16, kVectorSize));
- EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW32(vector32, kVectorSize));
+ WebRtcSpl_MinValueW32(vector32_arm, kVectorSize));
+ EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
- WebRtcSpl_MaxAbsElementW16(vector16, kVectorSize));
+ WebRtcSpl_MaxAbsElementW16(vector16_arm, kVectorSize));
int16_t min_value, max_value;
- WebRtcSpl_MinMaxW16(vector16, kVectorSize, &min_value, &max_value);
+ WebRtcSpl_MinMaxW16(vector16_arm, kVectorSize, &min_value, &max_value);
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, min_value);
EXPECT_EQ(12334, max_value);
// Test the cases where maximum values have to be caught
// outside of the unrolled loops in ARM-Neon.
- vector16[kVectorSize - 1] = WEBRTC_SPL_WORD16_MAX;
- vector32[kVectorSize - 1] = WEBRTC_SPL_WORD32_MAX;
+ vector16_arm[kVectorSize - 1] = WEBRTC_SPL_WORD16_MAX;
+ vector32_arm[kVectorSize - 1] = WEBRTC_SPL_WORD32_MAX;
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
- WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize));
+ WebRtcSpl_MaxAbsValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
- WebRtcSpl_MaxValueW16(vector16, kVectorSize));
+ WebRtcSpl_MaxValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
- WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize));
+ WebRtcSpl_MaxAbsValueW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
- WebRtcSpl_MaxValueW32(vector32, kVectorSize));
- EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
- EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
- EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
+ WebRtcSpl_MaxValueW32(vector32_arm, kVectorSize));
+ EXPECT_EQ(kVectorSize - 1,
+ WebRtcSpl_MaxAbsIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
- WebRtcSpl_MaxAbsElementW16(vector16, kVectorSize));
- WebRtcSpl_MinMaxW16(vector16, kVectorSize, &min_value, &max_value);
+ WebRtcSpl_MaxAbsElementW16(vector16_arm, kVectorSize));
+ WebRtcSpl_MinMaxW16(vector16_arm, kVectorSize, &min_value, &max_value);
EXPECT_EQ(-29871, min_value);
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, max_value);
// Test the cases where multiple maximum and minimum values are present.
- vector16[1] = WEBRTC_SPL_WORD16_MAX;
- vector16[6] = WEBRTC_SPL_WORD16_MIN;
- vector16[11] = WEBRTC_SPL_WORD16_MIN;
- vector32[1] = WEBRTC_SPL_WORD32_MAX;
- vector32[6] = WEBRTC_SPL_WORD32_MIN;
- vector32[11] = WEBRTC_SPL_WORD32_MIN;
+ vector16_arm[1] = WEBRTC_SPL_WORD16_MAX;
+ vector16_arm[6] = WEBRTC_SPL_WORD16_MIN;
+ vector16_arm[11] = WEBRTC_SPL_WORD16_MIN;
+ vector32_arm[1] = WEBRTC_SPL_WORD32_MAX;
+ vector32_arm[6] = WEBRTC_SPL_WORD32_MIN;
+ vector32_arm[11] = WEBRTC_SPL_WORD32_MIN;
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
- WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize));
+ WebRtcSpl_MaxAbsValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX,
- WebRtcSpl_MaxValueW16(vector16, kVectorSize));
+ WebRtcSpl_MaxValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
- WebRtcSpl_MinValueW16(vector16, kVectorSize));
+ WebRtcSpl_MinValueW16(vector16_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
- WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize));
+ WebRtcSpl_MaxAbsValueW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MAX,
- WebRtcSpl_MaxValueW32(vector32, kVectorSize));
+ WebRtcSpl_MaxValueW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD32_MIN,
- WebRtcSpl_MinValueW32(vector32, kVectorSize));
- EXPECT_EQ(6u, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize));
- EXPECT_EQ(1u, WebRtcSpl_MaxIndexW16(vector16, kVectorSize));
- EXPECT_EQ(1u, WebRtcSpl_MaxIndexW32(vector32, kVectorSize));
- EXPECT_EQ(6u, WebRtcSpl_MinIndexW16(vector16, kVectorSize));
- EXPECT_EQ(6u, WebRtcSpl_MinIndexW32(vector32, kVectorSize));
+ WebRtcSpl_MinValueW32(vector32_arm, kVectorSize));
+ EXPECT_EQ(6u, WebRtcSpl_MaxAbsIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(1u, WebRtcSpl_MaxIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(1u, WebRtcSpl_MaxIndexW32(vector32_arm, kVectorSize));
+ EXPECT_EQ(6u, WebRtcSpl_MinIndexW16(vector16_arm, kVectorSize));
+ EXPECT_EQ(6u, WebRtcSpl_MinIndexW32(vector32_arm, kVectorSize));
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN,
- WebRtcSpl_MaxAbsElementW16(vector16, kVectorSize));
- WebRtcSpl_MinMaxW16(vector16, kVectorSize, &min_value, &max_value);
+ WebRtcSpl_MaxAbsElementW16(vector16_arm, kVectorSize));
+ WebRtcSpl_MinMaxW16(vector16_arm, kVectorSize, &min_value, &max_value);
EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, min_value);
EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, max_value);
diff --git a/common_audio/vad/vad_unittest.cc b/common_audio/vad/vad_unittest.cc
index 1cdc3d9..5f6afb1 100644
--- a/common_audio/vad/vad_unittest.cc
+++ b/common_audio/vad/vad_unittest.cc
@@ -12,9 +12,11 @@
#include <stdlib.h>
+#include <cstdint>
+#include <iterator>
+
#include "common_audio/signal_processing/include/signal_processing_library.h"
#include "common_audio/vad/include/webrtc_vad.h"
-#include "rtc_base/arraysize.h"
#include "rtc_base/checks.h"
#include "test/gtest.h"
@@ -128,20 +130,21 @@
// This test verifies valid and invalid rate/frame_length combinations. We
// loop through some sampling rates and frame lengths from negative values to
// values larger than possible.
- const int kRates[] = {-8000, -4000, 0, 4000, 8000, 8001,
- 15999, 16000, 32000, 48000, 48001, 96000};
+ const int kInvalidRates[] = {-8000, -4000, 0, 4000, 8000, 8001,
+ 15999, 16000, 32000, 48000, 48001, 96000};
- const size_t kFrameLengths[] = {0, 80, 81, 159, 160, 240,
- 320, 480, 640, 960, 1440, 2000};
+ const size_t kInvalidFrameLengths[] = {0, 80, 81, 159, 160, 240,
+ 320, 480, 640, 960, 1440, 2000};
- for (size_t i = 0; i < arraysize(kRates); i++) {
- for (size_t j = 0; j < arraysize(kFrameLengths); j++) {
- if (ValidRatesAndFrameLengths(kRates[i], kFrameLengths[j])) {
- EXPECT_EQ(
- 0, WebRtcVad_ValidRateAndFrameLength(kRates[i], kFrameLengths[j]));
+ for (size_t i = 0; i < std::size(kInvalidRates); i++) {
+ for (size_t j = 0; j < std::size(kInvalidFrameLengths); j++) {
+ if (ValidRatesAndFrameLengths(kInvalidRates[i],
+ kInvalidFrameLengths[j])) {
+ EXPECT_EQ(0, WebRtcVad_ValidRateAndFrameLength(
+ kInvalidRates[i], kInvalidFrameLengths[j]));
} else {
- EXPECT_EQ(
- -1, WebRtcVad_ValidRateAndFrameLength(kRates[i], kFrameLengths[j]));
+ EXPECT_EQ(-1, WebRtcVad_ValidRateAndFrameLength(
+ kInvalidRates[i], kInvalidFrameLengths[j]));
}
}
}
