aboutsummaryrefslogtreecommitdiff
path: root/files/unit_test/compare_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'files/unit_test/compare_test.cc')
-rw-r--r--files/unit_test/compare_test.cc292
1 files changed, 257 insertions, 35 deletions
diff --git a/files/unit_test/compare_test.cc b/files/unit_test/compare_test.cc
index 13f74705..136254e1 100644
--- a/files/unit_test/compare_test.cc
+++ b/files/unit_test/compare_test.cc
@@ -15,14 +15,17 @@
#include "../unit_test/unit_test.h"
#include "libyuv/basic_types.h"
#include "libyuv/compare.h"
+#include "libyuv/compare_row.h" /* For HammingDistance_C */
#include "libyuv/cpu_id.h"
#include "libyuv/video_common.h"
namespace libyuv {
// hash seed of 5381 recommended.
-static uint32 ReferenceHashDjb2(const uint8* src, uint64 count, uint32 seed) {
- uint32 hash = seed;
+static uint32_t ReferenceHashDjb2(const uint8_t* src,
+ uint64_t count,
+ uint32_t seed) {
+ uint32_t hash = seed;
if (count > 0) {
do {
hash = hash * 33 + *src++;
@@ -31,7 +34,7 @@ static uint32 ReferenceHashDjb2(const uint8* src, uint64 count, uint32 seed) {
return hash;
}
-TEST_F(LibYUVBaseTest, Djb2_Test) {
+TEST_F(LibYUVCompareTest, Djb2_Test) {
const int kMaxTest = benchmark_width_ * benchmark_height_;
align_buffer_page_end(src_a, kMaxTest);
align_buffer_page_end(src_b, kMaxTest);
@@ -40,8 +43,8 @@ TEST_F(LibYUVBaseTest, Djb2_Test) {
"The quick brown fox jumps over the lazy dog"
" and feels as if he were in the seventh heaven of typography"
" together with Hermann Zapf";
- uint32 foxhash = HashDjb2(reinterpret_cast<const uint8*>(fox), 131, 5381);
- const uint32 kExpectedFoxHash = 2611006483u;
+ uint32_t foxhash = HashDjb2(reinterpret_cast<const uint8_t*>(fox), 131, 5381);
+ const uint32_t kExpectedFoxHash = 2611006483u;
EXPECT_EQ(kExpectedFoxHash, foxhash);
for (int i = 0; i < kMaxTest; ++i) {
@@ -49,8 +52,8 @@ TEST_F(LibYUVBaseTest, Djb2_Test) {
src_b[i] = (fastrand() & 0xff);
}
// Compare different buffers. Expect hash is different.
- uint32 h1 = HashDjb2(src_a, kMaxTest, 5381);
- uint32 h2 = HashDjb2(src_b, kMaxTest, 5381);
+ uint32_t h1 = HashDjb2(src_a, kMaxTest, 5381);
+ uint32_t h2 = HashDjb2(src_b, kMaxTest, 5381);
EXPECT_NE(h1, h2);
// Make last half same. Expect hash is different.
@@ -116,15 +119,15 @@ TEST_F(LibYUVBaseTest, Djb2_Test) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, BenchmarkDjb2_Opt) {
+TEST_F(LibYUVCompareTest, BenchmarkDjb2_Opt) {
const int kMaxTest = benchmark_width_ * benchmark_height_;
align_buffer_page_end(src_a, kMaxTest);
for (int i = 0; i < kMaxTest; ++i) {
src_a[i] = i;
}
- uint32 h2 = ReferenceHashDjb2(src_a, kMaxTest, 5381);
- uint32 h1;
+ uint32_t h2 = ReferenceHashDjb2(src_a, kMaxTest, 5381);
+ uint32_t h1;
for (int i = 0; i < benchmark_iterations_; ++i) {
h1 = HashDjb2(src_a, kMaxTest, 5381);
}
@@ -132,14 +135,14 @@ TEST_F(LibYUVBaseTest, BenchmarkDjb2_Opt) {
free_aligned_buffer_page_end(src_a);
}
-TEST_F(LibYUVBaseTest, BenchmarkDjb2_Unaligned) {
+TEST_F(LibYUVCompareTest, BenchmarkDjb2_Unaligned) {
const int kMaxTest = benchmark_width_ * benchmark_height_;
align_buffer_page_end(src_a, kMaxTest + 1);
for (int i = 0; i < kMaxTest; ++i) {
src_a[i + 1] = i;
}
- uint32 h2 = ReferenceHashDjb2(src_a + 1, kMaxTest, 5381);
- uint32 h1;
+ uint32_t h2 = ReferenceHashDjb2(src_a + 1, kMaxTest, 5381);
+ uint32_t h1;
for (int i = 0; i < benchmark_iterations_; ++i) {
h1 = HashDjb2(src_a + 1, kMaxTest, 5381);
}
@@ -147,8 +150,8 @@ TEST_F(LibYUVBaseTest, BenchmarkDjb2_Unaligned) {
free_aligned_buffer_page_end(src_a);
}
-TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
- uint32 fourcc;
+TEST_F(LibYUVCompareTest, BenchmarkARGBDetect_Opt) {
+ uint32_t fourcc;
const int kMaxTest = benchmark_width_ * benchmark_height_ * 4;
align_buffer_page_end(src_a, kMaxTest);
for (int i = 0; i < kMaxTest; ++i) {
@@ -158,12 +161,12 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
src_a[0] = 0;
fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
benchmark_height_);
- EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_BGRA), fourcc);
+ EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_BGRA), fourcc);
src_a[0] = 255;
src_a[3] = 0;
fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
benchmark_height_);
- EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_ARGB), fourcc);
+ EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
src_a[3] = 255;
for (int i = 0; i < benchmark_iterations_; ++i) {
@@ -175,8 +178,8 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
free_aligned_buffer_page_end(src_a);
}
-TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
- uint32 fourcc;
+TEST_F(LibYUVCompareTest, BenchmarkARGBDetect_Unaligned) {
+ uint32_t fourcc;
const int kMaxTest = benchmark_width_ * benchmark_height_ * 4 + 1;
align_buffer_page_end(src_a, kMaxTest);
for (int i = 1; i < kMaxTest; ++i) {
@@ -186,12 +189,12 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
src_a[0 + 1] = 0;
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
benchmark_height_);
- EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_BGRA), fourcc);
+ EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_BGRA), fourcc);
src_a[0 + 1] = 255;
src_a[3 + 1] = 0;
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
benchmark_height_);
- EXPECT_EQ(static_cast<uint32>(libyuv::FOURCC_ARGB), fourcc);
+ EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
src_a[3 + 1] = 255;
for (int i = 0; i < benchmark_iterations_; ++i) {
@@ -202,7 +205,223 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
free_aligned_buffer_page_end(src_a);
}
-TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
+
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance_Opt) {
+ const int kMaxWidth = 4096 * 3;
+ align_buffer_page_end(src_a, kMaxWidth);
+ align_buffer_page_end(src_b, kMaxWidth);
+ memset(src_a, 0, kMaxWidth);
+ memset(src_b, 0, kMaxWidth);
+
+ // Test known value
+ memcpy(src_a, "test0123test4567", 16);
+ memcpy(src_b, "tick0123tock4567", 16);
+ uint32_t h1 = HammingDistance_C(src_a, src_b, 16);
+ EXPECT_EQ(16u, h1);
+
+ // Test C vs OPT on random buffer
+ MemRandomize(src_a, kMaxWidth);
+ MemRandomize(src_b, kMaxWidth);
+
+ uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+ int count =
+ benchmark_iterations_ *
+ ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+ for (int i = 0; i < count; ++i) {
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+ h1 = HammingDistance_NEON(src_a, src_b, kMaxWidth);
+#elif defined(HAS_HAMMINGDISTANCE_AVX2)
+ int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+ if (has_avx2) {
+ h1 = HammingDistance_AVX2(src_a, src_b, kMaxWidth);
+ } else {
+ int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+ if (has_sse42) {
+ h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+ } else {
+ int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+ if (has_ssse3) {
+ h1 = HammingDistance_SSSE3(src_a, src_b, kMaxWidth);
+ } else {
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+ }
+ }
+ }
+#elif defined(HAS_HAMMINGDISTANCE_SSE42)
+ int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+ if (has_sse42) {
+ h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+ } else {
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+ }
+#else
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+#endif
+ }
+ EXPECT_EQ(h0, h1);
+
+ free_aligned_buffer_page_end(src_a);
+ free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance_C) {
+ const int kMaxWidth = 4096 * 3;
+ align_buffer_page_end(src_a, kMaxWidth);
+ align_buffer_page_end(src_b, kMaxWidth);
+ memset(src_a, 0, kMaxWidth);
+ memset(src_b, 0, kMaxWidth);
+
+ // Test known value
+ memcpy(src_a, "test0123test4567", 16);
+ memcpy(src_b, "tick0123tock4567", 16);
+ uint32_t h1 = HammingDistance_C(src_a, src_b, 16);
+ EXPECT_EQ(16u, h1);
+
+ // Test C vs OPT on random buffer
+ MemRandomize(src_a, kMaxWidth);
+ MemRandomize(src_b, kMaxWidth);
+
+ uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+ int count =
+ benchmark_iterations_ *
+ ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+ for (int i = 0; i < count; ++i) {
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+ }
+
+ EXPECT_EQ(h0, h1);
+
+ free_aligned_buffer_page_end(src_a);
+ free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance) {
+ const int kMaxWidth = 4096 * 3;
+ align_buffer_page_end(src_a, kMaxWidth);
+ align_buffer_page_end(src_b, kMaxWidth);
+ memset(src_a, 0, kMaxWidth);
+ memset(src_b, 0, kMaxWidth);
+
+ memcpy(src_a, "test0123test4567", 16);
+ memcpy(src_b, "tick0123tock4567", 16);
+ uint64_t h1 = ComputeHammingDistance(src_a, src_b, 16);
+ EXPECT_EQ(16u, h1);
+
+ // Test C vs OPT on random buffer
+ MemRandomize(src_a, kMaxWidth);
+ MemRandomize(src_b, kMaxWidth);
+
+ uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+ int count =
+ benchmark_iterations_ *
+ ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+ for (int i = 0; i < count; ++i) {
+ h1 = ComputeHammingDistance(src_a, src_b, kMaxWidth);
+ }
+
+ EXPECT_EQ(h0, h1);
+
+ free_aligned_buffer_page_end(src_a);
+ free_aligned_buffer_page_end(src_b);
+}
+
+// Tests low levels match reference C for specified size.
+// The opt implementations have size limitations
+// For NEON the counters are 16 bit so the shorts overflow after 65536 bytes.
+// So doing one less iteration of the loop is the maximum.
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+static const int kMaxOptCount = 65536 - 32; // 65504
+#else
+static const int kMaxOptCount = (1 << (32 - 3)) - 64; // 536870848
+#endif
+
+TEST_F(LibYUVCompareTest, TestHammingDistance_Opt) {
+ uint32_t h1 = 0;
+ const int kMaxWidth = (benchmark_width_ * benchmark_height_ + 31) & ~31;
+ align_buffer_page_end(src_a, kMaxWidth);
+ align_buffer_page_end(src_b, kMaxWidth);
+ memset(src_a, 255u, kMaxWidth);
+ memset(src_b, 0u, kMaxWidth);
+
+ uint64_t h0 = ComputeHammingDistance(src_a, src_b, kMaxWidth);
+ EXPECT_EQ(kMaxWidth * 8ULL, h0);
+
+ for (int i = 0; i < benchmark_iterations_; ++i) {
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+ h1 = HammingDistance_NEON(src_a, src_b, kMaxWidth);
+#elif defined(HAS_HAMMINGDISTANCE_AVX2)
+ int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+ if (has_avx2) {
+ h1 = HammingDistance_AVX2(src_a, src_b, kMaxWidth);
+ } else {
+ int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+ if (has_sse42) {
+ h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+ } else {
+ int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+ if (has_ssse3) {
+ h1 = HammingDistance_SSSE3(src_a, src_b, kMaxWidth);
+ } else {
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+ }
+ }
+ }
+#elif defined(HAS_HAMMINGDISTANCE_SSE42)
+ int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+ if (has_sse42) {
+ h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+ } else {
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+ }
+#else
+ h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+#endif
+ }
+
+ // A large count will cause the low level to potentially overflow so the
+ // result can not be expected to be correct.
+ // TODO(fbarchard): Consider expecting the low 16 bits to match.
+ if (kMaxWidth <= kMaxOptCount) {
+ EXPECT_EQ(kMaxWidth * 8U, h1);
+ } else {
+ if (kMaxWidth * 8ULL != static_cast<uint64_t>(h1)) {
+ printf(
+ "warning - HammingDistance_Opt %u does not match %llu "
+ "but length of %u is longer than guaranteed.\n",
+ h1, kMaxWidth * 8ULL, kMaxWidth);
+ } else {
+ printf(
+ "warning - HammingDistance_Opt %u matches but length of %u "
+ "is longer than guaranteed.\n",
+ h1, kMaxWidth);
+ }
+ }
+
+ free_aligned_buffer_page_end(src_a);
+ free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, TestHammingDistance) {
+ align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
+ align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
+ memset(src_a, 255u, benchmark_width_ * benchmark_height_);
+ memset(src_b, 0, benchmark_width_ * benchmark_height_);
+
+ uint64_t h1 = 0;
+ for (int i = 0; i < benchmark_iterations_; ++i) {
+ h1 = ComputeHammingDistance(src_a, src_b,
+ benchmark_width_ * benchmark_height_);
+ }
+ EXPECT_EQ(benchmark_width_ * benchmark_height_ * 8ULL, h1);
+
+ free_aligned_buffer_page_end(src_a);
+ free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkSumSquareError_Opt) {
const int kMaxWidth = 4096 * 3;
align_buffer_page_end(src_a, kMaxWidth);
align_buffer_page_end(src_b, kMaxWidth);
@@ -211,7 +430,7 @@ TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
memcpy(src_a, "test0123test4567", 16);
memcpy(src_b, "tick0123tock4567", 16);
- uint64 h1 = ComputeSumSquareError(src_a, src_b, 16);
+ uint64_t h1 = ComputeSumSquareError(src_a, src_b, 16);
EXPECT_EQ(790u, h1);
for (int i = 0; i < kMaxWidth; ++i) {
@@ -234,14 +453,14 @@ TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, SumSquareError) {
+TEST_F(LibYUVCompareTest, SumSquareError) {
const int kMaxWidth = 4096 * 3;
align_buffer_page_end(src_a, kMaxWidth);
align_buffer_page_end(src_b, kMaxWidth);
memset(src_a, 0, kMaxWidth);
memset(src_b, 0, kMaxWidth);
- uint64 err;
+ uint64_t err;
err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
EXPECT_EQ(0u, err);
@@ -263,10 +482,10 @@ TEST_F(LibYUVBaseTest, SumSquareError) {
}
MaskCpuFlags(disable_cpu_flags_);
- uint64 c_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+ uint64_t c_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
MaskCpuFlags(benchmark_cpu_info_);
- uint64 opt_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+ uint64_t opt_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
EXPECT_EQ(c_err, opt_err);
@@ -274,7 +493,7 @@ TEST_F(LibYUVBaseTest, SumSquareError) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) {
+TEST_F(LibYUVCompareTest, BenchmarkPsnr_Opt) {
align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
@@ -285,9 +504,10 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) {
MaskCpuFlags(benchmark_cpu_info_);
double opt_time = get_time();
- for (int i = 0; i < benchmark_iterations_; ++i)
+ for (int i = 0; i < benchmark_iterations_; ++i) {
CalcFramePsnr(src_a, benchmark_width_, src_b, benchmark_width_,
benchmark_width_, benchmark_height_);
+ }
opt_time = (get_time() - opt_time) / benchmark_iterations_;
printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
@@ -298,7 +518,7 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) {
+TEST_F(LibYUVCompareTest, BenchmarkPsnr_Unaligned) {
align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_ + 1);
align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
@@ -309,9 +529,10 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) {
MaskCpuFlags(benchmark_cpu_info_);
double opt_time = get_time();
- for (int i = 0; i < benchmark_iterations_; ++i)
+ for (int i = 0; i < benchmark_iterations_; ++i) {
CalcFramePsnr(src_a + 1, benchmark_width_, src_b, benchmark_width_,
benchmark_width_, benchmark_height_);
+ }
opt_time = (get_time() - opt_time) / benchmark_iterations_;
printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
@@ -322,7 +543,7 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, Psnr) {
+TEST_F(LibYUVCompareTest, Psnr) {
const int kSrcWidth = benchmark_width_;
const int kSrcHeight = benchmark_height_;
const int b = 128;
@@ -399,7 +620,7 @@ TEST_F(LibYUVBaseTest, Psnr) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) {
+TEST_F(LibYUVCompareTest, DISABLED_BenchmarkSsim_Opt) {
align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
@@ -410,9 +631,10 @@ TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) {
MaskCpuFlags(benchmark_cpu_info_);
double opt_time = get_time();
- for (int i = 0; i < benchmark_iterations_; ++i)
+ for (int i = 0; i < benchmark_iterations_; ++i) {
CalcFrameSsim(src_a, benchmark_width_, src_b, benchmark_width_,
benchmark_width_, benchmark_height_);
+ }
opt_time = (get_time() - opt_time) / benchmark_iterations_;
printf("BenchmarkSsim_Opt - %8.2f us opt\n", opt_time * 1e6);
@@ -423,7 +645,7 @@ TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) {
free_aligned_buffer_page_end(src_b);
}
-TEST_F(LibYUVBaseTest, Ssim) {
+TEST_F(LibYUVCompareTest, Ssim) {
const int kSrcWidth = benchmark_width_;
const int kSrcHeight = benchmark_height_;
const int b = 128;
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-07 09:04:41 +0000