mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-25 09:57:32 +09:00
Issue #2101 - Part 3: Update libyuv
Updated to version 1861, git revision 88b050f337cc0ca2a51800fe7bf4737222c87344 from https://chromium.googlesource.com/libyuv/libyuv/
This commit is contained in:
u3shit
roytam1
parent
42f3296899
commit
a4d1f57b9e
222 changed files with 111006 additions and 37106 deletions
|
|
@ -18,11 +18,17 @@
|
|||
#include "libyuv/cpu_id.h"
|
||||
#include "libyuv/video_common.h"
|
||||
|
||||
#ifdef ENABLE_ROW_TESTS
|
||||
#include "libyuv/compare_row.h" /* For HammingDistance_C */
|
||||
#endif
|
||||
|
||||
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,16 +37,17 @@ 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);
|
||||
|
||||
const char* fox = "The quick brown fox jumps over the lazy dog"
|
||||
const char* fox =
|
||||
"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) {
|
||||
|
|
@ -48,8 +55,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.
|
||||
|
|
@ -115,15 +122,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);
|
||||
}
|
||||
|
|
@ -131,14 +138,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);
|
||||
}
|
||||
|
|
@ -146,8 +153,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) {
|
||||
|
|
@ -155,27 +162,27 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
|
|||
}
|
||||
|
||||
src_a[0] = 0;
|
||||
fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
|
||||
benchmark_width_, benchmark_height_);
|
||||
EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
|
||||
fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
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(libyuv::FOURCC_ARGB, fourcc);
|
||||
fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
|
||||
src_a[3] = 255;
|
||||
|
||||
for (int i = 0; i < benchmark_iterations_; ++i) {
|
||||
fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
|
||||
benchmark_width_, benchmark_height_);
|
||||
fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
}
|
||||
EXPECT_EQ(0, fourcc);
|
||||
EXPECT_EQ(0u, fourcc);
|
||||
|
||||
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) {
|
||||
|
|
@ -183,25 +190,118 @@ TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
|
|||
}
|
||||
|
||||
src_a[0 + 1] = 0;
|
||||
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
|
||||
benchmark_width_, benchmark_height_);
|
||||
EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
|
||||
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
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(libyuv::FOURCC_ARGB, fourcc);
|
||||
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
|
||||
src_a[3 + 1] = 255;
|
||||
|
||||
for (int i = 0; i < benchmark_iterations_; ++i) {
|
||||
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
|
||||
benchmark_width_, benchmark_height_);
|
||||
fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
|
||||
benchmark_height_);
|
||||
}
|
||||
EXPECT_EQ(0, fourcc);
|
||||
EXPECT_EQ(0u, fourcc);
|
||||
|
||||
free_aligned_buffer_page_end(src_a);
|
||||
}
|
||||
TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
|
||||
|
||||
#ifdef ENABLE_ROW_TESTS
|
||||
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);
|
||||
|
|
@ -210,7 +310,132 @@ 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 = 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_ + 63) & ~63;
|
||||
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);
|
||||
}
|
||||
#endif // ENABLE_ROW_TESTS
|
||||
|
||||
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);
|
||||
memset(src_a, 0, kMaxWidth);
|
||||
memset(src_b, 0, kMaxWidth);
|
||||
|
||||
memcpy(src_a, "test0123test4567", 16);
|
||||
memcpy(src_b, "tick0123tock4567", 16);
|
||||
uint64_t h1 = ComputeSumSquareError(src_a, src_b, 16);
|
||||
EXPECT_EQ(790u, h1);
|
||||
|
||||
for (int i = 0; i < kMaxWidth; ++i) {
|
||||
|
|
@ -220,40 +445,41 @@ TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
|
|||
memset(src_a, 0, kMaxWidth);
|
||||
memset(src_b, 0, kMaxWidth);
|
||||
|
||||
int count = benchmark_iterations_ *
|
||||
((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
|
||||
int count =
|
||||
benchmark_iterations_ *
|
||||
((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
|
||||
for (int i = 0; i < count; ++i) {
|
||||
h1 = ComputeSumSquareError(src_a, src_b, kMaxWidth);
|
||||
}
|
||||
|
||||
EXPECT_EQ(0, h1);
|
||||
EXPECT_EQ(0u, h1);
|
||||
|
||||
free_aligned_buffer_page_end(src_a);
|
||||
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(0, err);
|
||||
EXPECT_EQ(0u, err);
|
||||
|
||||
memset(src_a, 1, kMaxWidth);
|
||||
err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
|
||||
|
||||
EXPECT_EQ(err, kMaxWidth);
|
||||
EXPECT_EQ(static_cast<int>(err), kMaxWidth);
|
||||
|
||||
memset(src_a, 190, kMaxWidth);
|
||||
memset(src_b, 193, kMaxWidth);
|
||||
err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
|
||||
|
||||
EXPECT_EQ(kMaxWidth * 3 * 3, err);
|
||||
EXPECT_EQ(static_cast<int>(err), kMaxWidth * 3 * 3);
|
||||
|
||||
for (int i = 0; i < kMaxWidth; ++i) {
|
||||
src_a[i] = (fastrand() & 0xff);
|
||||
|
|
@ -261,10 +487,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);
|
||||
|
||||
|
|
@ -272,7 +498,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) {
|
||||
|
|
@ -283,10 +509,10 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) {
|
|||
MaskCpuFlags(benchmark_cpu_info_);
|
||||
|
||||
double opt_time = get_time();
|
||||
for (int i = 0; i < benchmark_iterations_; ++i)
|
||||
CalcFramePsnr(src_a, benchmark_width_,
|
||||
src_b, benchmark_width_,
|
||||
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);
|
||||
|
|
@ -297,7 +523,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) {
|
||||
|
|
@ -308,10 +534,10 @@ TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) {
|
|||
MaskCpuFlags(benchmark_cpu_info_);
|
||||
|
||||
double opt_time = get_time();
|
||||
for (int i = 0; i < benchmark_iterations_; ++i)
|
||||
CalcFramePsnr(src_a + 1, benchmark_width_,
|
||||
src_b, benchmark_width_,
|
||||
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 +548,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;
|
||||
|
|
@ -335,24 +561,24 @@ TEST_F(LibYUVBaseTest, Psnr) {
|
|||
|
||||
double err;
|
||||
err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
EXPECT_EQ(err, kMaxPsnr);
|
||||
|
||||
memset(src_a, 255, kSrcPlaneSize);
|
||||
|
||||
err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
EXPECT_EQ(err, 0.0);
|
||||
|
||||
memset(src_a, 1, kSrcPlaneSize);
|
||||
|
||||
err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
EXPECT_GT(err, 48.0);
|
||||
EXPECT_LT(err, 49.0);
|
||||
|
|
@ -362,8 +588,8 @@ TEST_F(LibYUVBaseTest, Psnr) {
|
|||
}
|
||||
|
||||
err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
EXPECT_GT(err, 2.0);
|
||||
if (kSrcWidth * kSrcHeight >= 256) {
|
||||
|
|
@ -384,14 +610,14 @@ TEST_F(LibYUVBaseTest, Psnr) {
|
|||
double c_err, opt_err;
|
||||
|
||||
c_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
MaskCpuFlags(benchmark_cpu_info_);
|
||||
|
||||
opt_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
EXPECT_EQ(opt_err, c_err);
|
||||
|
||||
|
|
@ -399,7 +625,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,10 +636,10 @@ TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) {
|
|||
MaskCpuFlags(benchmark_cpu_info_);
|
||||
|
||||
double opt_time = get_time();
|
||||
for (int i = 0; i < benchmark_iterations_; ++i)
|
||||
CalcFrameSsim(src_a, benchmark_width_,
|
||||
src_b, benchmark_width_,
|
||||
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);
|
||||
|
|
@ -424,7 +650,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;
|
||||
|
|
@ -435,14 +661,14 @@ TEST_F(LibYUVBaseTest, Ssim) {
|
|||
memset(src_a, 0, kSrcPlaneSize);
|
||||
memset(src_b, 0, kSrcPlaneSize);
|
||||
|
||||
if (kSrcWidth <=8 || kSrcHeight <= 8) {
|
||||
if (kSrcWidth <= 8 || kSrcHeight <= 8) {
|
||||
printf("warning - Ssim size too small. Testing function executes.\n");
|
||||
}
|
||||
|
||||
double err;
|
||||
err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
if (kSrcWidth > 8 && kSrcHeight > 8) {
|
||||
EXPECT_EQ(err, 1.0);
|
||||
|
|
@ -451,8 +677,8 @@ TEST_F(LibYUVBaseTest, Ssim) {
|
|||
memset(src_a, 255, kSrcPlaneSize);
|
||||
|
||||
err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
if (kSrcWidth > 8 && kSrcHeight > 8) {
|
||||
EXPECT_LT(err, 0.0001);
|
||||
|
|
@ -461,8 +687,8 @@ TEST_F(LibYUVBaseTest, Ssim) {
|
|||
memset(src_a, 1, kSrcPlaneSize);
|
||||
|
||||
err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
if (kSrcWidth > 8 && kSrcHeight > 8) {
|
||||
EXPECT_GT(err, 0.0001);
|
||||
|
|
@ -474,8 +700,8 @@ TEST_F(LibYUVBaseTest, Ssim) {
|
|||
}
|
||||
|
||||
err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
if (kSrcWidth > 8 && kSrcHeight > 8) {
|
||||
EXPECT_GT(err, 0.0);
|
||||
|
|
@ -493,14 +719,14 @@ TEST_F(LibYUVBaseTest, Ssim) {
|
|||
double c_err, opt_err;
|
||||
|
||||
c_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
MaskCpuFlags(benchmark_cpu_info_);
|
||||
|
||||
opt_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
|
||||
src_b + kSrcStride * b + b, kSrcStride,
|
||||
kSrcWidth, kSrcHeight);
|
||||
src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
|
||||
kSrcHeight);
|
||||
|
||||
if (kSrcWidth > 8 && kSrcHeight > 8) {
|
||||
EXPECT_EQ(opt_err, c_err);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue